src/libgno/GenoPro.cpp

   1
   2  //
   3  //  This file was automatically generated using XmlPlus xsd2cpp tool.
   4  //  Please do not edit.
   5  //
   6
   7 #include "libgno/GenoPro.h"
   8
   9 namespace libgno  {
  10
  11
  12   //constructor
  13
  14   GenoPro::GenoPro(ElementCreateArgs args):
  15       XMLSchema::XmlElement<anyType>(args),
  16
  17     _fsmAttrs(NULL),
  18     _fsmElems(NULL)
  19
  20     , _sequence(new sequence(this) )
  21
  22   {
  23     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
  24     initFSM();
  25     if(args.ownerDoc && args.ownerDoc->buildTree())
  26     {
  27       if(args.ownerDoc->createSample()) {
  28         _fsm->fireSampleEvents();
  29       }
  30       else {
  31         _fsm->fireRequiredEvents();
  32       }
  33     }
  34   }
  35
  36   void GenoPro::initFSM()
  37   {
  38     XsdFsmBasePtr fsmsAttrs[] = {
  39
  40       NULL
  41     };
  42
  43     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
  44
  45     _fsm->replaceContentFsm(_sequence);
  46
  47     _fsmAttrs = _fsm->attributeFsm();
  48     _fsmElems = _fsm->contentFsm();
  49
  50   }
  51
  52   /* element functions  */
  53
  54
  55   GenoPro::Software_ptr GenoPro::create_Software(FsmCbOptions& options)
  56   {
  57     static DOMStringPtr myName = new DOMString("Software");
  58     static DOMStringPtr myNsUri = new DOMString("libgno");
  59
  60     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
  61     GenoPro::Software_p node = XSD::createElementTmpl<Software, void*>(t);
  62
  63     _Software = node;
  64
  65     return node;
  66   }
  67
  68
  69   GenoPro::Software_p GenoPro::element_Software()
  70   {
  71     FSM::warnNullNode(_Software, "Software", "{}Software", 0);
  72     return _Software;
  73   }
  74
  75   void GenoPro::mark_present_Software()
  76   {
  77     return get_sequence()->mark_present_Software();
  78   }
  79
  80 #ifndef __GenoPro_Date_member_elems_fns
  81 #define __GenoPro_Date_member_elems_fns
  82
  83
  84   GenoPro::Date_ptr GenoPro::create_Date(FsmCbOptions& options)
  85   {
  86     static DOMStringPtr myName = new DOMString("Date");
  87     static DOMStringPtr myNsUri = new DOMString("libgno");
  88
  89     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
  90     GenoPro::Date_p node = XSD::createElementTmpl<Date, XMLSchema::Types::bt_string*>(t);
  91
  92     if(options.isSampleCreate && (node->stringValue() == "") ) {
  93       node->stringValue(node->sampleValue());
  94     }
  95
  96     _Date = node;
  97
  98     return node;
  99   }
 100
 101
 102   GenoPro::Date_p GenoPro::element_Date()
 103   {
 104     FSM::warnNullNode(_Date, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
 105     return _Date;
 106   }
 107
 108   void GenoPro::set_Date(DOMString val)
 109   {
 110     get_sequence()->set_Date(val);
 111   }
 112
 113   DOMString GenoPro::get_Date_string()
 114   {
 115     return get_sequence()->get_Date_string();
 116   }
 117
 118
 119   void GenoPro::mark_present_Date()
 120   {
 121     return get_sequence()->mark_present_Date();
 122   }
 123
 124 #endif // __GenoPro_Date_member_elems_fns
 125
 126
 127   GenoPro::Global_ptr GenoPro::create_Global(FsmCbOptions& options)
 128   {
 129     static DOMStringPtr myName = new DOMString("Global");
 130     static DOMStringPtr myNsUri = new DOMString("libgno");
 131
 132     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 133     GenoPro::Global_p node = XSD::createElementTmpl<Global, void*>(t);
 134
 135     _Global = node;
 136
 137     return node;
 138   }
 139
 140
 141   GenoPro::Global_p GenoPro::element_Global()
 142   {
 143     FSM::warnNullNode(_Global, "Global", "{}Global", 0);
 144     return _Global;
 145   }
 146
 147   void GenoPro::mark_present_Global()
 148   {
 149     return get_sequence()->mark_present_Global();
 150   }
 151
 152
 153   GenoPro::GenoMaps_ptr GenoPro::create_GenoMaps(FsmCbOptions& options)
 154   {
 155     static DOMStringPtr myName = new DOMString("GenoMaps");
 156     static DOMStringPtr myNsUri = new DOMString("libgno");
 157
 158     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 159     GenoPro::GenoMaps_p node = XSD::createElementTmpl<GenoMaps, void*>(t);
 160
 161     _GenoMaps = node;
 162
 163     return node;
 164   }
 165
 166
 167   GenoPro::GenoMaps_p GenoPro::element_GenoMaps()
 168   {
 169     FSM::warnNullNode(_GenoMaps, "GenoMaps", "{}GenoMaps", 0);
 170     return _GenoMaps;
 171   }
 172
 173   void GenoPro::mark_present_GenoMaps()
 174   {
 175     return get_sequence()->mark_present_GenoMaps();
 176   }
 177
 178
 179   GenoPro::Individuals_ptr GenoPro::create_Individuals(FsmCbOptions& options)
 180   {
 181     static DOMStringPtr myName = new DOMString("Individuals");
 182     static DOMStringPtr myNsUri = new DOMString("libgno");
 183
 184     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 185     GenoPro::Individuals_p node = XSD::createElementTmpl<Individuals, void*>(t);
 186
 187     _Individuals = node;
 188
 189     return node;
 190   }
 191
 192
 193   GenoPro::Individuals_p GenoPro::element_Individuals()
 194   {
 195     FSM::warnNullNode(_Individuals, "Individuals", "{}Individuals", 0);
 196     return _Individuals;
 197   }
 198
 199   void GenoPro::mark_present_Individuals()
 200   {
 201     return get_sequence()->mark_present_Individuals();
 202   }
 203
 204
 205   GenoPro::Families_ptr GenoPro::create_Families(FsmCbOptions& options)
 206   {
 207     static DOMStringPtr myName = new DOMString("Families");
 208     static DOMStringPtr myNsUri = new DOMString("libgno");
 209
 210     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 211     GenoPro::Families_p node = XSD::createElementTmpl<Families, void*>(t);
 212
 213     _Families = node;
 214
 215     return node;
 216   }
 217
 218
 219   GenoPro::Families_p GenoPro::element_Families()
 220   {
 221     FSM::warnNullNode(_Families, "Families", "{}Families", 0);
 222     return _Families;
 223   }
 224
 225   void GenoPro::mark_present_Families()
 226   {
 227     return get_sequence()->mark_present_Families();
 228   }
 229
 230
 231   GenoPro::Marriages_ptr GenoPro::create_Marriages(FsmCbOptions& options)
 232   {
 233     static DOMStringPtr myName = new DOMString("Marriages");
 234     static DOMStringPtr myNsUri = new DOMString("libgno");
 235
 236     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 237     GenoPro::Marriages_p node = XSD::createElementTmpl<Marriages, void*>(t);
 238
 239     _Marriages = node;
 240
 241     return node;
 242   }
 243
 244
 245   GenoPro::Marriages_p GenoPro::element_Marriages()
 246   {
 247     FSM::warnNullNode(_Marriages, "Marriages", "{}Marriages", 0);
 248     return _Marriages;
 249   }
 250
 251   void GenoPro::mark_present_Marriages()
 252   {
 253     return get_sequence()->mark_present_Marriages();
 254   }
 255
 256
 257   GenoPro::PedigreeLinks_ptr GenoPro::create_PedigreeLinks(FsmCbOptions& options)
 258   {
 259     static DOMStringPtr myName = new DOMString("PedigreeLinks");
 260     static DOMStringPtr myNsUri = new DOMString("libgno");
 261
 262     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 263     GenoPro::PedigreeLinks_p node = XSD::createElementTmpl<PedigreeLinks, void*>(t);
 264
 265     _PedigreeLinks = node;
 266
 267     return node;
 268   }
 269
 270
 271   GenoPro::PedigreeLinks_p GenoPro::element_PedigreeLinks()
 272   {
 273     FSM::warnNullNode(_PedigreeLinks, "PedigreeLinks", "{}PedigreeLinks", 0);
 274     return _PedigreeLinks;
 275   }
 276
 277   void GenoPro::mark_present_PedigreeLinks()
 278   {
 279     return get_sequence()->mark_present_PedigreeLinks();
 280   }
 281
 282 #ifndef __GenoPro_Pictures_member_elems_fns
 283 #define __GenoPro_Pictures_member_elems_fns
 284
 285
 286   GenoPro::Pictures_ptr GenoPro::create_Pictures(FsmCbOptions& options)
 287   {
 288     static DOMStringPtr myName = new DOMString("Pictures");
 289     static DOMStringPtr myNsUri = new DOMString("libgno");
 290
 291     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 292     GenoPro::Pictures_p node = XSD::createElementTmpl<Pictures, void*>(t);
 293
 294     _Pictures = node;
 295
 296     return node;
 297   }
 298
 299
 300   GenoPro::Pictures_p GenoPro::element_Pictures()
 301   {
 302     FSM::warnNullNode(_Pictures, "Pictures", "{}Pictures", 0);
 303     return _Pictures;
 304   }
 305
 306   void GenoPro::mark_present_Pictures()
 307   {
 308     return get_sequence()->mark_present_Pictures();
 309   }
 310
 311 #endif // __GenoPro_Pictures_member_elems_fns
 312
 313
 314   GenoPro::Places_ptr GenoPro::create_Places(FsmCbOptions& options)
 315   {
 316     static DOMStringPtr myName = new DOMString("Places");
 317     static DOMStringPtr myNsUri = new DOMString("libgno");
 318
 319     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 320     GenoPro::Places_p node = XSD::createElementTmpl<Places, void*>(t);
 321
 322     _Places = node;
 323
 324     return node;
 325   }
 326
 327
 328   GenoPro::Places_p GenoPro::element_Places()
 329   {
 330     FSM::warnNullNode(_Places, "Places", "{}Places", 0);
 331     return _Places;
 332   }
 333
 334   void GenoPro::mark_present_Places()
 335   {
 336     return get_sequence()->mark_present_Places();
 337   }
 338
 339
 340   GenoPro::Educations_ptr GenoPro::create_Educations(FsmCbOptions& options)
 341   {
 342     static DOMStringPtr myName = new DOMString("Educations");
 343     static DOMStringPtr myNsUri = new DOMString("libgno");
 344
 345     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 346     GenoPro::Educations_p node = XSD::createElementTmpl<Educations, void*>(t);
 347
 348     _Educations = node;
 349
 350     return node;
 351   }
 352
 353
 354   GenoPro::Educations_p GenoPro::element_Educations()
 355   {
 356     FSM::warnNullNode(_Educations, "Educations", "{}Educations", 0);
 357     return _Educations;
 358   }
 359
 360   void GenoPro::mark_present_Educations()
 361   {
 362     return get_sequence()->mark_present_Educations();
 363   }
 364
 365
 366   GenoPro::Occupations_ptr GenoPro::create_Occupations(FsmCbOptions& options)
 367   {
 368     static DOMStringPtr myName = new DOMString("Occupations");
 369     static DOMStringPtr myNsUri = new DOMString("libgno");
 370
 371     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 372     GenoPro::Occupations_p node = XSD::createElementTmpl<Occupations, void*>(t);
 373
 374     _Occupations = node;
 375
 376     return node;
 377   }
 378
 379
 380   GenoPro::Occupations_p GenoPro::element_Occupations()
 381   {
 382     FSM::warnNullNode(_Occupations, "Occupations", "{}Occupations", 0);
 383     return _Occupations;
 384   }
 385
 386   void GenoPro::mark_present_Occupations()
 387   {
 388     return get_sequence()->mark_present_Occupations();
 389   }
 390
 391
 392   GenoPro::Contacts_ptr GenoPro::create_Contacts(FsmCbOptions& options)
 393   {
 394     static DOMStringPtr myName = new DOMString("Contacts");
 395     static DOMStringPtr myNsUri = new DOMString("libgno");
 396
 397     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 398     GenoPro::Contacts_p node = XSD::createElementTmpl<Contacts, void*>(t);
 399
 400     _Contacts = node;
 401
 402     return node;
 403   }
 404
 405
 406   GenoPro::Contacts_p GenoPro::element_Contacts()
 407   {
 408     FSM::warnNullNode(_Contacts, "Contacts", "{}Contacts", 0);
 409     return _Contacts;
 410   }
 411
 412   void GenoPro::mark_present_Contacts()
 413   {
 414     return get_sequence()->mark_present_Contacts();
 415   }
 416
 417
 418   GenoPro::SourcesAndCitations_ptr GenoPro::create_SourcesAndCitations(FsmCbOptions& options)
 419   {
 420     static DOMStringPtr myName = new DOMString("SourcesAndCitations");
 421     static DOMStringPtr myNsUri = new DOMString("libgno");
 422
 423     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 424     GenoPro::SourcesAndCitations_p node = XSD::createElementTmpl<SourcesAndCitations, void*>(t);
 425
 426     _SourcesAndCitations = node;
 427
 428     return node;
 429   }
 430
 431
 432   GenoPro::SourcesAndCitations_p GenoPro::element_SourcesAndCitations()
 433   {
 434     FSM::warnNullNode(_SourcesAndCitations, "SourcesAndCitations", "{}SourcesAndCitations", 0);
 435     return _SourcesAndCitations;
 436   }
 437
 438   void GenoPro::mark_present_SourcesAndCitations()
 439   {
 440     return get_sequence()->mark_present_SourcesAndCitations();
 441   }
 442
 443
 444   GenoPro::Twins_ptr GenoPro::create_Twins(FsmCbOptions& options)
 445   {
 446     static DOMStringPtr myName = new DOMString("Twins");
 447     static DOMStringPtr myNsUri = new DOMString("libgno");
 448
 449     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 450     GenoPro::Twins_p node = XSD::createElementTmpl<Twins, void*>(t);
 451
 452     _Twins = node;
 453
 454     return node;
 455   }
 456
 457
 458   GenoPro::Twins_p GenoPro::element_Twins()
 459   {
 460     FSM::warnNullNode(_Twins, "Twins", "{}Twins", 0);
 461     return _Twins;
 462   }
 463
 464   void GenoPro::mark_present_Twins()
 465   {
 466     return get_sequence()->mark_present_Twins();
 467   }
 468
 469
 470   GenoPro::Shapes_ptr GenoPro::create_Shapes(FsmCbOptions& options)
 471   {
 472     static DOMStringPtr myName = new DOMString("Shapes");
 473     static DOMStringPtr myNsUri = new DOMString("libgno");
 474
 475     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 476     GenoPro::Shapes_p node = XSD::createElementTmpl<Shapes, void*>(t);
 477
 478     _Shapes = node;
 479
 480     return node;
 481   }
 482
 483
 484   GenoPro::Shapes_p GenoPro::element_Shapes()
 485   {
 486     FSM::warnNullNode(_Shapes, "Shapes", "{}Shapes", 0);
 487     return _Shapes;
 488   }
 489
 490   void GenoPro::mark_present_Shapes()
 491   {
 492     return get_sequence()->mark_present_Shapes();
 493   }
 494
 495
 496   GenoPro::SocialRelationships_ptr GenoPro::create_SocialRelationships(FsmCbOptions& options)
 497   {
 498     static DOMStringPtr myName = new DOMString("SocialRelationships");
 499     static DOMStringPtr myNsUri = new DOMString("libgno");
 500
 501     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
 502     GenoPro::SocialRelationships_p node = XSD::createElementTmpl<SocialRelationships, void*>(t);
 503
 504     _SocialRelationships = node;
 505
 506     return node;
 507   }
 508
 509
 510   GenoPro::SocialRelationships_p GenoPro::element_SocialRelationships()
 511   {
 512     FSM::warnNullNode(_SocialRelationships, "SocialRelationships", "{}SocialRelationships", 0);
 513     return _SocialRelationships;
 514   }
 515
 516   void GenoPro::mark_present_SocialRelationships()
 517   {
 518     return get_sequence()->mark_present_SocialRelationships();
 519   }
 520
 521
 522   /* attribute  functions  */
 523
 524   //constructor
 525   GenoPro::sequence::sequence(GenoPro* that):
 526     _that(that)
 527   {
 528     XsdFsmBasePtr fsmArray[] = {
 529     new XsdFSM<Software_ptr>( Particle(new DOMString("libgno"), DOMString("Software"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Software_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Software)),
 530       new XsdFSM<Date_ptr>( Particle(new DOMString("libgno"), DOMString("Date"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Date_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Date)),
 531       new XsdFSM<Global_ptr>( Particle(new DOMString("libgno"), DOMString("Global"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Global_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Global)),
 532       new XsdFSM<GenoMaps_ptr>( Particle(new DOMString("libgno"), DOMString("GenoMaps"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<GenoMaps_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_GenoMaps)),
 533       new XsdFSM<Individuals_ptr>( Particle(new DOMString("libgno"), DOMString("Individuals"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Individuals_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Individuals)),
 534       new XsdFSM<Families_ptr>( Particle(new DOMString("libgno"), DOMString("Families"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Families_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Families)),
 535       new XsdFSM<Marriages_ptr>( Particle(new DOMString("libgno"), DOMString("Marriages"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Marriages_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Marriages)),
 536       new XsdFSM<PedigreeLinks_ptr>( Particle(new DOMString("libgno"), DOMString("PedigreeLinks"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<PedigreeLinks_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_PedigreeLinks)),
 537       new XsdFSM<Pictures_ptr>( Particle(new DOMString("libgno"), DOMString("Pictures"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Pictures_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Pictures)),
 538       new XsdFSM<Places_ptr>( Particle(new DOMString("libgno"), DOMString("Places"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Places_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Places)),
 539       new XsdFSM<Educations_ptr>( Particle(new DOMString("libgno"), DOMString("Educations"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Educations_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Educations)),
 540       new XsdFSM<Occupations_ptr>( Particle(new DOMString("libgno"), DOMString("Occupations"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Occupations_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Occupations)),
 541       new XsdFSM<Contacts_ptr>( Particle(new DOMString("libgno"), DOMString("Contacts"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Contacts_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Contacts)),
 542       new XsdFSM<SourcesAndCitations_ptr>( Particle(new DOMString("libgno"), DOMString("SourcesAndCitations"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<SourcesAndCitations_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_SourcesAndCitations)),
 543       new XsdFSM<Twins_ptr>( Particle(new DOMString("libgno"), DOMString("Twins"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Twins_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Twins)),
 544       new XsdFSM<Shapes_ptr>( Particle(new DOMString("libgno"), DOMString("Shapes"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Shapes_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_Shapes)),
 545       new XsdFSM<SocialRelationships_ptr>( Particle(new DOMString("libgno"), DOMString("SocialRelationships"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<SocialRelationships_ptr, GenoPro, FsmCbOptions>(_that, &GenoPro::create_SocialRelationships)),
 546
 547       NULL
 548     } ;
 549
 550     XsdSequenceFsmOfFSMs::init(fsmArray);
 551   }
 552
 553
 554
 555   GenoPro::Software_p GenoPro::sequence::element_Software()
 556   {
 557       GenoPro::Software_p node_p = NULL;
 558     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
 559     if(fsm_p)
 560     {
 561       XsdFSM<Software_ptr> *unitFsm = dynamic_cast<XsdFSM<Software_ptr> *>(fsm_p);
 562       if(unitFsm && unitFsm->nodeList().size()>0) {
 563         assert(unitFsm->nodeList().size()==1);
 564         node_p = unitFsm->nodeList().at(0);
 565       }
 566     }
 567
 568     FSM::warnNullNode(node_p, "Software", "{}Software", 0);
 569     return node_p;
 570
 571   }
 572
 573
 574
 575   void GenoPro::sequence::mark_present_Software()
 576   {
 577     DOMStringPtr nsUriPtr = new DOMString("libgno");
 578     XsdEvent event(nsUriPtr, NULL, DOMString("Software"), XsdEvent::ELEMENT_START, false);
 579     this->processEventThrow(event);
 580   }
 581
 582
 583
 584   GenoPro::Date_p GenoPro::sequence::element_Date()
 585   {
 586       GenoPro::Date_p node_p = NULL;
 587     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
 588     if(fsm_p)
 589     {
 590       XsdFSM<Date_ptr> *unitFsm = dynamic_cast<XsdFSM<Date_ptr> *>(fsm_p);
 591       if(unitFsm && unitFsm->nodeList().size()>0) {
 592         assert(unitFsm->nodeList().size()==1);
 593         node_p = unitFsm->nodeList().at(0);
 594       }
 595     }
 596
 597     FSM::warnNullNode(node_p, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
 598     return node_p;
 599
 600   }
 601
 602
 603   void GenoPro::sequence::set_Date(DOMString val)
 604   {
 605
 606     mark_present_Date();
 607
 608     element_Date()->stringValue(val);
 609   }
 610
 611   DOMString GenoPro::sequence::get_Date_string()
 612   {
 613     return element_Date()->stringValue();
 614   }
 615
 616
 617
 618   void GenoPro::sequence::mark_present_Date()
 619   {
 620     DOMStringPtr nsUriPtr = new DOMString("libgno");
 621     XsdEvent event(nsUriPtr, NULL, DOMString("Date"), XsdEvent::ELEMENT_START, false);
 622     this->processEventThrow(event);
 623   }
 624
 625
 626
 627   GenoPro::Global_p GenoPro::sequence::element_Global()
 628   {
 629       GenoPro::Global_p node_p = NULL;
 630     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
 631     if(fsm_p)
 632     {
 633       XsdFSM<Global_ptr> *unitFsm = dynamic_cast<XsdFSM<Global_ptr> *>(fsm_p);
 634       if(unitFsm && unitFsm->nodeList().size()>0) {
 635         assert(unitFsm->nodeList().size()==1);
 636         node_p = unitFsm->nodeList().at(0);
 637       }
 638     }
 639
 640     FSM::warnNullNode(node_p, "Global", "{}Global", 0);
 641     return node_p;
 642
 643   }
 644
 645
 646
 647   void GenoPro::sequence::mark_present_Global()
 648   {
 649     DOMStringPtr nsUriPtr = new DOMString("libgno");
 650     XsdEvent event(nsUriPtr, NULL, DOMString("Global"), XsdEvent::ELEMENT_START, false);
 651     this->processEventThrow(event);
 652   }
 653
 654
 655
 656   GenoPro::GenoMaps_p GenoPro::sequence::element_GenoMaps()
 657   {
 658       GenoPro::GenoMaps_p node_p = NULL;
 659     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
 660     if(fsm_p)
 661     {
 662       XsdFSM<GenoMaps_ptr> *unitFsm = dynamic_cast<XsdFSM<GenoMaps_ptr> *>(fsm_p);
 663       if(unitFsm && unitFsm->nodeList().size()>0) {
 664         assert(unitFsm->nodeList().size()==1);
 665         node_p = unitFsm->nodeList().at(0);
 666       }
 667     }
 668
 669     FSM::warnNullNode(node_p, "GenoMaps", "{}GenoMaps", 0);
 670     return node_p;
 671
 672   }
 673
 674
 675
 676   void GenoPro::sequence::mark_present_GenoMaps()
 677   {
 678     DOMStringPtr nsUriPtr = new DOMString("libgno");
 679     XsdEvent event(nsUriPtr, NULL, DOMString("GenoMaps"), XsdEvent::ELEMENT_START, false);
 680     this->processEventThrow(event);
 681   }
 682
 683
 684
 685   GenoPro::Individuals_p GenoPro::sequence::element_Individuals()
 686   {
 687       GenoPro::Individuals_p node_p = NULL;
 688     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
 689     if(fsm_p)
 690     {
 691       XsdFSM<Individuals_ptr> *unitFsm = dynamic_cast<XsdFSM<Individuals_ptr> *>(fsm_p);
 692       if(unitFsm && unitFsm->nodeList().size()>0) {
 693         assert(unitFsm->nodeList().size()==1);
 694         node_p = unitFsm->nodeList().at(0);
 695       }
 696     }
 697
 698     FSM::warnNullNode(node_p, "Individuals", "{}Individuals", 0);
 699     return node_p;
 700
 701   }
 702
 703
 704
 705   void GenoPro::sequence::mark_present_Individuals()
 706   {
 707     DOMStringPtr nsUriPtr = new DOMString("libgno");
 708     XsdEvent event(nsUriPtr, NULL, DOMString("Individuals"), XsdEvent::ELEMENT_START, false);
 709     this->processEventThrow(event);
 710   }
 711
 712
 713
 714   GenoPro::Families_p GenoPro::sequence::element_Families()
 715   {
 716       GenoPro::Families_p node_p = NULL;
 717     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
 718     if(fsm_p)
 719     {
 720       XsdFSM<Families_ptr> *unitFsm = dynamic_cast<XsdFSM<Families_ptr> *>(fsm_p);
 721       if(unitFsm && unitFsm->nodeList().size()>0) {
 722         assert(unitFsm->nodeList().size()==1);
 723         node_p = unitFsm->nodeList().at(0);
 724       }
 725     }
 726
 727     FSM::warnNullNode(node_p, "Families", "{}Families", 0);
 728     return node_p;
 729
 730   }
 731
 732
 733
 734   void GenoPro::sequence::mark_present_Families()
 735   {
 736     DOMStringPtr nsUriPtr = new DOMString("libgno");
 737     XsdEvent event(nsUriPtr, NULL, DOMString("Families"), XsdEvent::ELEMENT_START, false);
 738     this->processEventThrow(event);
 739   }
 740
 741
 742
 743   GenoPro::Marriages_p GenoPro::sequence::element_Marriages()
 744   {
 745       GenoPro::Marriages_p node_p = NULL;
 746     XsdFsmBase* fsm_p = this->allFSMs()[6].get();
 747     if(fsm_p)
 748     {
 749       XsdFSM<Marriages_ptr> *unitFsm = dynamic_cast<XsdFSM<Marriages_ptr> *>(fsm_p);
 750       if(unitFsm && unitFsm->nodeList().size()>0) {
 751         assert(unitFsm->nodeList().size()==1);
 752         node_p = unitFsm->nodeList().at(0);
 753       }
 754     }
 755
 756     FSM::warnNullNode(node_p, "Marriages", "{}Marriages", 0);
 757     return node_p;
 758
 759   }
 760
 761
 762
 763   void GenoPro::sequence::mark_present_Marriages()
 764   {
 765     DOMStringPtr nsUriPtr = new DOMString("libgno");
 766     XsdEvent event(nsUriPtr, NULL, DOMString("Marriages"), XsdEvent::ELEMENT_START, false);
 767     this->processEventThrow(event);
 768   }
 769
 770
 771
 772   GenoPro::PedigreeLinks_p GenoPro::sequence::element_PedigreeLinks()
 773   {
 774       GenoPro::PedigreeLinks_p node_p = NULL;
 775     XsdFsmBase* fsm_p = this->allFSMs()[7].get();
 776     if(fsm_p)
 777     {
 778       XsdFSM<PedigreeLinks_ptr> *unitFsm = dynamic_cast<XsdFSM<PedigreeLinks_ptr> *>(fsm_p);
 779       if(unitFsm && unitFsm->nodeList().size()>0) {
 780         assert(unitFsm->nodeList().size()==1);
 781         node_p = unitFsm->nodeList().at(0);
 782       }
 783     }
 784
 785     FSM::warnNullNode(node_p, "PedigreeLinks", "{}PedigreeLinks", 0);
 786     return node_p;
 787
 788   }
 789
 790
 791
 792   void GenoPro::sequence::mark_present_PedigreeLinks()
 793   {
 794     DOMStringPtr nsUriPtr = new DOMString("libgno");
 795     XsdEvent event(nsUriPtr, NULL, DOMString("PedigreeLinks"), XsdEvent::ELEMENT_START, false);
 796     this->processEventThrow(event);
 797   }
 798
 799
 800
 801   GenoPro::Pictures_p GenoPro::sequence::element_Pictures()
 802   {
 803       GenoPro::Pictures_p node_p = NULL;
 804     XsdFsmBase* fsm_p = this->allFSMs()[8].get();
 805     if(fsm_p)
 806     {
 807       XsdFSM<Pictures_ptr> *unitFsm = dynamic_cast<XsdFSM<Pictures_ptr> *>(fsm_p);
 808       if(unitFsm && unitFsm->nodeList().size()>0) {
 809         assert(unitFsm->nodeList().size()==1);
 810         node_p = unitFsm->nodeList().at(0);
 811       }
 812     }
 813
 814     FSM::warnNullNode(node_p, "Pictures", "{}Pictures", 0);
 815     return node_p;
 816
 817   }
 818
 819
 820
 821   void GenoPro::sequence::mark_present_Pictures()
 822   {
 823     DOMStringPtr nsUriPtr = new DOMString("libgno");
 824     XsdEvent event(nsUriPtr, NULL, DOMString("Pictures"), XsdEvent::ELEMENT_START, false);
 825     this->processEventThrow(event);
 826   }
 827
 828
 829
 830   GenoPro::Places_p GenoPro::sequence::element_Places()
 831   {
 832       GenoPro::Places_p node_p = NULL;
 833     XsdFsmBase* fsm_p = this->allFSMs()[9].get();
 834     if(fsm_p)
 835     {
 836       XsdFSM<Places_ptr> *unitFsm = dynamic_cast<XsdFSM<Places_ptr> *>(fsm_p);
 837       if(unitFsm && unitFsm->nodeList().size()>0) {
 838         assert(unitFsm->nodeList().size()==1);
 839         node_p = unitFsm->nodeList().at(0);
 840       }
 841     }
 842
 843     FSM::warnNullNode(node_p, "Places", "{}Places", 0);
 844     return node_p;
 845
 846   }
 847
 848
 849
 850   void GenoPro::sequence::mark_present_Places()
 851   {
 852     DOMStringPtr nsUriPtr = new DOMString("libgno");
 853     XsdEvent event(nsUriPtr, NULL, DOMString("Places"), XsdEvent::ELEMENT_START, false);
 854     this->processEventThrow(event);
 855   }
 856
 857
 858
 859   GenoPro::Educations_p GenoPro::sequence::element_Educations()
 860   {
 861       GenoPro::Educations_p node_p = NULL;
 862     XsdFsmBase* fsm_p = this->allFSMs()[10].get();
 863     if(fsm_p)
 864     {
 865       XsdFSM<Educations_ptr> *unitFsm = dynamic_cast<XsdFSM<Educations_ptr> *>(fsm_p);
 866       if(unitFsm && unitFsm->nodeList().size()>0) {
 867         assert(unitFsm->nodeList().size()==1);
 868         node_p = unitFsm->nodeList().at(0);
 869       }
 870     }
 871
 872     FSM::warnNullNode(node_p, "Educations", "{}Educations", 0);
 873     return node_p;
 874
 875   }
 876
 877
 878
 879   void GenoPro::sequence::mark_present_Educations()
 880   {
 881     DOMStringPtr nsUriPtr = new DOMString("libgno");
 882     XsdEvent event(nsUriPtr, NULL, DOMString("Educations"), XsdEvent::ELEMENT_START, false);
 883     this->processEventThrow(event);
 884   }
 885
 886
 887
 888   GenoPro::Occupations_p GenoPro::sequence::element_Occupations()
 889   {
 890       GenoPro::Occupations_p node_p = NULL;
 891     XsdFsmBase* fsm_p = this->allFSMs()[11].get();
 892     if(fsm_p)
 893     {
 894       XsdFSM<Occupations_ptr> *unitFsm = dynamic_cast<XsdFSM<Occupations_ptr> *>(fsm_p);
 895       if(unitFsm && unitFsm->nodeList().size()>0) {
 896         assert(unitFsm->nodeList().size()==1);
 897         node_p = unitFsm->nodeList().at(0);
 898       }
 899     }
 900
 901     FSM::warnNullNode(node_p, "Occupations", "{}Occupations", 0);
 902     return node_p;
 903
 904   }
 905
 906
 907
 908   void GenoPro::sequence::mark_present_Occupations()
 909   {
 910     DOMStringPtr nsUriPtr = new DOMString("libgno");
 911     XsdEvent event(nsUriPtr, NULL, DOMString("Occupations"), XsdEvent::ELEMENT_START, false);
 912     this->processEventThrow(event);
 913   }
 914
 915
 916
 917   GenoPro::Contacts_p GenoPro::sequence::element_Contacts()
 918   {
 919       GenoPro::Contacts_p node_p = NULL;
 920     XsdFsmBase* fsm_p = this->allFSMs()[12].get();
 921     if(fsm_p)
 922     {
 923       XsdFSM<Contacts_ptr> *unitFsm = dynamic_cast<XsdFSM<Contacts_ptr> *>(fsm_p);
 924       if(unitFsm && unitFsm->nodeList().size()>0) {
 925         assert(unitFsm->nodeList().size()==1);
 926         node_p = unitFsm->nodeList().at(0);
 927       }
 928     }
 929
 930     FSM::warnNullNode(node_p, "Contacts", "{}Contacts", 0);
 931     return node_p;
 932
 933   }
 934
 935
 936
 937   void GenoPro::sequence::mark_present_Contacts()
 938   {
 939     DOMStringPtr nsUriPtr = new DOMString("libgno");
 940     XsdEvent event(nsUriPtr, NULL, DOMString("Contacts"), XsdEvent::ELEMENT_START, false);
 941     this->processEventThrow(event);
 942   }
 943
 944
 945
 946   GenoPro::SourcesAndCitations_p GenoPro::sequence::element_SourcesAndCitations()
 947   {
 948       GenoPro::SourcesAndCitations_p node_p = NULL;
 949     XsdFsmBase* fsm_p = this->allFSMs()[13].get();
 950     if(fsm_p)
 951     {
 952       XsdFSM<SourcesAndCitations_ptr> *unitFsm = dynamic_cast<XsdFSM<SourcesAndCitations_ptr> *>(fsm_p);
 953       if(unitFsm && unitFsm->nodeList().size()>0) {
 954         assert(unitFsm->nodeList().size()==1);
 955         node_p = unitFsm->nodeList().at(0);
 956       }
 957     }
 958
 959     FSM::warnNullNode(node_p, "SourcesAndCitations", "{}SourcesAndCitations", 0);
 960     return node_p;
 961
 962   }
 963
 964
 965
 966   void GenoPro::sequence::mark_present_SourcesAndCitations()
 967   {
 968     DOMStringPtr nsUriPtr = new DOMString("libgno");
 969     XsdEvent event(nsUriPtr, NULL, DOMString("SourcesAndCitations"), XsdEvent::ELEMENT_START, false);
 970     this->processEventThrow(event);
 971   }
 972
 973
 974
 975   GenoPro::Twins_p GenoPro::sequence::element_Twins()
 976   {
 977       GenoPro::Twins_p node_p = NULL;
 978     XsdFsmBase* fsm_p = this->allFSMs()[14].get();
 979     if(fsm_p)
 980     {
 981       XsdFSM<Twins_ptr> *unitFsm = dynamic_cast<XsdFSM<Twins_ptr> *>(fsm_p);
 982       if(unitFsm && unitFsm->nodeList().size()>0) {
 983         assert(unitFsm->nodeList().size()==1);
 984         node_p = unitFsm->nodeList().at(0);
 985       }
 986     }
 987
 988     FSM::warnNullNode(node_p, "Twins", "{}Twins", 0);
 989     return node_p;
 990
 991   }
 992
 993
 994
 995   void GenoPro::sequence::mark_present_Twins()
 996   {
 997     DOMStringPtr nsUriPtr = new DOMString("libgno");
 998     XsdEvent event(nsUriPtr, NULL, DOMString("Twins"), XsdEvent::ELEMENT_START, false);
 999     this->processEventThrow(event);
1000   }
1001
1002
1003
1004   GenoPro::Shapes_p GenoPro::sequence::element_Shapes()
1005   {
1006       GenoPro::Shapes_p node_p = NULL;
1007     XsdFsmBase* fsm_p = this->allFSMs()[15].get();
1008     if(fsm_p)
1009     {
1010       XsdFSM<Shapes_ptr> *unitFsm = dynamic_cast<XsdFSM<Shapes_ptr> *>(fsm_p);
1011       if(unitFsm && unitFsm->nodeList().size()>0) {
1012         assert(unitFsm->nodeList().size()==1);
1013         node_p = unitFsm->nodeList().at(0);
1014       }
1015     }
1016
1017     FSM::warnNullNode(node_p, "Shapes", "{}Shapes", 0);
1018     return node_p;
1019
1020   }
1021
1022
1023
1024   void GenoPro::sequence::mark_present_Shapes()
1025   {
1026     DOMStringPtr nsUriPtr = new DOMString("libgno");
1027     XsdEvent event(nsUriPtr, NULL, DOMString("Shapes"), XsdEvent::ELEMENT_START, false);
1028     this->processEventThrow(event);
1029   }
1030
1031
1032
1033   GenoPro::SocialRelationships_p GenoPro::sequence::element_SocialRelationships()
1034   {
1035       GenoPro::SocialRelationships_p node_p = NULL;
1036     XsdFsmBase* fsm_p = this->allFSMs()[16].get();
1037     if(fsm_p)
1038     {
1039       XsdFSM<SocialRelationships_ptr> *unitFsm = dynamic_cast<XsdFSM<SocialRelationships_ptr> *>(fsm_p);
1040       if(unitFsm && unitFsm->nodeList().size()>0) {
1041         assert(unitFsm->nodeList().size()==1);
1042         node_p = unitFsm->nodeList().at(0);
1043       }
1044     }
1045
1046     FSM::warnNullNode(node_p, "SocialRelationships", "{}SocialRelationships", 0);
1047     return node_p;
1048
1049   }
1050
1051
1052
1053   void GenoPro::sequence::mark_present_SocialRelationships()
1054   {
1055     DOMStringPtr nsUriPtr = new DOMString("libgno");
1056     XsdEvent event(nsUriPtr, NULL, DOMString("SocialRelationships"), XsdEvent::ELEMENT_START, false);
1057     this->processEventThrow(event);
1058   }
1059
1060
1061
1062   //constructor
1063
1064   GenoPro::Software::Software(ElementCreateArgs args):
1065       XMLSchema::XmlElement<anyType>(args),
1066
1067     _fsmAttrs(NULL),
1068     _fsmElems(NULL)
1069
1070     , _sequence(new sequence(this) )
1071
1072   {
1073     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
1074     initFSM();
1075     if(args.ownerDoc && args.ownerDoc->buildTree())
1076     {
1077       if(args.ownerDoc->createSample()) {
1078         _fsm->fireSampleEvents();
1079       }
1080       else {
1081         _fsm->fireRequiredEvents();
1082       }
1083     }
1084   }
1085
1086   void GenoPro::Software::initFSM()
1087   {
1088     XsdFsmBasePtr fsmsAttrs[] = {
1089
1090       NULL
1091     };
1092
1093     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
1094
1095     _fsm->replaceContentFsm(_sequence);
1096
1097     _fsmAttrs = _fsm->attributeFsm();
1098     _fsmElems = _fsm->contentFsm();
1099
1100   }
1101
1102   /* element functions  */
1103
1104
1105   GenoPro::Software::Name_ptr GenoPro::Software::create_Name(FsmCbOptions& options)
1106   {
1107     static DOMStringPtr myName = new DOMString("Name");
1108     static DOMStringPtr myNsUri = new DOMString("libgno");
1109
1110     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
1111     GenoPro::Software::Name_p node = XSD::createElementTmpl<Name, XMLSchema::Types::bt_string*>(t);
1112
1113     if(options.isSampleCreate && (node->stringValue() == "") ) {
1114       node->stringValue(node->sampleValue());
1115     }
1116
1117     _Name = node;
1118
1119     return node;
1120   }
1121
1122
1123   GenoPro::Software::Name_p GenoPro::Software::element_Name()
1124   {
1125     FSM::warnNullNode(_Name, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
1126     return _Name;
1127   }
1128
1129   void GenoPro::Software::set_Name(DOMString val)
1130   {
1131     get_sequence()->set_Name(val);
1132   }
1133
1134   DOMString GenoPro::Software::get_Name_string()
1135   {
1136     return get_sequence()->get_Name_string();
1137   }
1138
1139
1140   void GenoPro::Software::mark_present_Name()
1141   {
1142     return get_sequence()->mark_present_Name();
1143   }
1144
1145
1146   GenoPro::Software::Version_ptr GenoPro::Software::create_Version(FsmCbOptions& options)
1147   {
1148     static DOMStringPtr myName = new DOMString("Version");
1149     static DOMStringPtr myNsUri = new DOMString("libgno");
1150
1151     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
1152     GenoPro::Software::Version_p node = XSD::createElementTmpl<Version, XMLSchema::Types::bt_normalizedString*>(t);
1153
1154     if(options.isSampleCreate && (node->stringValue() == "") ) {
1155       node->stringValue(node->sampleValue());
1156     }
1157
1158     _Version = node;
1159
1160     return node;
1161   }
1162
1163
1164   GenoPro::Software::Version_p GenoPro::Software::element_Version()
1165   {
1166     FSM::warnNullNode(_Version, "Version", "{http://www.w3.org/2001/XMLSchema}Version", 0);
1167     return _Version;
1168   }
1169
1170   void GenoPro::Software::set_Version(DOMString val)
1171   {
1172     get_sequence()->set_Version(val);
1173   }
1174
1175   DOMString GenoPro::Software::get_Version_string()
1176   {
1177     return get_sequence()->get_Version_string();
1178   }
1179
1180
1181   void GenoPro::Software::mark_present_Version()
1182   {
1183     return get_sequence()->mark_present_Version();
1184   }
1185
1186
1187   GenoPro::Software::Address_ptr GenoPro::Software::create_Address(FsmCbOptions& options)
1188   {
1189     static DOMStringPtr myName = new DOMString("Address");
1190     static DOMStringPtr myNsUri = new DOMString("libgno");
1191
1192     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "anyURI");
1193     GenoPro::Software::Address_p node = XSD::createElementTmpl<Address, XMLSchema::Types::bt_anyURI*>(t);
1194
1195     if(options.isSampleCreate && (node->stringValue() == "") ) {
1196       node->stringValue(node->sampleValue());
1197     }
1198
1199     _Address = node;
1200
1201     return node;
1202   }
1203
1204
1205   GenoPro::Software::Address_p GenoPro::Software::element_Address()
1206   {
1207     FSM::warnNullNode(_Address, "Address", "{http://www.w3.org/2001/XMLSchema}Address", 0);
1208     return _Address;
1209   }
1210
1211   void GenoPro::Software::set_Address(DOMString val)
1212   {
1213     get_sequence()->set_Address(val);
1214   }
1215
1216   DOMString GenoPro::Software::get_Address_string()
1217   {
1218     return get_sequence()->get_Address_string();
1219   }
1220
1221
1222   void GenoPro::Software::mark_present_Address()
1223   {
1224     return get_sequence()->mark_present_Address();
1225   }
1226
1227
1228   /* attribute  functions  */
1229
1230   //constructor
1231   GenoPro::Software::sequence::sequence(Software* that):
1232     _that(that)
1233   {
1234     XsdFsmBasePtr fsmArray[] = {
1235     new XsdFSM<Name_ptr>( Particle(new DOMString("libgno"), DOMString("Name"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Name_ptr, Software, FsmCbOptions>(_that, &Software::create_Name)),
1236       new XsdFSM<Version_ptr>( Particle(new DOMString("libgno"), DOMString("Version"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Version_ptr, Software, FsmCbOptions>(_that, &Software::create_Version)),
1237       new XsdFSM<Address_ptr>( Particle(new DOMString("libgno"), DOMString("Address"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Address_ptr, Software, FsmCbOptions>(_that, &Software::create_Address)),
1238
1239       NULL
1240     } ;
1241
1242     XsdSequenceFsmOfFSMs::init(fsmArray);
1243   }
1244
1245
1246
1247   GenoPro::Software::Name_p GenoPro::Software::sequence::element_Name()
1248   {
1249       GenoPro::Software::Name_p node_p = NULL;
1250     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
1251     if(fsm_p)
1252     {
1253       XsdFSM<Name_ptr> *unitFsm = dynamic_cast<XsdFSM<Name_ptr> *>(fsm_p);
1254       if(unitFsm && unitFsm->nodeList().size()>0) {
1255         assert(unitFsm->nodeList().size()==1);
1256         node_p = unitFsm->nodeList().at(0);
1257       }
1258     }
1259
1260     FSM::warnNullNode(node_p, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
1261     return node_p;
1262
1263   }
1264
1265
1266   void GenoPro::Software::sequence::set_Name(DOMString val)
1267   {
1268
1269     mark_present_Name();
1270
1271     element_Name()->stringValue(val);
1272   }
1273
1274   DOMString GenoPro::Software::sequence::get_Name_string()
1275   {
1276     return element_Name()->stringValue();
1277   }
1278
1279
1280
1281   void GenoPro::Software::sequence::mark_present_Name()
1282   {
1283     DOMStringPtr nsUriPtr = new DOMString("libgno");
1284     XsdEvent event(nsUriPtr, NULL, DOMString("Name"), XsdEvent::ELEMENT_START, false);
1285     this->processEventThrow(event);
1286   }
1287
1288
1289
1290   GenoPro::Software::Version_p GenoPro::Software::sequence::element_Version()
1291   {
1292       GenoPro::Software::Version_p node_p = NULL;
1293     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
1294     if(fsm_p)
1295     {
1296       XsdFSM<Version_ptr> *unitFsm = dynamic_cast<XsdFSM<Version_ptr> *>(fsm_p);
1297       if(unitFsm && unitFsm->nodeList().size()>0) {
1298         assert(unitFsm->nodeList().size()==1);
1299         node_p = unitFsm->nodeList().at(0);
1300       }
1301     }
1302
1303     FSM::warnNullNode(node_p, "Version", "{http://www.w3.org/2001/XMLSchema}Version", 0);
1304     return node_p;
1305
1306   }
1307
1308
1309   void GenoPro::Software::sequence::set_Version(DOMString val)
1310   {
1311
1312     mark_present_Version();
1313
1314     element_Version()->stringValue(val);
1315   }
1316
1317   DOMString GenoPro::Software::sequence::get_Version_string()
1318   {
1319     return element_Version()->stringValue();
1320   }
1321
1322
1323
1324   void GenoPro::Software::sequence::mark_present_Version()
1325   {
1326     DOMStringPtr nsUriPtr = new DOMString("libgno");
1327     XsdEvent event(nsUriPtr, NULL, DOMString("Version"), XsdEvent::ELEMENT_START, false);
1328     this->processEventThrow(event);
1329   }
1330
1331
1332
1333   GenoPro::Software::Address_p GenoPro::Software::sequence::element_Address()
1334   {
1335       GenoPro::Software::Address_p node_p = NULL;
1336     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
1337     if(fsm_p)
1338     {
1339       XsdFSM<Address_ptr> *unitFsm = dynamic_cast<XsdFSM<Address_ptr> *>(fsm_p);
1340       if(unitFsm && unitFsm->nodeList().size()>0) {
1341         assert(unitFsm->nodeList().size()==1);
1342         node_p = unitFsm->nodeList().at(0);
1343       }
1344     }
1345
1346     FSM::warnNullNode(node_p, "Address", "{http://www.w3.org/2001/XMLSchema}Address", 0);
1347     return node_p;
1348
1349   }
1350
1351
1352   void GenoPro::Software::sequence::set_Address(DOMString val)
1353   {
1354
1355     mark_present_Address();
1356
1357     element_Address()->stringValue(val);
1358   }
1359
1360   DOMString GenoPro::Software::sequence::get_Address_string()
1361   {
1362     return element_Address()->stringValue();
1363   }
1364
1365
1366
1367   void GenoPro::Software::sequence::mark_present_Address()
1368   {
1369     DOMStringPtr nsUriPtr = new DOMString("libgno");
1370     XsdEvent event(nsUriPtr, NULL, DOMString("Address"), XsdEvent::ELEMENT_START, false);
1371     this->processEventThrow(event);
1372   }
1373
1374
1375
1376   //constructor
1377
1378   GenoPro::Global::Global(ElementCreateArgs args):
1379       XMLSchema::XmlElement<anyType>(args),
1380
1381     _fsmAttrs(NULL),
1382     _fsmElems(NULL)
1383
1384     , _sequence(new sequence(this) )
1385
1386   {
1387     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
1388     initFSM();
1389     if(args.ownerDoc && args.ownerDoc->buildTree())
1390     {
1391       if(args.ownerDoc->createSample()) {
1392         _fsm->fireSampleEvents();
1393       }
1394       else {
1395         _fsm->fireRequiredEvents();
1396       }
1397     }
1398   }
1399
1400   void GenoPro::Global::initFSM()
1401   {
1402     XsdFsmBasePtr fsmsAttrs[] = {
1403
1404       NULL
1405     };
1406
1407     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
1408
1409     _fsm->replaceContentFsm(_sequence);
1410
1411     _fsmAttrs = _fsm->attributeFsm();
1412     _fsmElems = _fsm->contentFsm();
1413
1414   }
1415
1416   /* element functions  */
1417
1418 #ifndef __Global_Name_member_elems_fns
1419 #define __Global_Name_member_elems_fns
1420
1421
1422   GenoPro::Global::Name_ptr GenoPro::Global::create_Name(FsmCbOptions& options)
1423   {
1424     static DOMStringPtr myName = new DOMString("Name");
1425     static DOMStringPtr myNsUri = new DOMString("libgno");
1426
1427     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1428     GenoPro::Global::Name_p node = XSD::createElementTmpl<Name, void*>(t);
1429
1430     _Name = node;
1431
1432     return node;
1433   }
1434
1435
1436   GenoPro::Global::Name_p GenoPro::Global::element_Name()
1437   {
1438     FSM::warnNullNode(_Name, "Name", "{}Name", 0);
1439     return _Name;
1440   }
1441
1442   void GenoPro::Global::mark_present_Name()
1443   {
1444     return get_sequence()->mark_present_Name();
1445   }
1446
1447 #endif // __Global_Name_member_elems_fns
1448
1449
1450   GenoPro::Global::Font_ptr GenoPro::Global::create_Font(FsmCbOptions& options)
1451   {
1452     static DOMStringPtr myName = new DOMString("Font");
1453     static DOMStringPtr myNsUri = new DOMString("libgno");
1454
1455     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
1456     GenoPro::Global::Font_p node = XSD::createElementTmpl<Font, XMLSchema::Types::bt_string*>(t);
1457
1458     if(options.isSampleCreate && (node->stringValue() == "") ) {
1459       node->stringValue(node->sampleValue());
1460     }
1461
1462     _Font = node;
1463
1464     return node;
1465   }
1466
1467
1468   GenoPro::Global::Font_p GenoPro::Global::element_Font()
1469   {
1470     FSM::warnNullNode(_Font, "Font", "{http://www.w3.org/2001/XMLSchema}Font", 0);
1471     return _Font;
1472   }
1473
1474   void GenoPro::Global::set_Font(DOMString val)
1475   {
1476     get_sequence()->set_Font(val);
1477   }
1478
1479   DOMString GenoPro::Global::get_Font_string()
1480   {
1481     return get_sequence()->get_Font_string();
1482   }
1483
1484
1485   void GenoPro::Global::mark_present_Font()
1486   {
1487     return get_sequence()->mark_present_Font();
1488   }
1489
1490 #ifndef __Global_Display_member_elems_fns
1491 #define __Global_Display_member_elems_fns
1492
1493
1494   GenoPro::Global::Display_ptr GenoPro::Global::create_Display(FsmCbOptions& options)
1495   {
1496     static DOMStringPtr myName = new DOMString("Display");
1497     static DOMStringPtr myNsUri = new DOMString("libgno");
1498
1499     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1500     GenoPro::Global::Display_p node = XSD::createElementTmpl<Display, void*>(t);
1501
1502     _Display = node;
1503
1504     return node;
1505   }
1506
1507
1508   GenoPro::Global::Display_p GenoPro::Global::element_Display()
1509   {
1510     FSM::warnNullNode(_Display, "Display", "{}Display", 0);
1511     return _Display;
1512   }
1513
1514   void GenoPro::Global::mark_present_Display()
1515   {
1516     return get_sequence()->mark_present_Display();
1517   }
1518
1519 #endif // __Global_Display_member_elems_fns
1520
1521 #ifndef __Global_Tags_member_elems_fns
1522 #define __Global_Tags_member_elems_fns
1523
1524
1525   GenoPro::Global::Tags_ptr GenoPro::Global::create_Tags(FsmCbOptions& options)
1526   {
1527     static DOMStringPtr myName = new DOMString("Tags");
1528     static DOMStringPtr myNsUri = new DOMString("libgno");
1529
1530     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1531     GenoPro::Global::Tags_p node = XSD::createElementTmpl<Tags, void*>(t);
1532
1533     _list_Tags.push_back(node);
1534
1535     return node;
1536   }
1537
1538
1539   GenoPro::Global::Tags_p GenoPro::Global::element_Tags_at(unsigned int idx)
1540   {
1541     if(idx > _list_Tags.size()-1) {
1542       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
1543     }
1544
1545     return _list_Tags.at(idx);
1546   }
1547
1548   List<GenoPro::Global::Tags_ptr> GenoPro::Global::elements_Tags()
1549   {
1550     return _list_Tags;
1551   }
1552
1553   GenoPro::Global::Tags_p GenoPro::Global::add_node_Tags()
1554   {
1555     return get_sequence()->add_node_Tags();
1556   }
1557
1558   List<GenoPro::Global::Tags_ptr> GenoPro::Global::set_count_Tags(unsigned int size)
1559   {
1560     return get_sequence()->set_count_Tags(size);
1561   }
1562
1563
1564 #endif // __Global_Tags_member_elems_fns
1565
1566
1567   GenoPro::Global::Document_ptr GenoPro::Global::create_Document(FsmCbOptions& options)
1568   {
1569     static DOMStringPtr myName = new DOMString("Document");
1570     static DOMStringPtr myNsUri = new DOMString("libgno");
1571
1572     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1573     GenoPro::Global::Document_p node = XSD::createElementTmpl<Document, void*>(t);
1574
1575     _Document = node;
1576
1577     return node;
1578   }
1579
1580
1581   GenoPro::Global::Document_p GenoPro::Global::element_Document()
1582   {
1583     FSM::warnNullNode(_Document, "Document", "{}Document", 0);
1584     return _Document;
1585   }
1586
1587   void GenoPro::Global::mark_present_Document()
1588   {
1589     return get_sequence()->mark_present_Document();
1590   }
1591
1592
1593   GenoPro::Global::ActiveGenoMap_ptr GenoPro::Global::create_ActiveGenoMap(FsmCbOptions& options)
1594   {
1595     static DOMStringPtr myName = new DOMString("ActiveGenoMap");
1596     static DOMStringPtr myNsUri = new DOMString("libgno");
1597
1598     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
1599     GenoPro::Global::ActiveGenoMap_p node = XSD::createElementTmpl<ActiveGenoMap, XMLSchema::Types::bt_normalizedString*>(t);
1600
1601     if(options.isSampleCreate && (node->stringValue() == "") ) {
1602       node->stringValue(node->sampleValue());
1603     }
1604
1605     _ActiveGenoMap = node;
1606
1607     return node;
1608   }
1609
1610
1611   GenoPro::Global::ActiveGenoMap_p GenoPro::Global::element_ActiveGenoMap()
1612   {
1613     FSM::warnNullNode(_ActiveGenoMap, "ActiveGenoMap", "{http://www.w3.org/2001/XMLSchema}ActiveGenoMap", 0);
1614     return _ActiveGenoMap;
1615   }
1616
1617   void GenoPro::Global::set_ActiveGenoMap(DOMString val)
1618   {
1619     get_sequence()->set_ActiveGenoMap(val);
1620   }
1621
1622   DOMString GenoPro::Global::get_ActiveGenoMap_string()
1623   {
1624     return get_sequence()->get_ActiveGenoMap_string();
1625   }
1626
1627
1628   void GenoPro::Global::mark_present_ActiveGenoMap()
1629   {
1630     return get_sequence()->mark_present_ActiveGenoMap();
1631   }
1632
1633
1634   GenoPro::Global::Options_ptr GenoPro::Global::create_Options(FsmCbOptions& options)
1635   {
1636     static DOMStringPtr myName = new DOMString("Options");
1637     static DOMStringPtr myNsUri = new DOMString("libgno");
1638
1639     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1640     GenoPro::Global::Options_p node = XSD::createElementTmpl<Options, void*>(t);
1641
1642     if(options.isSampleCreate && (node->stringValue() == "") ) {
1643       node->stringValue(node->sampleValue());
1644     }
1645
1646     _Options = node;
1647
1648     return node;
1649   }
1650
1651
1652   GenoPro::Global::Options_p GenoPro::Global::element_Options()
1653   {
1654     FSM::warnNullNode(_Options, "Options", "{}Options", 0);
1655     return _Options;
1656   }
1657
1658   void GenoPro::Global::mark_present_Options()
1659   {
1660     return get_sequence()->mark_present_Options();
1661   }
1662
1663
1664   /* attribute  functions  */
1665
1666   //constructor
1667   GenoPro::Global::sequence::sequence(Global* that):
1668     _that(that)
1669   {
1670     XsdFsmBasePtr fsmArray[] = {
1671     new XsdFSM<Name_ptr>( Particle(new DOMString("libgno"), DOMString("Name"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Name_ptr, Global, FsmCbOptions>(_that, &Global::create_Name)),
1672       new XsdFSM<Font_ptr>( Particle(new DOMString("libgno"), DOMString("Font"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Font_ptr, Global, FsmCbOptions>(_that, &Global::create_Font)),
1673       new XsdFSM<Display_ptr>( Particle(new DOMString("libgno"), DOMString("Display"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Display_ptr, Global, FsmCbOptions>(_that, &Global::create_Display)),
1674       new XsdFSM<Tags_ptr>( Particle(new DOMString("libgno"), DOMString("Tags"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Tags_ptr, Global, FsmCbOptions>(_that, &Global::create_Tags)),
1675       new XsdFSM<Document_ptr>( Particle(new DOMString("libgno"), DOMString("Document"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Document_ptr, Global, FsmCbOptions>(_that, &Global::create_Document)),
1676       new XsdFSM<ActiveGenoMap_ptr>( Particle(new DOMString("libgno"), DOMString("ActiveGenoMap"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<ActiveGenoMap_ptr, Global, FsmCbOptions>(_that, &Global::create_ActiveGenoMap)),
1677       new XsdFSM<Options_ptr>( Particle(new DOMString("libgno"), DOMString("Options"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Options_ptr, Global, FsmCbOptions>(_that, &Global::create_Options)),
1678
1679       NULL
1680     } ;
1681
1682     XsdSequenceFsmOfFSMs::init(fsmArray);
1683   }
1684
1685
1686
1687   GenoPro::Global::Name_p GenoPro::Global::sequence::element_Name()
1688   {
1689       GenoPro::Global::Name_p node_p = NULL;
1690     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
1691     if(fsm_p)
1692     {
1693       XsdFSM<Name_ptr> *unitFsm = dynamic_cast<XsdFSM<Name_ptr> *>(fsm_p);
1694       if(unitFsm && unitFsm->nodeList().size()>0) {
1695         assert(unitFsm->nodeList().size()==1);
1696         node_p = unitFsm->nodeList().at(0);
1697       }
1698     }
1699
1700     FSM::warnNullNode(node_p, "Name", "{}Name", 0);
1701     return node_p;
1702
1703   }
1704
1705
1706
1707   void GenoPro::Global::sequence::mark_present_Name()
1708   {
1709     DOMStringPtr nsUriPtr = new DOMString("libgno");
1710     XsdEvent event(nsUriPtr, NULL, DOMString("Name"), XsdEvent::ELEMENT_START, false);
1711     this->processEventThrow(event);
1712   }
1713
1714
1715
1716   GenoPro::Global::Font_p GenoPro::Global::sequence::element_Font()
1717   {
1718       GenoPro::Global::Font_p node_p = NULL;
1719     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
1720     if(fsm_p)
1721     {
1722       XsdFSM<Font_ptr> *unitFsm = dynamic_cast<XsdFSM<Font_ptr> *>(fsm_p);
1723       if(unitFsm && unitFsm->nodeList().size()>0) {
1724         assert(unitFsm->nodeList().size()==1);
1725         node_p = unitFsm->nodeList().at(0);
1726       }
1727     }
1728
1729     FSM::warnNullNode(node_p, "Font", "{http://www.w3.org/2001/XMLSchema}Font", 0);
1730     return node_p;
1731
1732   }
1733
1734
1735   void GenoPro::Global::sequence::set_Font(DOMString val)
1736   {
1737
1738     mark_present_Font();
1739
1740     element_Font()->stringValue(val);
1741   }
1742
1743   DOMString GenoPro::Global::sequence::get_Font_string()
1744   {
1745     return element_Font()->stringValue();
1746   }
1747
1748
1749
1750   void GenoPro::Global::sequence::mark_present_Font()
1751   {
1752     DOMStringPtr nsUriPtr = new DOMString("libgno");
1753     XsdEvent event(nsUriPtr, NULL, DOMString("Font"), XsdEvent::ELEMENT_START, false);
1754     this->processEventThrow(event);
1755   }
1756
1757
1758
1759   GenoPro::Global::Display_p GenoPro::Global::sequence::element_Display()
1760   {
1761       GenoPro::Global::Display_p node_p = NULL;
1762     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
1763     if(fsm_p)
1764     {
1765       XsdFSM<Display_ptr> *unitFsm = dynamic_cast<XsdFSM<Display_ptr> *>(fsm_p);
1766       if(unitFsm && unitFsm->nodeList().size()>0) {
1767         assert(unitFsm->nodeList().size()==1);
1768         node_p = unitFsm->nodeList().at(0);
1769       }
1770     }
1771
1772     FSM::warnNullNode(node_p, "Display", "{}Display", 0);
1773     return node_p;
1774
1775   }
1776
1777
1778
1779   void GenoPro::Global::sequence::mark_present_Display()
1780   {
1781     DOMStringPtr nsUriPtr = new DOMString("libgno");
1782     XsdEvent event(nsUriPtr, NULL, DOMString("Display"), XsdEvent::ELEMENT_START, false);
1783     this->processEventThrow(event);
1784   }
1785
1786
1787
1788   List<GenoPro::Global::Tags_ptr> GenoPro::Global::sequence::elements_Tags()
1789   {
1790
1791     List<Tags_ptr> nodeList;
1792     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
1793     if(fsm_p)
1794     {
1795       XsdFSM<Tags_ptr> *unitFsm = dynamic_cast<XsdFSM<Tags_ptr> *>(fsm_p);
1796       if(unitFsm) {
1797         //nodeList = unitFsm->nodeList().stl_list();
1798         nodeList = unitFsm->nodeList();
1799       }
1800     }
1801     return nodeList;
1802
1803   }
1804
1805
1806   GenoPro::Global::Tags_p GenoPro::Global::sequence::element_Tags_at(unsigned int idx)
1807   {
1808     return elements_Tags().at(idx);
1809   }
1810
1811
1812   GenoPro::Global::Tags_p GenoPro::Global::sequence::add_node_Tags()
1813   {
1814     DOMStringPtr nsUriPtr = new DOMString("libgno");
1815     XsdEvent event(nsUriPtr, NULL, DOMString("Tags"), XsdEvent::ELEMENT_START, false);
1816     this->processEventThrow(event);
1817     return elements_Tags().back();
1818   }
1819
1820   List<GenoPro::Global::Tags_ptr> GenoPro::Global::sequence::set_count_Tags(unsigned int size)
1821   {
1822     if( (size > -1) || (size < 1)) {
1823       ostringstream oss;
1824       oss << "set_count_Tags: size should be in range: [" << 1
1825         << "," << "unbounded" << "]";
1826       throw IndexOutOfBoundsException(oss.str());
1827     }
1828
1829     unsigned int prevSize = elements_Tags().size();
1830     if(size < prevSize) {
1831       //FIXME: allow later:
1832       throw XPlus::RuntimeException("resize lesser than current size not allowed");
1833     }
1834
1835     for(unsigned int j=prevSize; j<size; j++)
1836     {
1837       // pretend docBuilding to avoid computation of adding after first loop
1838       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Tags"), XsdEvent::ELEMENT_START, false);
1839       this->processEventThrow(event);
1840     }
1841
1842     return elements_Tags();
1843   }
1844
1845
1846
1847   GenoPro::Global::Document_p GenoPro::Global::sequence::element_Document()
1848   {
1849       GenoPro::Global::Document_p node_p = NULL;
1850     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
1851     if(fsm_p)
1852     {
1853       XsdFSM<Document_ptr> *unitFsm = dynamic_cast<XsdFSM<Document_ptr> *>(fsm_p);
1854       if(unitFsm && unitFsm->nodeList().size()>0) {
1855         assert(unitFsm->nodeList().size()==1);
1856         node_p = unitFsm->nodeList().at(0);
1857       }
1858     }
1859
1860     FSM::warnNullNode(node_p, "Document", "{}Document", 0);
1861     return node_p;
1862
1863   }
1864
1865
1866
1867   void GenoPro::Global::sequence::mark_present_Document()
1868   {
1869     DOMStringPtr nsUriPtr = new DOMString("libgno");
1870     XsdEvent event(nsUriPtr, NULL, DOMString("Document"), XsdEvent::ELEMENT_START, false);
1871     this->processEventThrow(event);
1872   }
1873
1874
1875
1876   GenoPro::Global::ActiveGenoMap_p GenoPro::Global::sequence::element_ActiveGenoMap()
1877   {
1878       GenoPro::Global::ActiveGenoMap_p node_p = NULL;
1879     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
1880     if(fsm_p)
1881     {
1882       XsdFSM<ActiveGenoMap_ptr> *unitFsm = dynamic_cast<XsdFSM<ActiveGenoMap_ptr> *>(fsm_p);
1883       if(unitFsm && unitFsm->nodeList().size()>0) {
1884         assert(unitFsm->nodeList().size()==1);
1885         node_p = unitFsm->nodeList().at(0);
1886       }
1887     }
1888
1889     FSM::warnNullNode(node_p, "ActiveGenoMap", "{http://www.w3.org/2001/XMLSchema}ActiveGenoMap", 0);
1890     return node_p;
1891
1892   }
1893
1894
1895   void GenoPro::Global::sequence::set_ActiveGenoMap(DOMString val)
1896   {
1897
1898     mark_present_ActiveGenoMap();
1899
1900     element_ActiveGenoMap()->stringValue(val);
1901   }
1902
1903   DOMString GenoPro::Global::sequence::get_ActiveGenoMap_string()
1904   {
1905     return element_ActiveGenoMap()->stringValue();
1906   }
1907
1908
1909
1910   void GenoPro::Global::sequence::mark_present_ActiveGenoMap()
1911   {
1912     DOMStringPtr nsUriPtr = new DOMString("libgno");
1913     XsdEvent event(nsUriPtr, NULL, DOMString("ActiveGenoMap"), XsdEvent::ELEMENT_START, false);
1914     this->processEventThrow(event);
1915   }
1916
1917
1918
1919   GenoPro::Global::Options_p GenoPro::Global::sequence::element_Options()
1920   {
1921       GenoPro::Global::Options_p node_p = NULL;
1922     XsdFsmBase* fsm_p = this->allFSMs()[6].get();
1923     if(fsm_p)
1924     {
1925       XsdFSM<Options_ptr> *unitFsm = dynamic_cast<XsdFSM<Options_ptr> *>(fsm_p);
1926       if(unitFsm && unitFsm->nodeList().size()>0) {
1927         assert(unitFsm->nodeList().size()==1);
1928         node_p = unitFsm->nodeList().at(0);
1929       }
1930     }
1931
1932     FSM::warnNullNode(node_p, "Options", "{}Options", 0);
1933     return node_p;
1934
1935   }
1936
1937
1938
1939   void GenoPro::Global::sequence::mark_present_Options()
1940   {
1941     DOMStringPtr nsUriPtr = new DOMString("libgno");
1942     XsdEvent event(nsUriPtr, NULL, DOMString("Options"), XsdEvent::ELEMENT_START, false);
1943     this->processEventThrow(event);
1944   }
1945
1946
1947
1948   //constructor
1949
1950   GenoPro::Global::Name::Name(ElementCreateArgs args):
1951       XMLSchema::XmlElement<anyType>(args),
1952
1953     _fsmAttrs(NULL),
1954     _fsmElems(NULL)
1955
1956     , _sequence(new sequence(this) )
1957
1958   {
1959     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
1960     initFSM();
1961     if(args.ownerDoc && args.ownerDoc->buildTree())
1962     {
1963       if(args.ownerDoc->createSample()) {
1964         _fsm->fireSampleEvents();
1965       }
1966       else {
1967         _fsm->fireRequiredEvents();
1968       }
1969     }
1970   }
1971
1972   void GenoPro::Global::Name::initFSM()
1973   {
1974     XsdFsmBasePtr fsmsAttrs[] = {
1975
1976       NULL
1977     };
1978
1979     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
1980
1981     _fsm->replaceContentFsm(_sequence);
1982
1983     _fsmAttrs = _fsm->attributeFsm();
1984     _fsmElems = _fsm->contentFsm();
1985
1986   }
1987
1988   /* element functions  */
1989
1990
1991   GenoPro::Global::Name::Full_ptr GenoPro::Global::Name::create_Full(FsmCbOptions& options)
1992   {
1993     static DOMStringPtr myName = new DOMString("Full");
1994     static DOMStringPtr myNsUri = new DOMString("libgno");
1995
1996     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
1997     GenoPro::Global::Name::Full_p node = XSD::createElementTmpl<Full, void*>(t);
1998
1999     if(options.isSampleCreate && (node->stringValue() == "") ) {
2000       node->stringValue(node->sampleValue());
2001     }
2002
2003     _Full = node;
2004
2005     return node;
2006   }
2007
2008
2009   GenoPro::Global::Name::Full_p GenoPro::Global::Name::element_Full()
2010   {
2011     FSM::warnNullNode(_Full, "Full", "{}Full", 0);
2012     return _Full;
2013   }
2014
2015   void GenoPro::Global::Name::mark_present_Full()
2016   {
2017     return get_sequence()->mark_present_Full();
2018   }
2019
2020
2021   GenoPro::Global::Name::Display_ptr GenoPro::Global::Name::create_Display(FsmCbOptions& options)
2022   {
2023     static DOMStringPtr myName = new DOMString("Display");
2024     static DOMStringPtr myNsUri = new DOMString("libgno");
2025
2026     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2027     GenoPro::Global::Name::Display_p node = XSD::createElementTmpl<Display, void*>(t);
2028
2029     if(options.isSampleCreate && (node->stringValue() == "") ) {
2030       node->stringValue(node->sampleValue());
2031     }
2032
2033     _Display = node;
2034
2035     return node;
2036   }
2037
2038
2039   GenoPro::Global::Name::Display_p GenoPro::Global::Name::element_Display()
2040   {
2041     FSM::warnNullNode(_Display, "Display", "{}Display", 0);
2042     return _Display;
2043   }
2044
2045   void GenoPro::Global::Name::mark_present_Display()
2046   {
2047     return get_sequence()->mark_present_Display();
2048   }
2049
2050
2051   /* attribute  functions  */
2052
2053   //constructor
2054   GenoPro::Global::Name::sequence::sequence(Name* that):
2055     _that(that)
2056   {
2057     XsdFsmBasePtr fsmArray[] = {
2058     new XsdFSM<Full_ptr>( Particle(new DOMString("libgno"), DOMString("Full"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Full_ptr, Name, FsmCbOptions>(_that, &Name::create_Full)),
2059       new XsdFSM<Display_ptr>( Particle(new DOMString("libgno"), DOMString("Display"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Display_ptr, Name, FsmCbOptions>(_that, &Name::create_Display)),
2060
2061       NULL
2062     } ;
2063
2064     XsdSequenceFsmOfFSMs::init(fsmArray);
2065   }
2066
2067
2068
2069   GenoPro::Global::Name::Full_p GenoPro::Global::Name::sequence::element_Full()
2070   {
2071       GenoPro::Global::Name::Full_p node_p = NULL;
2072     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
2073     if(fsm_p)
2074     {
2075       XsdFSM<Full_ptr> *unitFsm = dynamic_cast<XsdFSM<Full_ptr> *>(fsm_p);
2076       if(unitFsm && unitFsm->nodeList().size()>0) {
2077         assert(unitFsm->nodeList().size()==1);
2078         node_p = unitFsm->nodeList().at(0);
2079       }
2080     }
2081
2082     FSM::warnNullNode(node_p, "Full", "{}Full", 0);
2083     return node_p;
2084
2085   }
2086
2087
2088
2089   void GenoPro::Global::Name::sequence::mark_present_Full()
2090   {
2091     DOMStringPtr nsUriPtr = new DOMString("libgno");
2092     XsdEvent event(nsUriPtr, NULL, DOMString("Full"), XsdEvent::ELEMENT_START, false);
2093     this->processEventThrow(event);
2094   }
2095
2096
2097
2098   GenoPro::Global::Name::Display_p GenoPro::Global::Name::sequence::element_Display()
2099   {
2100       GenoPro::Global::Name::Display_p node_p = NULL;
2101     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
2102     if(fsm_p)
2103     {
2104       XsdFSM<Display_ptr> *unitFsm = dynamic_cast<XsdFSM<Display_ptr> *>(fsm_p);
2105       if(unitFsm && unitFsm->nodeList().size()>0) {
2106         assert(unitFsm->nodeList().size()==1);
2107         node_p = unitFsm->nodeList().at(0);
2108       }
2109     }
2110
2111     FSM::warnNullNode(node_p, "Display", "{}Display", 0);
2112     return node_p;
2113
2114   }
2115
2116
2117
2118   void GenoPro::Global::Name::sequence::mark_present_Display()
2119   {
2120     DOMStringPtr nsUriPtr = new DOMString("libgno");
2121     XsdEvent event(nsUriPtr, NULL, DOMString("Display"), XsdEvent::ELEMENT_START, false);
2122     this->processEventThrow(event);
2123   }
2124
2125
2126   //constructor
2127
2128   GenoPro::Global::Name::Full::Full(ElementCreateArgs args):
2129       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
2130
2131     _fsmAttrs(NULL),
2132     _fsmElems(NULL)
2133   {
2134
2135
2136     initFSM();
2137
2138
2139     if(args.ownerDoc && args.ownerDoc->buildTree())
2140
2141     {
2142       if(args.ownerDoc->createSample()) {
2143         _fsm->fireSampleEvents();
2144       }
2145       else {
2146         _fsm->fireRequiredEvents();
2147       }
2148     }
2149   }
2150
2151   void GenoPro::Global::Name::Full::initFSM()
2152   {
2153     XsdFsmBasePtr fsmsAttrs[] = {
2154     new XsdFSM<attr_Format_ptr>( Particle(NULL, DOMString("Format"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Format_ptr, Full, FsmCbOptions>(this, &Full::create_attr_Format)),
2155
2156       NULL
2157     };
2158
2159     _fsm->appendAttributeFsms(fsmsAttrs);
2160     _fsmAttrs = _fsm->attributeFsm();
2161     _fsmElems = _fsm->contentFsm();
2162
2163    }
2164
2165   /* element functions  */
2166
2167
2168   /* attribute  functions  */
2169
2170
2171   GenoPro::Global::Name::Full::attr_Format_ptr GenoPro::Global::Name::Full::create_attr_Format(FsmCbOptions& options)
2172   {
2173     static DOMStringPtr myName = new DOMString("Format");
2174     static DOMStringPtr myNsUri = NULL;
2175
2176     if(_attr_Format) {
2177       return _attr_Format;
2178     }
2179     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2180     GenoPro::Global::Name::Full::attr_Format_p node = XSD::createAttributeTmpl<attr_Format>(t);
2181
2182     if(options.isSampleCreate && (node->stringValue() == "") ) {
2183       node->stringValue(node->sampleValue());
2184     }
2185
2186     _attr_Format = node;
2187
2188     return node;
2189   }
2190
2191
2192     void GenoPro::Global::Name::Full::set_attr_Format(DOMString val)
2193     {
2194
2195       attribute_attr_Format()->stringValue(val);
2196     }
2197
2198     DOMString GenoPro::Global::Name::Full::get_attr_Format_string()
2199     {
2200
2201       return attribute_attr_Format()->stringValue();
2202     }
2203
2204
2205   GenoPro::Global::Name::Full::attr_Format_p GenoPro::Global::Name::Full::attribute_attr_Format()
2206   {
2207     FSM::warnNullNode(_attr_Format, "attr_Format", "{http://www.w3.org/2001/XMLSchema}Format", 1);
2208     return _attr_Format;
2209   }
2210
2211   //constructor
2212
2213   GenoPro::Global::Name::Display::Display(ElementCreateArgs args):
2214       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
2215
2216     _fsmAttrs(NULL),
2217     _fsmElems(NULL)
2218   {
2219
2220
2221     initFSM();
2222
2223
2224     if(args.ownerDoc && args.ownerDoc->buildTree())
2225
2226     {
2227       if(args.ownerDoc->createSample()) {
2228         _fsm->fireSampleEvents();
2229       }
2230       else {
2231         _fsm->fireRequiredEvents();
2232       }
2233     }
2234   }
2235
2236   void GenoPro::Global::Name::Display::initFSM()
2237   {
2238     XsdFsmBasePtr fsmsAttrs[] = {
2239     new XsdFSM<attr_Format_ptr>( Particle(NULL, DOMString("Format"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Format_ptr, Display, FsmCbOptions>(this, &Display::create_attr_Format)),
2240     new XsdFSM<attr_Lines_ptr>( Particle(NULL, DOMString("Lines"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Lines_ptr, Display, FsmCbOptions>(this, &Display::create_attr_Lines)),
2241
2242       NULL
2243     };
2244
2245     _fsm->appendAttributeFsms(fsmsAttrs);
2246     _fsmAttrs = _fsm->attributeFsm();
2247     _fsmElems = _fsm->contentFsm();
2248
2249    }
2250
2251   /* element functions  */
2252
2253
2254   /* attribute  functions  */
2255
2256
2257   GenoPro::Global::Name::Display::attr_Format_ptr GenoPro::Global::Name::Display::create_attr_Format(FsmCbOptions& options)
2258   {
2259     static DOMStringPtr myName = new DOMString("Format");
2260     static DOMStringPtr myNsUri = NULL;
2261
2262     if(_attr_Format) {
2263       return _attr_Format;
2264     }
2265     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2266     GenoPro::Global::Name::Display::attr_Format_p node = XSD::createAttributeTmpl<attr_Format>(t);
2267
2268     if(options.isSampleCreate && (node->stringValue() == "") ) {
2269       node->stringValue(node->sampleValue());
2270     }
2271
2272     _attr_Format = node;
2273
2274     return node;
2275   }
2276
2277
2278     void GenoPro::Global::Name::Display::set_attr_Format(DOMString val)
2279     {
2280
2281       attribute_attr_Format()->stringValue(val);
2282     }
2283
2284     DOMString GenoPro::Global::Name::Display::get_attr_Format_string()
2285     {
2286
2287       return attribute_attr_Format()->stringValue();
2288     }
2289
2290
2291   GenoPro::Global::Name::Display::attr_Format_p GenoPro::Global::Name::Display::attribute_attr_Format()
2292   {
2293     FSM::warnNullNode(_attr_Format, "attr_Format", "{http://www.w3.org/2001/XMLSchema}Format", 1);
2294     return _attr_Format;
2295   }
2296
2297
2298   GenoPro::Global::Name::Display::attr_Lines_ptr GenoPro::Global::Name::Display::create_attr_Lines(FsmCbOptions& options)
2299   {
2300     static DOMStringPtr myName = new DOMString("Lines");
2301     static DOMStringPtr myNsUri = NULL;
2302
2303     if(_attr_Lines) {
2304       return _attr_Lines;
2305     }
2306     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2307     GenoPro::Global::Name::Display::attr_Lines_p node = XSD::createAttributeTmpl<attr_Lines>(t);
2308
2309     if(options.isSampleCreate && (node->stringValue() == "") ) {
2310       node->stringValue(node->sampleValue());
2311     }
2312
2313     _attr_Lines = node;
2314
2315     return node;
2316   }
2317
2318
2319     void GenoPro::Global::Name::Display::set_attr_Lines(DOMString val)
2320     {
2321
2322       attribute_attr_Lines()->stringValue(val);
2323     }
2324
2325     DOMString GenoPro::Global::Name::Display::get_attr_Lines_string()
2326     {
2327
2328       return attribute_attr_Lines()->stringValue();
2329     }
2330
2331
2332     void GenoPro::Global::Name::Display::set_attr_Lines(int val)
2333     {
2334
2335       attribute_attr_Lines()->value(val);
2336     }
2337
2338     int GenoPro::Global::Name::Display::get_attr_Lines()
2339     {
2340
2341       return attribute_attr_Lines()->value();
2342     }
2343
2344
2345   GenoPro::Global::Name::Display::attr_Lines_p GenoPro::Global::Name::Display::attribute_attr_Lines()
2346   {
2347     FSM::warnNullNode(_attr_Lines, "attr_Lines", "{http://www.w3.org/2001/XMLSchema}Lines", 1);
2348     return _attr_Lines;
2349   }
2350
2351
2352   //constructor
2353
2354   GenoPro::Global::Display::Display(ElementCreateArgs args):
2355       XMLSchema::XmlElement<anyType>(args),
2356
2357     _fsmAttrs(NULL),
2358     _fsmElems(NULL)
2359
2360     , _sequence(new sequence(this) )
2361
2362   {
2363     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
2364     initFSM();
2365     if(args.ownerDoc && args.ownerDoc->buildTree())
2366     {
2367       if(args.ownerDoc->createSample()) {
2368         _fsm->fireSampleEvents();
2369       }
2370       else {
2371         _fsm->fireRequiredEvents();
2372       }
2373     }
2374   }
2375
2376   void GenoPro::Global::Display::initFSM()
2377   {
2378     XsdFsmBasePtr fsmsAttrs[] = {
2379
2380       NULL
2381     };
2382
2383     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
2384
2385     _fsm->replaceContentFsm(_sequence);
2386
2387     _fsmAttrs = _fsm->attributeFsm();
2388     _fsmElems = _fsm->contentFsm();
2389
2390   }
2391
2392   /* element functions  */
2393
2394
2395   GenoPro::Global::Display::Tag_ptr GenoPro::Global::Display::create_Tag(FsmCbOptions& options)
2396   {
2397     static DOMStringPtr myName = new DOMString("Tag");
2398     static DOMStringPtr myNsUri = new DOMString("libgno");
2399
2400     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
2401     GenoPro::Global::Display::Tag_p node = XSD::createElementTmpl<Tag, XMLSchema::Types::bt_normalizedString*>(t);
2402
2403     if(options.isSampleCreate && (node->stringValue() == "") ) {
2404       node->stringValue(node->sampleValue());
2405     }
2406
2407     _Tag = node;
2408
2409     return node;
2410   }
2411
2412
2413   GenoPro::Global::Display::Tag_p GenoPro::Global::Display::element_Tag()
2414   {
2415     FSM::warnNullNode(_Tag, "Tag", "{http://www.w3.org/2001/XMLSchema}Tag", 0);
2416     return _Tag;
2417   }
2418
2419   void GenoPro::Global::Display::set_Tag(DOMString val)
2420   {
2421     get_sequence()->set_Tag(val);
2422   }
2423
2424   DOMString GenoPro::Global::Display::get_Tag_string()
2425   {
2426     return get_sequence()->get_Tag_string();
2427   }
2428
2429
2430   void GenoPro::Global::Display::mark_present_Tag()
2431   {
2432     return get_sequence()->mark_present_Tag();
2433   }
2434
2435
2436   GenoPro::Global::Display::Colors_ptr GenoPro::Global::Display::create_Colors(FsmCbOptions& options)
2437   {
2438     static DOMStringPtr myName = new DOMString("Colors");
2439     static DOMStringPtr myNsUri = new DOMString("libgno");
2440
2441     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2442     GenoPro::Global::Display::Colors_p node = XSD::createElementTmpl<Colors, void*>(t);
2443
2444     _Colors = node;
2445
2446     return node;
2447   }
2448
2449
2450   GenoPro::Global::Display::Colors_p GenoPro::Global::Display::element_Colors()
2451   {
2452     FSM::warnNullNode(_Colors, "Colors", "{}Colors", 0);
2453     return _Colors;
2454   }
2455
2456   void GenoPro::Global::Display::mark_present_Colors()
2457   {
2458     return get_sequence()->mark_present_Colors();
2459   }
2460
2461
2462   /* attribute  functions  */
2463
2464   //constructor
2465   GenoPro::Global::Display::sequence::sequence(Display* that):
2466     _that(that)
2467   {
2468     XsdFsmBasePtr fsmArray[] = {
2469     new XsdFSM<Tag_ptr>( Particle(new DOMString("libgno"), DOMString("Tag"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Tag_ptr, Display, FsmCbOptions>(_that, &Display::create_Tag)),
2470       new XsdFSM<Colors_ptr>( Particle(new DOMString("libgno"), DOMString("Colors"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Colors_ptr, Display, FsmCbOptions>(_that, &Display::create_Colors)),
2471
2472       NULL
2473     } ;
2474
2475     XsdSequenceFsmOfFSMs::init(fsmArray);
2476   }
2477
2478
2479
2480   GenoPro::Global::Display::Tag_p GenoPro::Global::Display::sequence::element_Tag()
2481   {
2482       GenoPro::Global::Display::Tag_p node_p = NULL;
2483     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
2484     if(fsm_p)
2485     {
2486       XsdFSM<Tag_ptr> *unitFsm = dynamic_cast<XsdFSM<Tag_ptr> *>(fsm_p);
2487       if(unitFsm && unitFsm->nodeList().size()>0) {
2488         assert(unitFsm->nodeList().size()==1);
2489         node_p = unitFsm->nodeList().at(0);
2490       }
2491     }
2492
2493     FSM::warnNullNode(node_p, "Tag", "{http://www.w3.org/2001/XMLSchema}Tag", 0);
2494     return node_p;
2495
2496   }
2497
2498
2499   void GenoPro::Global::Display::sequence::set_Tag(DOMString val)
2500   {
2501
2502     mark_present_Tag();
2503
2504     element_Tag()->stringValue(val);
2505   }
2506
2507   DOMString GenoPro::Global::Display::sequence::get_Tag_string()
2508   {
2509     return element_Tag()->stringValue();
2510   }
2511
2512
2513
2514   void GenoPro::Global::Display::sequence::mark_present_Tag()
2515   {
2516     DOMStringPtr nsUriPtr = new DOMString("libgno");
2517     XsdEvent event(nsUriPtr, NULL, DOMString("Tag"), XsdEvent::ELEMENT_START, false);
2518     this->processEventThrow(event);
2519   }
2520
2521
2522
2523   GenoPro::Global::Display::Colors_p GenoPro::Global::Display::sequence::element_Colors()
2524   {
2525       GenoPro::Global::Display::Colors_p node_p = NULL;
2526     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
2527     if(fsm_p)
2528     {
2529       XsdFSM<Colors_ptr> *unitFsm = dynamic_cast<XsdFSM<Colors_ptr> *>(fsm_p);
2530       if(unitFsm && unitFsm->nodeList().size()>0) {
2531         assert(unitFsm->nodeList().size()==1);
2532         node_p = unitFsm->nodeList().at(0);
2533       }
2534     }
2535
2536     FSM::warnNullNode(node_p, "Colors", "{}Colors", 0);
2537     return node_p;
2538
2539   }
2540
2541
2542
2543   void GenoPro::Global::Display::sequence::mark_present_Colors()
2544   {
2545     DOMStringPtr nsUriPtr = new DOMString("libgno");
2546     XsdEvent event(nsUriPtr, NULL, DOMString("Colors"), XsdEvent::ELEMENT_START, false);
2547     this->processEventThrow(event);
2548   }
2549
2550
2551
2552   //constructor
2553
2554   GenoPro::Global::Display::Colors::Colors(ElementCreateArgs args):
2555       XMLSchema::XmlElement<anyType>(args),
2556
2557     _fsmAttrs(NULL),
2558     _fsmElems(NULL)
2559
2560     , _sequence(new sequence(this) )
2561
2562   {
2563     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
2564     initFSM();
2565     if(args.ownerDoc && args.ownerDoc->buildTree())
2566     {
2567       if(args.ownerDoc->createSample()) {
2568         _fsm->fireSampleEvents();
2569       }
2570       else {
2571         _fsm->fireRequiredEvents();
2572       }
2573     }
2574   }
2575
2576   void GenoPro::Global::Display::Colors::initFSM()
2577   {
2578     XsdFsmBasePtr fsmsAttrs[] = {
2579
2580       NULL
2581     };
2582
2583     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
2584
2585     _fsm->replaceContentFsm(_sequence);
2586
2587     _fsmAttrs = _fsm->attributeFsm();
2588     _fsmElems = _fsm->contentFsm();
2589
2590   }
2591
2592   /* element functions  */
2593
2594
2595   GenoPro::Global::Display::Colors::Gender_ptr GenoPro::Global::Display::Colors::create_Gender(FsmCbOptions& options)
2596   {
2597     static DOMStringPtr myName = new DOMString("Gender");
2598     static DOMStringPtr myNsUri = new DOMString("libgno");
2599
2600     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2601     GenoPro::Global::Display::Colors::Gender_p node = XSD::createElementTmpl<Gender, void*>(t);
2602
2603     _Gender = node;
2604
2605     return node;
2606   }
2607
2608
2609   GenoPro::Global::Display::Colors::Gender_p GenoPro::Global::Display::Colors::element_Gender()
2610   {
2611     FSM::warnNullNode(_Gender, "Gender", "{}Gender", 0);
2612     return _Gender;
2613   }
2614
2615   void GenoPro::Global::Display::Colors::mark_present_Gender()
2616   {
2617     return get_sequence()->mark_present_Gender();
2618   }
2619
2620
2621   GenoPro::Global::Display::Colors::Border_ptr GenoPro::Global::Display::Colors::create_Border(FsmCbOptions& options)
2622   {
2623     static DOMStringPtr myName = new DOMString("Border");
2624     static DOMStringPtr myNsUri = new DOMString("libgno");
2625
2626     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2627     GenoPro::Global::Display::Colors::Border_p node = XSD::createElementTmpl<Border, void*>(t);
2628
2629     _Border = node;
2630
2631     return node;
2632   }
2633
2634
2635   GenoPro::Global::Display::Colors::Border_p GenoPro::Global::Display::Colors::element_Border()
2636   {
2637     FSM::warnNullNode(_Border, "Border", "{}Border", 0);
2638     return _Border;
2639   }
2640
2641   void GenoPro::Global::Display::Colors::mark_present_Border()
2642   {
2643     return get_sequence()->mark_present_Border();
2644   }
2645
2646
2647   GenoPro::Global::Display::Colors::Label_ptr GenoPro::Global::Display::Colors::create_Label(FsmCbOptions& options)
2648   {
2649     static DOMStringPtr myName = new DOMString("Label");
2650     static DOMStringPtr myNsUri = new DOMString("libgno");
2651
2652     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2653     GenoPro::Global::Display::Colors::Label_p node = XSD::createElementTmpl<Label, void*>(t);
2654
2655     _Label = node;
2656
2657     return node;
2658   }
2659
2660
2661   GenoPro::Global::Display::Colors::Label_p GenoPro::Global::Display::Colors::element_Label()
2662   {
2663     FSM::warnNullNode(_Label, "Label", "{}Label", 0);
2664     return _Label;
2665   }
2666
2667   void GenoPro::Global::Display::Colors::mark_present_Label()
2668   {
2669     return get_sequence()->mark_present_Label();
2670   }
2671
2672
2673   /* attribute  functions  */
2674
2675   //constructor
2676   GenoPro::Global::Display::Colors::sequence::sequence(Colors* that):
2677     _that(that)
2678   {
2679     XsdFsmBasePtr fsmArray[] = {
2680     new XsdFSM<Gender_ptr>( Particle(new DOMString("libgno"), DOMString("Gender"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Gender_ptr, Colors, FsmCbOptions>(_that, &Colors::create_Gender)),
2681       new XsdFSM<Border_ptr>( Particle(new DOMString("libgno"), DOMString("Border"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Border_ptr, Colors, FsmCbOptions>(_that, &Colors::create_Border)),
2682       new XsdFSM<Label_ptr>( Particle(new DOMString("libgno"), DOMString("Label"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Label_ptr, Colors, FsmCbOptions>(_that, &Colors::create_Label)),
2683
2684       NULL
2685     } ;
2686
2687     XsdSequenceFsmOfFSMs::init(fsmArray);
2688   }
2689
2690
2691
2692   GenoPro::Global::Display::Colors::Gender_p GenoPro::Global::Display::Colors::sequence::element_Gender()
2693   {
2694       GenoPro::Global::Display::Colors::Gender_p node_p = NULL;
2695     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
2696     if(fsm_p)
2697     {
2698       XsdFSM<Gender_ptr> *unitFsm = dynamic_cast<XsdFSM<Gender_ptr> *>(fsm_p);
2699       if(unitFsm && unitFsm->nodeList().size()>0) {
2700         assert(unitFsm->nodeList().size()==1);
2701         node_p = unitFsm->nodeList().at(0);
2702       }
2703     }
2704
2705     FSM::warnNullNode(node_p, "Gender", "{}Gender", 0);
2706     return node_p;
2707
2708   }
2709
2710
2711
2712   void GenoPro::Global::Display::Colors::sequence::mark_present_Gender()
2713   {
2714     DOMStringPtr nsUriPtr = new DOMString("libgno");
2715     XsdEvent event(nsUriPtr, NULL, DOMString("Gender"), XsdEvent::ELEMENT_START, false);
2716     this->processEventThrow(event);
2717   }
2718
2719
2720
2721   GenoPro::Global::Display::Colors::Border_p GenoPro::Global::Display::Colors::sequence::element_Border()
2722   {
2723       GenoPro::Global::Display::Colors::Border_p node_p = NULL;
2724     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
2725     if(fsm_p)
2726     {
2727       XsdFSM<Border_ptr> *unitFsm = dynamic_cast<XsdFSM<Border_ptr> *>(fsm_p);
2728       if(unitFsm && unitFsm->nodeList().size()>0) {
2729         assert(unitFsm->nodeList().size()==1);
2730         node_p = unitFsm->nodeList().at(0);
2731       }
2732     }
2733
2734     FSM::warnNullNode(node_p, "Border", "{}Border", 0);
2735     return node_p;
2736
2737   }
2738
2739
2740
2741   void GenoPro::Global::Display::Colors::sequence::mark_present_Border()
2742   {
2743     DOMStringPtr nsUriPtr = new DOMString("libgno");
2744     XsdEvent event(nsUriPtr, NULL, DOMString("Border"), XsdEvent::ELEMENT_START, false);
2745     this->processEventThrow(event);
2746   }
2747
2748
2749
2750   GenoPro::Global::Display::Colors::Label_p GenoPro::Global::Display::Colors::sequence::element_Label()
2751   {
2752       GenoPro::Global::Display::Colors::Label_p node_p = NULL;
2753     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
2754     if(fsm_p)
2755     {
2756       XsdFSM<Label_ptr> *unitFsm = dynamic_cast<XsdFSM<Label_ptr> *>(fsm_p);
2757       if(unitFsm && unitFsm->nodeList().size()>0) {
2758         assert(unitFsm->nodeList().size()==1);
2759         node_p = unitFsm->nodeList().at(0);
2760       }
2761     }
2762
2763     FSM::warnNullNode(node_p, "Label", "{}Label", 0);
2764     return node_p;
2765
2766   }
2767
2768
2769
2770   void GenoPro::Global::Display::Colors::sequence::mark_present_Label()
2771   {
2772     DOMStringPtr nsUriPtr = new DOMString("libgno");
2773     XsdEvent event(nsUriPtr, NULL, DOMString("Label"), XsdEvent::ELEMENT_START, false);
2774     this->processEventThrow(event);
2775   }
2776
2777
2778
2779   //constructor
2780
2781   GenoPro::Global::Display::Colors::Gender::Gender(ElementCreateArgs args):
2782       XMLSchema::XmlElement<anyType>(args),
2783
2784     _fsmAttrs(NULL),
2785     _fsmElems(NULL)
2786
2787     , _sequence(new sequence(this) )
2788
2789   {
2790     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
2791     initFSM();
2792     if(args.ownerDoc && args.ownerDoc->buildTree())
2793     {
2794       if(args.ownerDoc->createSample()) {
2795         _fsm->fireSampleEvents();
2796       }
2797       else {
2798         _fsm->fireRequiredEvents();
2799       }
2800     }
2801   }
2802
2803   void GenoPro::Global::Display::Colors::Gender::initFSM()
2804   {
2805     XsdFsmBasePtr fsmsAttrs[] = {
2806   new XsdFSM<attr_Symbol_ptr>( Particle(NULL, DOMString("Symbol"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Symbol_ptr, Gender, FsmCbOptions>(this, &Gender::create_attr_Symbol)),
2807   new XsdFSM<attr_Text_ptr>( Particle(NULL, DOMString("Text"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Text_ptr, Gender, FsmCbOptions>(this, &Gender::create_attr_Text)),
2808   new XsdFSM<attr_Fill_ptr>( Particle(NULL, DOMString("Fill"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Fill_ptr, Gender, FsmCbOptions>(this, &Gender::create_attr_Fill)),
2809
2810       NULL
2811     };
2812
2813     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
2814
2815     _fsm->replaceContentFsm(_sequence);
2816
2817     _fsmAttrs = _fsm->attributeFsm();
2818     _fsmElems = _fsm->contentFsm();
2819
2820   }
2821
2822   /* element functions  */
2823
2824 #ifndef __Gender_Fill_member_elems_fns
2825 #define __Gender_Fill_member_elems_fns
2826
2827
2828   GenoPro::Global::Display::Colors::Gender::Fill_ptr GenoPro::Global::Display::Colors::Gender::create_Fill(FsmCbOptions& options)
2829   {
2830     static DOMStringPtr myName = new DOMString("Fill");
2831     static DOMStringPtr myNsUri = new DOMString("libgno");
2832
2833     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
2834     GenoPro::Global::Display::Colors::Gender::Fill_p node = XSD::createElementTmpl<Fill, void*>(t);
2835
2836     _Fill = node;
2837
2838     return node;
2839   }
2840
2841
2842   GenoPro::Global::Display::Colors::Gender::Fill_p GenoPro::Global::Display::Colors::Gender::element_Fill()
2843   {
2844     FSM::warnNullNode(_Fill, "Fill", "{}Fill", 0);
2845     return _Fill;
2846   }
2847
2848   void GenoPro::Global::Display::Colors::Gender::mark_present_Fill()
2849   {
2850     return get_sequence()->mark_present_Fill();
2851   }
2852
2853 #endif // __Gender_Fill_member_elems_fns
2854
2855 #ifndef __Gender_attr_Fill_member_elems_fns
2856 #define __Gender_attr_Fill_member_elems_fns
2857
2858 #endif // __Gender_attr_Fill_member_elems_fns
2859
2860
2861   /* attribute  functions  */
2862
2863
2864   GenoPro::Global::Display::Colors::Gender::attr_Symbol_ptr GenoPro::Global::Display::Colors::Gender::create_attr_Symbol(FsmCbOptions& options)
2865   {
2866     static DOMStringPtr myName = new DOMString("Symbol");
2867     static DOMStringPtr myNsUri = NULL;
2868
2869     if(_attr_Symbol) {
2870       return _attr_Symbol;
2871     }
2872     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2873     GenoPro::Global::Display::Colors::Gender::attr_Symbol_p node = XSD::createAttributeTmpl<attr_Symbol>(t);
2874
2875     if(options.isSampleCreate && (node->stringValue() == "") ) {
2876       node->stringValue(node->sampleValue());
2877     }
2878
2879     _attr_Symbol = node;
2880
2881     return node;
2882   }
2883
2884
2885     void GenoPro::Global::Display::Colors::Gender::set_attr_Symbol(DOMString val)
2886     {
2887
2888       attribute_attr_Symbol()->stringValue(val);
2889     }
2890
2891     DOMString GenoPro::Global::Display::Colors::Gender::get_attr_Symbol_string()
2892     {
2893
2894       return attribute_attr_Symbol()->stringValue();
2895     }
2896
2897
2898   GenoPro::Global::Display::Colors::Gender::attr_Symbol_p GenoPro::Global::Display::Colors::Gender::attribute_attr_Symbol()
2899   {
2900     FSM::warnNullNode(_attr_Symbol, "attr_Symbol", "{http://www.w3.org/2001/XMLSchema}Symbol", 1);
2901     return _attr_Symbol;
2902   }
2903
2904
2905   GenoPro::Global::Display::Colors::Gender::attr_Text_ptr GenoPro::Global::Display::Colors::Gender::create_attr_Text(FsmCbOptions& options)
2906   {
2907     static DOMStringPtr myName = new DOMString("Text");
2908     static DOMStringPtr myNsUri = NULL;
2909
2910     if(_attr_Text) {
2911       return _attr_Text;
2912     }
2913     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2914     GenoPro::Global::Display::Colors::Gender::attr_Text_p node = XSD::createAttributeTmpl<attr_Text>(t);
2915
2916     if(options.isSampleCreate && (node->stringValue() == "") ) {
2917       node->stringValue(node->sampleValue());
2918     }
2919
2920     _attr_Text = node;
2921
2922     return node;
2923   }
2924
2925
2926     void GenoPro::Global::Display::Colors::Gender::set_attr_Text(DOMString val)
2927     {
2928
2929       attribute_attr_Text()->stringValue(val);
2930     }
2931
2932     DOMString GenoPro::Global::Display::Colors::Gender::get_attr_Text_string()
2933     {
2934
2935       return attribute_attr_Text()->stringValue();
2936     }
2937
2938
2939   GenoPro::Global::Display::Colors::Gender::attr_Text_p GenoPro::Global::Display::Colors::Gender::attribute_attr_Text()
2940   {
2941     FSM::warnNullNode(_attr_Text, "attr_Text", "{http://www.w3.org/2001/XMLSchema}Text", 1);
2942     return _attr_Text;
2943   }
2944
2945 #ifndef __Gender_attr_Fill_member_attrs_fns
2946 #define __Gender_attr_Fill_member_attrs_fns
2947
2948
2949   GenoPro::Global::Display::Colors::Gender::attr_Fill_ptr GenoPro::Global::Display::Colors::Gender::create_attr_Fill(FsmCbOptions& options)
2950   {
2951     static DOMStringPtr myName = new DOMString("Fill");
2952     static DOMStringPtr myNsUri = NULL;
2953
2954     if(_attr_Fill) {
2955       return _attr_Fill;
2956     }
2957     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
2958     GenoPro::Global::Display::Colors::Gender::attr_Fill_p node = XSD::createAttributeTmpl<attr_Fill>(t);
2959
2960     if(options.isSampleCreate && (node->stringValue() == "") ) {
2961       node->stringValue(node->sampleValue());
2962     }
2963
2964     _attr_Fill = node;
2965
2966     return node;
2967   }
2968
2969
2970     void GenoPro::Global::Display::Colors::Gender::set_attr_Fill(DOMString val)
2971     {
2972
2973       attribute_attr_Fill()->stringValue(val);
2974     }
2975
2976     DOMString GenoPro::Global::Display::Colors::Gender::get_attr_Fill_string()
2977     {
2978
2979       return attribute_attr_Fill()->stringValue();
2980     }
2981
2982
2983   GenoPro::Global::Display::Colors::Gender::attr_Fill_p GenoPro::Global::Display::Colors::Gender::attribute_attr_Fill()
2984   {
2985     FSM::warnNullNode(_attr_Fill, "attr_Fill", "{http://www.w3.org/2001/XMLSchema}Fill", 1);
2986     return _attr_Fill;
2987   }
2988
2989 #endif // __Gender_attr_Fill_member_attrs_fns
2990
2991   //constructor
2992   GenoPro::Global::Display::Colors::Gender::sequence::sequence(Gender* that):
2993     _that(that)
2994   {
2995     XsdFsmBasePtr fsmArray[] = {
2996     new XsdFSM<Fill_ptr>( Particle(new DOMString("libgno"), DOMString("Fill"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Fill_ptr, Gender, FsmCbOptions>(_that, &Gender::create_Fill)),
2997
2998       NULL
2999     } ;
3000
3001     XsdSequenceFsmOfFSMs::init(fsmArray);
3002   }
3003
3004
3005
3006   GenoPro::Global::Display::Colors::Gender::Fill_p GenoPro::Global::Display::Colors::Gender::sequence::element_Fill()
3007   {
3008       GenoPro::Global::Display::Colors::Gender::Fill_p node_p = NULL;
3009     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
3010     if(fsm_p)
3011     {
3012       XsdFSM<Fill_ptr> *unitFsm = dynamic_cast<XsdFSM<Fill_ptr> *>(fsm_p);
3013       if(unitFsm && unitFsm->nodeList().size()>0) {
3014         assert(unitFsm->nodeList().size()==1);
3015         node_p = unitFsm->nodeList().at(0);
3016       }
3017     }
3018
3019     FSM::warnNullNode(node_p, "Fill", "{}Fill", 0);
3020     return node_p;
3021
3022   }
3023
3024
3025
3026   void GenoPro::Global::Display::Colors::Gender::sequence::mark_present_Fill()
3027   {
3028     DOMStringPtr nsUriPtr = new DOMString("libgno");
3029     XsdEvent event(nsUriPtr, NULL, DOMString("Fill"), XsdEvent::ELEMENT_START, false);
3030     this->processEventThrow(event);
3031   }
3032
3033
3034
3035   //constructor
3036
3037   GenoPro::Global::Display::Colors::Gender::Fill::Fill(ElementCreateArgs args):
3038       XMLSchema::XmlElement<anyType>(args),
3039
3040     _fsmAttrs(NULL),
3041     _fsmElems(NULL)
3042
3043     , _sequence(new sequence(this) )
3044
3045   {
3046     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
3047     initFSM();
3048     if(args.ownerDoc && args.ownerDoc->buildTree())
3049     {
3050       if(args.ownerDoc->createSample()) {
3051         _fsm->fireSampleEvents();
3052       }
3053       else {
3054         _fsm->fireRequiredEvents();
3055       }
3056     }
3057   }
3058
3059   void GenoPro::Global::Display::Colors::Gender::Fill::initFSM()
3060   {
3061     XsdFsmBasePtr fsmsAttrs[] = {
3062
3063       NULL
3064     };
3065
3066     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
3067
3068     _fsm->replaceContentFsm(_sequence);
3069
3070     _fsmAttrs = _fsm->attributeFsm();
3071     _fsmElems = _fsm->contentFsm();
3072
3073   }
3074
3075   /* element functions  */
3076
3077
3078   GenoPro::Global::Display::Colors::Gender::Fill::Top_ptr GenoPro::Global::Display::Colors::Gender::Fill::create_Top(FsmCbOptions& options)
3079   {
3080     static DOMStringPtr myName = new DOMString("Top");
3081     static DOMStringPtr myNsUri = new DOMString("libgno");
3082
3083     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
3084     GenoPro::Global::Display::Colors::Gender::Fill::Top_p node = XSD::createElementTmpl<Top, void*>(t);
3085
3086     if(options.isSampleCreate && (node->stringValue() == "") ) {
3087       node->stringValue(node->sampleValue());
3088     }
3089
3090     _Top = node;
3091
3092     return node;
3093   }
3094
3095
3096   GenoPro::Global::Display::Colors::Gender::Fill::Top_p GenoPro::Global::Display::Colors::Gender::Fill::element_Top()
3097   {
3098     FSM::warnNullNode(_Top, "Top", "{}Top", 0);
3099     return _Top;
3100   }
3101
3102   void GenoPro::Global::Display::Colors::Gender::Fill::mark_present_Top()
3103   {
3104     return get_sequence()->mark_present_Top();
3105   }
3106
3107
3108   GenoPro::Global::Display::Colors::Gender::Fill::Bottom_ptr GenoPro::Global::Display::Colors::Gender::Fill::create_Bottom(FsmCbOptions& options)
3109   {
3110     static DOMStringPtr myName = new DOMString("Bottom");
3111     static DOMStringPtr myNsUri = new DOMString("libgno");
3112
3113     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
3114     GenoPro::Global::Display::Colors::Gender::Fill::Bottom_p node = XSD::createElementTmpl<Bottom, void*>(t);
3115
3116     if(options.isSampleCreate && (node->stringValue() == "") ) {
3117       node->stringValue(node->sampleValue());
3118     }
3119
3120     _Bottom = node;
3121
3122     return node;
3123   }
3124
3125
3126   GenoPro::Global::Display::Colors::Gender::Fill::Bottom_p GenoPro::Global::Display::Colors::Gender::Fill::element_Bottom()
3127   {
3128     FSM::warnNullNode(_Bottom, "Bottom", "{}Bottom", 0);
3129     return _Bottom;
3130   }
3131
3132   void GenoPro::Global::Display::Colors::Gender::Fill::mark_present_Bottom()
3133   {
3134     return get_sequence()->mark_present_Bottom();
3135   }
3136
3137
3138   /* attribute  functions  */
3139
3140   //constructor
3141   GenoPro::Global::Display::Colors::Gender::Fill::sequence::sequence(Fill* that):
3142     _that(that)
3143   {
3144     XsdFsmBasePtr fsmArray[] = {
3145     new XsdFSM<Top_ptr>( Particle(new DOMString("libgno"), DOMString("Top"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Top_ptr, Fill, FsmCbOptions>(_that, &Fill::create_Top)),
3146       new XsdFSM<Bottom_ptr>( Particle(new DOMString("libgno"), DOMString("Bottom"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Bottom_ptr, Fill, FsmCbOptions>(_that, &Fill::create_Bottom)),
3147
3148       NULL
3149     } ;
3150
3151     XsdSequenceFsmOfFSMs::init(fsmArray);
3152   }
3153
3154
3155
3156   GenoPro::Global::Display::Colors::Gender::Fill::Top_p GenoPro::Global::Display::Colors::Gender::Fill::sequence::element_Top()
3157   {
3158       GenoPro::Global::Display::Colors::Gender::Fill::Top_p node_p = NULL;
3159     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
3160     if(fsm_p)
3161     {
3162       XsdFSM<Top_ptr> *unitFsm = dynamic_cast<XsdFSM<Top_ptr> *>(fsm_p);
3163       if(unitFsm && unitFsm->nodeList().size()>0) {
3164         assert(unitFsm->nodeList().size()==1);
3165         node_p = unitFsm->nodeList().at(0);
3166       }
3167     }
3168
3169     FSM::warnNullNode(node_p, "Top", "{}Top", 0);
3170     return node_p;
3171
3172   }
3173
3174
3175
3176   void GenoPro::Global::Display::Colors::Gender::Fill::sequence::mark_present_Top()
3177   {
3178     DOMStringPtr nsUriPtr = new DOMString("libgno");
3179     XsdEvent event(nsUriPtr, NULL, DOMString("Top"), XsdEvent::ELEMENT_START, false);
3180     this->processEventThrow(event);
3181   }
3182
3183
3184
3185   GenoPro::Global::Display::Colors::Gender::Fill::Bottom_p GenoPro::Global::Display::Colors::Gender::Fill::sequence::element_Bottom()
3186   {
3187       GenoPro::Global::Display::Colors::Gender::Fill::Bottom_p node_p = NULL;
3188     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
3189     if(fsm_p)
3190     {
3191       XsdFSM<Bottom_ptr> *unitFsm = dynamic_cast<XsdFSM<Bottom_ptr> *>(fsm_p);
3192       if(unitFsm && unitFsm->nodeList().size()>0) {
3193         assert(unitFsm->nodeList().size()==1);
3194         node_p = unitFsm->nodeList().at(0);
3195       }
3196     }
3197
3198     FSM::warnNullNode(node_p, "Bottom", "{}Bottom", 0);
3199     return node_p;
3200
3201   }
3202
3203
3204
3205   void GenoPro::Global::Display::Colors::Gender::Fill::sequence::mark_present_Bottom()
3206   {
3207     DOMStringPtr nsUriPtr = new DOMString("libgno");
3208     XsdEvent event(nsUriPtr, NULL, DOMString("Bottom"), XsdEvent::ELEMENT_START, false);
3209     this->processEventThrow(event);
3210   }
3211
3212
3213   //constructor
3214
3215   GenoPro::Global::Display::Colors::Gender::Fill::Top::Top(ElementCreateArgs args):
3216       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
3217
3218     _fsmAttrs(NULL),
3219     _fsmElems(NULL)
3220   {
3221
3222
3223     initFSM();
3224
3225
3226     if(args.ownerDoc && args.ownerDoc->buildTree())
3227
3228     {
3229       if(args.ownerDoc->createSample()) {
3230         _fsm->fireSampleEvents();
3231       }
3232       else {
3233         _fsm->fireRequiredEvents();
3234       }
3235     }
3236   }
3237
3238   void GenoPro::Global::Display::Colors::Gender::Fill::Top::initFSM()
3239   {
3240     XsdFsmBasePtr fsmsAttrs[] = {
3241     new XsdFSM<attr_Left_ptr>( Particle(NULL, DOMString("Left"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Left_ptr, Top, FsmCbOptions>(this, &Top::create_attr_Left)),
3242     new XsdFSM<attr_Right_ptr>( Particle(NULL, DOMString("Right"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Right_ptr, Top, FsmCbOptions>(this, &Top::create_attr_Right)),
3243
3244       NULL
3245     };
3246
3247     _fsm->appendAttributeFsms(fsmsAttrs);
3248     _fsmAttrs = _fsm->attributeFsm();
3249     _fsmElems = _fsm->contentFsm();
3250
3251    }
3252
3253   /* element functions  */
3254
3255
3256   /* attribute  functions  */
3257
3258
3259   GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Left_ptr GenoPro::Global::Display::Colors::Gender::Fill::Top::create_attr_Left(FsmCbOptions& options)
3260   {
3261     static DOMStringPtr myName = new DOMString("Left");
3262     static DOMStringPtr myNsUri = NULL;
3263
3264     if(_attr_Left) {
3265       return _attr_Left;
3266     }
3267     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3268     GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Left_p node = XSD::createAttributeTmpl<attr_Left>(t);
3269
3270     if(options.isSampleCreate && (node->stringValue() == "") ) {
3271       node->stringValue(node->sampleValue());
3272     }
3273
3274     _attr_Left = node;
3275
3276     return node;
3277   }
3278
3279
3280     void GenoPro::Global::Display::Colors::Gender::Fill::Top::set_attr_Left(DOMString val)
3281     {
3282
3283       attribute_attr_Left()->stringValue(val);
3284     }
3285
3286     DOMString GenoPro::Global::Display::Colors::Gender::Fill::Top::get_attr_Left_string()
3287     {
3288
3289       return attribute_attr_Left()->stringValue();
3290     }
3291
3292
3293   GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Left_p GenoPro::Global::Display::Colors::Gender::Fill::Top::attribute_attr_Left()
3294   {
3295     FSM::warnNullNode(_attr_Left, "attr_Left", "{http://www.w3.org/2001/XMLSchema}Left", 1);
3296     return _attr_Left;
3297   }
3298
3299
3300   GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Right_ptr GenoPro::Global::Display::Colors::Gender::Fill::Top::create_attr_Right(FsmCbOptions& options)
3301   {
3302     static DOMStringPtr myName = new DOMString("Right");
3303     static DOMStringPtr myNsUri = NULL;
3304
3305     if(_attr_Right) {
3306       return _attr_Right;
3307     }
3308     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3309     GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Right_p node = XSD::createAttributeTmpl<attr_Right>(t);
3310
3311     if(options.isSampleCreate && (node->stringValue() == "") ) {
3312       node->stringValue(node->sampleValue());
3313     }
3314
3315     _attr_Right = node;
3316
3317     return node;
3318   }
3319
3320
3321     void GenoPro::Global::Display::Colors::Gender::Fill::Top::set_attr_Right(DOMString val)
3322     {
3323
3324       attribute_attr_Right()->stringValue(val);
3325     }
3326
3327     DOMString GenoPro::Global::Display::Colors::Gender::Fill::Top::get_attr_Right_string()
3328     {
3329
3330       return attribute_attr_Right()->stringValue();
3331     }
3332
3333
3334   GenoPro::Global::Display::Colors::Gender::Fill::Top::attr_Right_p GenoPro::Global::Display::Colors::Gender::Fill::Top::attribute_attr_Right()
3335   {
3336     FSM::warnNullNode(_attr_Right, "attr_Right", "{http://www.w3.org/2001/XMLSchema}Right", 1);
3337     return _attr_Right;
3338   }
3339
3340   //constructor
3341
3342   GenoPro::Global::Display::Colors::Gender::Fill::Bottom::Bottom(ElementCreateArgs args):
3343       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
3344
3345     _fsmAttrs(NULL),
3346     _fsmElems(NULL)
3347   {
3348
3349
3350     initFSM();
3351
3352
3353     if(args.ownerDoc && args.ownerDoc->buildTree())
3354
3355     {
3356       if(args.ownerDoc->createSample()) {
3357         _fsm->fireSampleEvents();
3358       }
3359       else {
3360         _fsm->fireRequiredEvents();
3361       }
3362     }
3363   }
3364
3365   void GenoPro::Global::Display::Colors::Gender::Fill::Bottom::initFSM()
3366   {
3367     XsdFsmBasePtr fsmsAttrs[] = {
3368     new XsdFSM<attr_Left_ptr>( Particle(NULL, DOMString("Left"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Left_ptr, Bottom, FsmCbOptions>(this, &Bottom::create_attr_Left)),
3369     new XsdFSM<attr_Right_ptr>( Particle(NULL, DOMString("Right"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Right_ptr, Bottom, FsmCbOptions>(this, &Bottom::create_attr_Right)),
3370
3371       NULL
3372     };
3373
3374     _fsm->appendAttributeFsms(fsmsAttrs);
3375     _fsmAttrs = _fsm->attributeFsm();
3376     _fsmElems = _fsm->contentFsm();
3377
3378    }
3379
3380   /* element functions  */
3381
3382
3383   /* attribute  functions  */
3384
3385
3386   GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Left_ptr GenoPro::Global::Display::Colors::Gender::Fill::Bottom::create_attr_Left(FsmCbOptions& options)
3387   {
3388     static DOMStringPtr myName = new DOMString("Left");
3389     static DOMStringPtr myNsUri = NULL;
3390
3391     if(_attr_Left) {
3392       return _attr_Left;
3393     }
3394     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3395     GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Left_p node = XSD::createAttributeTmpl<attr_Left>(t);
3396
3397     if(options.isSampleCreate && (node->stringValue() == "") ) {
3398       node->stringValue(node->sampleValue());
3399     }
3400
3401     _attr_Left = node;
3402
3403     return node;
3404   }
3405
3406
3407     void GenoPro::Global::Display::Colors::Gender::Fill::Bottom::set_attr_Left(DOMString val)
3408     {
3409
3410       attribute_attr_Left()->stringValue(val);
3411     }
3412
3413     DOMString GenoPro::Global::Display::Colors::Gender::Fill::Bottom::get_attr_Left_string()
3414     {
3415
3416       return attribute_attr_Left()->stringValue();
3417     }
3418
3419
3420   GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Left_p GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attribute_attr_Left()
3421   {
3422     FSM::warnNullNode(_attr_Left, "attr_Left", "{http://www.w3.org/2001/XMLSchema}Left", 1);
3423     return _attr_Left;
3424   }
3425
3426
3427   GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Right_ptr GenoPro::Global::Display::Colors::Gender::Fill::Bottom::create_attr_Right(FsmCbOptions& options)
3428   {
3429     static DOMStringPtr myName = new DOMString("Right");
3430     static DOMStringPtr myNsUri = NULL;
3431
3432     if(_attr_Right) {
3433       return _attr_Right;
3434     }
3435     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3436     GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Right_p node = XSD::createAttributeTmpl<attr_Right>(t);
3437
3438     if(options.isSampleCreate && (node->stringValue() == "") ) {
3439       node->stringValue(node->sampleValue());
3440     }
3441
3442     _attr_Right = node;
3443
3444     return node;
3445   }
3446
3447
3448     void GenoPro::Global::Display::Colors::Gender::Fill::Bottom::set_attr_Right(DOMString val)
3449     {
3450
3451       attribute_attr_Right()->stringValue(val);
3452     }
3453
3454     DOMString GenoPro::Global::Display::Colors::Gender::Fill::Bottom::get_attr_Right_string()
3455     {
3456
3457       return attribute_attr_Right()->stringValue();
3458     }
3459
3460
3461   GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attr_Right_p GenoPro::Global::Display::Colors::Gender::Fill::Bottom::attribute_attr_Right()
3462   {
3463     FSM::warnNullNode(_attr_Right, "attr_Right", "{http://www.w3.org/2001/XMLSchema}Right", 1);
3464     return _attr_Right;
3465   }
3466
3467
3468   //constructor
3469
3470   GenoPro::Global::Display::Colors::Border::Border(ElementCreateArgs args):
3471       XMLSchema::XmlElement<anyType>(args),
3472
3473     _fsmAttrs(NULL),
3474     _fsmElems(NULL)
3475
3476     , _sequence(new sequence(this) )
3477
3478   {
3479     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
3480     initFSM();
3481     if(args.ownerDoc && args.ownerDoc->buildTree())
3482     {
3483       if(args.ownerDoc->createSample()) {
3484         _fsm->fireSampleEvents();
3485       }
3486       else {
3487         _fsm->fireRequiredEvents();
3488       }
3489     }
3490   }
3491
3492   void GenoPro::Global::Display::Colors::Border::initFSM()
3493   {
3494     XsdFsmBasePtr fsmsAttrs[] = {
3495   new XsdFSM<attr_Outline_ptr>( Particle(NULL, DOMString("Outline"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Outline_ptr, Border, FsmCbOptions>(this, &Border::create_attr_Outline)),
3496
3497       NULL
3498     };
3499
3500     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
3501
3502     _fsm->replaceContentFsm(_sequence);
3503
3504     _fsmAttrs = _fsm->attributeFsm();
3505     _fsmElems = _fsm->contentFsm();
3506
3507   }
3508
3509   /* element functions  */
3510
3511
3512   GenoPro::Global::Display::Colors::Border::Fill_ptr GenoPro::Global::Display::Colors::Border::create_Fill(FsmCbOptions& options)
3513   {
3514     static DOMStringPtr myName = new DOMString("Fill");
3515     static DOMStringPtr myNsUri = new DOMString("libgno");
3516
3517     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
3518     GenoPro::Global::Display::Colors::Border::Fill_p node = XSD::createElementTmpl<Fill, XMLSchema::Types::bt_normalizedString*>(t);
3519
3520     if(options.isSampleCreate && (node->stringValue() == "") ) {
3521       node->stringValue(node->sampleValue());
3522     }
3523
3524     _Fill = node;
3525
3526     return node;
3527   }
3528
3529
3530   GenoPro::Global::Display::Colors::Border::Fill_p GenoPro::Global::Display::Colors::Border::element_Fill()
3531   {
3532     FSM::warnNullNode(_Fill, "Fill", "{http://www.w3.org/2001/XMLSchema}Fill", 0);
3533     return _Fill;
3534   }
3535
3536   void GenoPro::Global::Display::Colors::Border::set_Fill(DOMString val)
3537   {
3538     get_sequence()->set_Fill(val);
3539   }
3540
3541   DOMString GenoPro::Global::Display::Colors::Border::get_Fill_string()
3542   {
3543     return get_sequence()->get_Fill_string();
3544   }
3545
3546
3547   void GenoPro::Global::Display::Colors::Border::mark_present_Fill()
3548   {
3549     return get_sequence()->mark_present_Fill();
3550   }
3551
3552
3553   /* attribute  functions  */
3554
3555
3556   GenoPro::Global::Display::Colors::Border::attr_Outline_ptr GenoPro::Global::Display::Colors::Border::create_attr_Outline(FsmCbOptions& options)
3557   {
3558     static DOMStringPtr myName = new DOMString("Outline");
3559     static DOMStringPtr myNsUri = NULL;
3560
3561     if(_attr_Outline) {
3562       return _attr_Outline;
3563     }
3564     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3565     GenoPro::Global::Display::Colors::Border::attr_Outline_p node = XSD::createAttributeTmpl<attr_Outline>(t);
3566
3567     if(options.isSampleCreate && (node->stringValue() == "") ) {
3568       node->stringValue(node->sampleValue());
3569     }
3570
3571     _attr_Outline = node;
3572
3573     return node;
3574   }
3575
3576
3577     void GenoPro::Global::Display::Colors::Border::set_attr_Outline(DOMString val)
3578     {
3579
3580       attribute_attr_Outline()->stringValue(val);
3581     }
3582
3583     DOMString GenoPro::Global::Display::Colors::Border::get_attr_Outline_string()
3584     {
3585
3586       return attribute_attr_Outline()->stringValue();
3587     }
3588
3589
3590   GenoPro::Global::Display::Colors::Border::attr_Outline_p GenoPro::Global::Display::Colors::Border::attribute_attr_Outline()
3591   {
3592     FSM::warnNullNode(_attr_Outline, "attr_Outline", "{http://www.w3.org/2001/XMLSchema}Outline", 1);
3593     return _attr_Outline;
3594   }
3595
3596   //constructor
3597   GenoPro::Global::Display::Colors::Border::sequence::sequence(Border* that):
3598     _that(that)
3599   {
3600     XsdFsmBasePtr fsmArray[] = {
3601     new XsdFSM<Fill_ptr>( Particle(new DOMString("libgno"), DOMString("Fill"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Fill_ptr, Border, FsmCbOptions>(_that, &Border::create_Fill)),
3602
3603       NULL
3604     } ;
3605
3606     XsdSequenceFsmOfFSMs::init(fsmArray);
3607   }
3608
3609
3610
3611   GenoPro::Global::Display::Colors::Border::Fill_p GenoPro::Global::Display::Colors::Border::sequence::element_Fill()
3612   {
3613       GenoPro::Global::Display::Colors::Border::Fill_p node_p = NULL;
3614     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
3615     if(fsm_p)
3616     {
3617       XsdFSM<Fill_ptr> *unitFsm = dynamic_cast<XsdFSM<Fill_ptr> *>(fsm_p);
3618       if(unitFsm && unitFsm->nodeList().size()>0) {
3619         assert(unitFsm->nodeList().size()==1);
3620         node_p = unitFsm->nodeList().at(0);
3621       }
3622     }
3623
3624     FSM::warnNullNode(node_p, "Fill", "{http://www.w3.org/2001/XMLSchema}Fill", 0);
3625     return node_p;
3626
3627   }
3628
3629
3630   void GenoPro::Global::Display::Colors::Border::sequence::set_Fill(DOMString val)
3631   {
3632
3633     mark_present_Fill();
3634
3635     element_Fill()->stringValue(val);
3636   }
3637
3638   DOMString GenoPro::Global::Display::Colors::Border::sequence::get_Fill_string()
3639   {
3640     return element_Fill()->stringValue();
3641   }
3642
3643
3644
3645   void GenoPro::Global::Display::Colors::Border::sequence::mark_present_Fill()
3646   {
3647     DOMStringPtr nsUriPtr = new DOMString("libgno");
3648     XsdEvent event(nsUriPtr, NULL, DOMString("Fill"), XsdEvent::ELEMENT_START, false);
3649     this->processEventThrow(event);
3650   }
3651
3652
3653
3654   //constructor
3655
3656   GenoPro::Global::Display::Colors::Label::Label(ElementCreateArgs args):
3657       XMLSchema::XmlElement<anyType>(args),
3658
3659     _fsmAttrs(NULL),
3660     _fsmElems(NULL)
3661
3662     , _sequence(new sequence(this) )
3663
3664   {
3665     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
3666     initFSM();
3667     if(args.ownerDoc && args.ownerDoc->buildTree())
3668     {
3669       if(args.ownerDoc->createSample()) {
3670         _fsm->fireSampleEvents();
3671       }
3672       else {
3673         _fsm->fireRequiredEvents();
3674       }
3675     }
3676   }
3677
3678   void GenoPro::Global::Display::Colors::Label::initFSM()
3679   {
3680     XsdFsmBasePtr fsmsAttrs[] = {
3681   new XsdFSM<attr_Top_ptr>( Particle(NULL, DOMString("Top"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Top_ptr, Label, FsmCbOptions>(this, &Label::create_attr_Top)),
3682   new XsdFSM<attr_Bottom_ptr>( Particle(NULL, DOMString("Bottom"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Bottom_ptr, Label, FsmCbOptions>(this, &Label::create_attr_Bottom)),
3683
3684       NULL
3685     };
3686
3687     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
3688
3689     _fsm->replaceContentFsm(_sequence);
3690
3691     _fsmAttrs = _fsm->attributeFsm();
3692     _fsmElems = _fsm->contentFsm();
3693
3694   }
3695
3696   /* element functions  */
3697
3698
3699   GenoPro::Global::Display::Colors::Label::Fill_ptr GenoPro::Global::Display::Colors::Label::create_Fill(FsmCbOptions& options)
3700   {
3701     static DOMStringPtr myName = new DOMString("Fill");
3702     static DOMStringPtr myNsUri = new DOMString("libgno");
3703
3704     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
3705     GenoPro::Global::Display::Colors::Label::Fill_p node = XSD::createElementTmpl<Fill, void*>(t);
3706
3707     if(options.isSampleCreate && (node->stringValue() == "") ) {
3708       node->stringValue(node->sampleValue());
3709     }
3710
3711     _Fill = node;
3712
3713     return node;
3714   }
3715
3716
3717   GenoPro::Global::Display::Colors::Label::Fill_p GenoPro::Global::Display::Colors::Label::element_Fill()
3718   {
3719     FSM::warnNullNode(_Fill, "Fill", "{}Fill", 0);
3720     return _Fill;
3721   }
3722
3723   void GenoPro::Global::Display::Colors::Label::mark_present_Fill()
3724   {
3725     return get_sequence()->mark_present_Fill();
3726   }
3727
3728 #ifndef __Label_attr_Top_member_elems_fns
3729 #define __Label_attr_Top_member_elems_fns
3730
3731 #endif // __Label_attr_Top_member_elems_fns
3732
3733 #ifndef __Label_attr_Bottom_member_elems_fns
3734 #define __Label_attr_Bottom_member_elems_fns
3735
3736 #endif // __Label_attr_Bottom_member_elems_fns
3737
3738
3739   /* attribute  functions  */
3740
3741 #ifndef __Label_attr_Top_member_attrs_fns
3742 #define __Label_attr_Top_member_attrs_fns
3743
3744
3745   GenoPro::Global::Display::Colors::Label::attr_Top_ptr GenoPro::Global::Display::Colors::Label::create_attr_Top(FsmCbOptions& options)
3746   {
3747     static DOMStringPtr myName = new DOMString("Top");
3748     static DOMStringPtr myNsUri = NULL;
3749
3750     if(_attr_Top) {
3751       return _attr_Top;
3752     }
3753     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3754     GenoPro::Global::Display::Colors::Label::attr_Top_p node = XSD::createAttributeTmpl<attr_Top>(t);
3755
3756     if(options.isSampleCreate && (node->stringValue() == "") ) {
3757       node->stringValue(node->sampleValue());
3758     }
3759
3760     _attr_Top = node;
3761
3762     return node;
3763   }
3764
3765
3766     void GenoPro::Global::Display::Colors::Label::set_attr_Top(DOMString val)
3767     {
3768
3769       attribute_attr_Top()->stringValue(val);
3770     }
3771
3772     DOMString GenoPro::Global::Display::Colors::Label::get_attr_Top_string()
3773     {
3774
3775       return attribute_attr_Top()->stringValue();
3776     }
3777
3778
3779   GenoPro::Global::Display::Colors::Label::attr_Top_p GenoPro::Global::Display::Colors::Label::attribute_attr_Top()
3780   {
3781     FSM::warnNullNode(_attr_Top, "attr_Top", "{http://www.w3.org/2001/XMLSchema}Top", 1);
3782     return _attr_Top;
3783   }
3784
3785 #endif // __Label_attr_Top_member_attrs_fns
3786
3787 #ifndef __Label_attr_Bottom_member_attrs_fns
3788 #define __Label_attr_Bottom_member_attrs_fns
3789
3790
3791   GenoPro::Global::Display::Colors::Label::attr_Bottom_ptr GenoPro::Global::Display::Colors::Label::create_attr_Bottom(FsmCbOptions& options)
3792   {
3793     static DOMStringPtr myName = new DOMString("Bottom");
3794     static DOMStringPtr myNsUri = NULL;
3795
3796     if(_attr_Bottom) {
3797       return _attr_Bottom;
3798     }
3799     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3800     GenoPro::Global::Display::Colors::Label::attr_Bottom_p node = XSD::createAttributeTmpl<attr_Bottom>(t);
3801
3802     if(options.isSampleCreate && (node->stringValue() == "") ) {
3803       node->stringValue(node->sampleValue());
3804     }
3805
3806     _attr_Bottom = node;
3807
3808     return node;
3809   }
3810
3811
3812     void GenoPro::Global::Display::Colors::Label::set_attr_Bottom(DOMString val)
3813     {
3814
3815       attribute_attr_Bottom()->stringValue(val);
3816     }
3817
3818     DOMString GenoPro::Global::Display::Colors::Label::get_attr_Bottom_string()
3819     {
3820
3821       return attribute_attr_Bottom()->stringValue();
3822     }
3823
3824
3825   GenoPro::Global::Display::Colors::Label::attr_Bottom_p GenoPro::Global::Display::Colors::Label::attribute_attr_Bottom()
3826   {
3827     FSM::warnNullNode(_attr_Bottom, "attr_Bottom", "{http://www.w3.org/2001/XMLSchema}Bottom", 1);
3828     return _attr_Bottom;
3829   }
3830
3831 #endif // __Label_attr_Bottom_member_attrs_fns
3832
3833   //constructor
3834   GenoPro::Global::Display::Colors::Label::sequence::sequence(Label* that):
3835     _that(that)
3836   {
3837     XsdFsmBasePtr fsmArray[] = {
3838     new XsdFSM<Fill_ptr>( Particle(new DOMString("libgno"), DOMString("Fill"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Fill_ptr, Label, FsmCbOptions>(_that, &Label::create_Fill)),
3839
3840       NULL
3841     } ;
3842
3843     XsdSequenceFsmOfFSMs::init(fsmArray);
3844   }
3845
3846
3847
3848   GenoPro::Global::Display::Colors::Label::Fill_p GenoPro::Global::Display::Colors::Label::sequence::element_Fill()
3849   {
3850       GenoPro::Global::Display::Colors::Label::Fill_p node_p = NULL;
3851     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
3852     if(fsm_p)
3853     {
3854       XsdFSM<Fill_ptr> *unitFsm = dynamic_cast<XsdFSM<Fill_ptr> *>(fsm_p);
3855       if(unitFsm && unitFsm->nodeList().size()>0) {
3856         assert(unitFsm->nodeList().size()==1);
3857         node_p = unitFsm->nodeList().at(0);
3858       }
3859     }
3860
3861     FSM::warnNullNode(node_p, "Fill", "{}Fill", 0);
3862     return node_p;
3863
3864   }
3865
3866
3867
3868   void GenoPro::Global::Display::Colors::Label::sequence::mark_present_Fill()
3869   {
3870     DOMStringPtr nsUriPtr = new DOMString("libgno");
3871     XsdEvent event(nsUriPtr, NULL, DOMString("Fill"), XsdEvent::ELEMENT_START, false);
3872     this->processEventThrow(event);
3873   }
3874
3875
3876   //constructor
3877
3878   GenoPro::Global::Display::Colors::Label::Fill::Fill(ElementCreateArgs args):
3879       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
3880
3881     _fsmAttrs(NULL),
3882     _fsmElems(NULL)
3883   {
3884
3885
3886     initFSM();
3887
3888
3889     if(args.ownerDoc && args.ownerDoc->buildTree())
3890
3891     {
3892       if(args.ownerDoc->createSample()) {
3893         _fsm->fireSampleEvents();
3894       }
3895       else {
3896         _fsm->fireRequiredEvents();
3897       }
3898     }
3899   }
3900
3901   void GenoPro::Global::Display::Colors::Label::Fill::initFSM()
3902   {
3903     XsdFsmBasePtr fsmsAttrs[] = {
3904     new XsdFSM<attr_Top_ptr>( Particle(NULL, DOMString("Top"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Top_ptr, Fill, FsmCbOptions>(this, &Fill::create_attr_Top)),
3905     new XsdFSM<attr_Bottom_ptr>( Particle(NULL, DOMString("Bottom"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Bottom_ptr, Fill, FsmCbOptions>(this, &Fill::create_attr_Bottom)),
3906
3907       NULL
3908     };
3909
3910     _fsm->appendAttributeFsms(fsmsAttrs);
3911     _fsmAttrs = _fsm->attributeFsm();
3912     _fsmElems = _fsm->contentFsm();
3913
3914    }
3915
3916   /* element functions  */
3917
3918
3919   /* attribute  functions  */
3920
3921
3922   GenoPro::Global::Display::Colors::Label::Fill::attr_Top_ptr GenoPro::Global::Display::Colors::Label::Fill::create_attr_Top(FsmCbOptions& options)
3923   {
3924     static DOMStringPtr myName = new DOMString("Top");
3925     static DOMStringPtr myNsUri = NULL;
3926
3927     if(_attr_Top) {
3928       return _attr_Top;
3929     }
3930     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3931     GenoPro::Global::Display::Colors::Label::Fill::attr_Top_p node = XSD::createAttributeTmpl<attr_Top>(t);
3932
3933     if(options.isSampleCreate && (node->stringValue() == "") ) {
3934       node->stringValue(node->sampleValue());
3935     }
3936
3937     _attr_Top = node;
3938
3939     return node;
3940   }
3941
3942
3943     void GenoPro::Global::Display::Colors::Label::Fill::set_attr_Top(DOMString val)
3944     {
3945
3946       attribute_attr_Top()->stringValue(val);
3947     }
3948
3949     DOMString GenoPro::Global::Display::Colors::Label::Fill::get_attr_Top_string()
3950     {
3951
3952       return attribute_attr_Top()->stringValue();
3953     }
3954
3955
3956   GenoPro::Global::Display::Colors::Label::Fill::attr_Top_p GenoPro::Global::Display::Colors::Label::Fill::attribute_attr_Top()
3957   {
3958     FSM::warnNullNode(_attr_Top, "attr_Top", "{http://www.w3.org/2001/XMLSchema}Top", 1);
3959     return _attr_Top;
3960   }
3961
3962
3963   GenoPro::Global::Display::Colors::Label::Fill::attr_Bottom_ptr GenoPro::Global::Display::Colors::Label::Fill::create_attr_Bottom(FsmCbOptions& options)
3964   {
3965     static DOMStringPtr myName = new DOMString("Bottom");
3966     static DOMStringPtr myNsUri = NULL;
3967
3968     if(_attr_Bottom) {
3969       return _attr_Bottom;
3970     }
3971     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
3972     GenoPro::Global::Display::Colors::Label::Fill::attr_Bottom_p node = XSD::createAttributeTmpl<attr_Bottom>(t);
3973
3974     if(options.isSampleCreate && (node->stringValue() == "") ) {
3975       node->stringValue(node->sampleValue());
3976     }
3977
3978     _attr_Bottom = node;
3979
3980     return node;
3981   }
3982
3983
3984     void GenoPro::Global::Display::Colors::Label::Fill::set_attr_Bottom(DOMString val)
3985     {
3986
3987       attribute_attr_Bottom()->stringValue(val);
3988     }
3989
3990     DOMString GenoPro::Global::Display::Colors::Label::Fill::get_attr_Bottom_string()
3991     {
3992
3993       return attribute_attr_Bottom()->stringValue();
3994     }
3995
3996
3997   GenoPro::Global::Display::Colors::Label::Fill::attr_Bottom_p GenoPro::Global::Display::Colors::Label::Fill::attribute_attr_Bottom()
3998   {
3999     FSM::warnNullNode(_attr_Bottom, "attr_Bottom", "{http://www.w3.org/2001/XMLSchema}Bottom", 1);
4000     return _attr_Bottom;
4001   }
4002
4003
4004   //constructor
4005
4006   GenoPro::Global::Tags::Tags(ElementCreateArgs args):
4007       XMLSchema::XmlElement<anyType>(args),
4008
4009     _fsmAttrs(NULL),
4010     _fsmElems(NULL)
4011
4012     , _sequence(new sequence(this) )
4013
4014   {
4015     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
4016     initFSM();
4017     if(args.ownerDoc && args.ownerDoc->buildTree())
4018     {
4019       if(args.ownerDoc->createSample()) {
4020         _fsm->fireSampleEvents();
4021       }
4022       else {
4023         _fsm->fireRequiredEvents();
4024       }
4025     }
4026   }
4027
4028   void GenoPro::Global::Tags::initFSM()
4029   {
4030     XsdFsmBasePtr fsmsAttrs[] = {
4031   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Tags, FsmCbOptions>(this, &Tags::create_attr_ID)),
4032
4033       NULL
4034     };
4035
4036     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
4037
4038     _fsm->replaceContentFsm(_sequence);
4039
4040     _fsmAttrs = _fsm->attributeFsm();
4041     _fsmElems = _fsm->contentFsm();
4042
4043   }
4044
4045   /* element functions  */
4046
4047
4048   GenoPro::Global::Tags::TagData_ptr GenoPro::Global::Tags::create_TagData(FsmCbOptions& options)
4049   {
4050     static DOMStringPtr myName = new DOMString("TagData");
4051     static DOMStringPtr myNsUri = new DOMString("libgno");
4052
4053     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
4054     GenoPro::Global::Tags::TagData_p node = XSD::createElementTmpl<TagData, void*>(t);
4055
4056     _list_TagData.push_back(node);
4057
4058     return node;
4059   }
4060
4061
4062   GenoPro::Global::Tags::TagData_p GenoPro::Global::Tags::element_TagData_at(unsigned int idx)
4063   {
4064     if(idx > _list_TagData.size()-1) {
4065       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
4066     }
4067
4068     return _list_TagData.at(idx);
4069   }
4070
4071   List<GenoPro::Global::Tags::TagData_ptr> GenoPro::Global::Tags::elements_TagData()
4072   {
4073     return _list_TagData;
4074   }
4075
4076   GenoPro::Global::Tags::TagData_p GenoPro::Global::Tags::add_node_TagData()
4077   {
4078     return get_sequence()->add_node_TagData();
4079   }
4080
4081   List<GenoPro::Global::Tags::TagData_ptr> GenoPro::Global::Tags::set_count_TagData(unsigned int size)
4082   {
4083     return get_sequence()->set_count_TagData(size);
4084   }
4085
4086
4087
4088   GenoPro::Global::Tags::DialogLayout_ptr GenoPro::Global::Tags::create_DialogLayout(FsmCbOptions& options)
4089   {
4090     static DOMStringPtr myName = new DOMString("DialogLayout");
4091     static DOMStringPtr myNsUri = new DOMString("libgno");
4092
4093     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
4094     GenoPro::Global::Tags::DialogLayout_p node = XSD::createElementTmpl<DialogLayout, void*>(t);
4095
4096     _DialogLayout = node;
4097
4098     return node;
4099   }
4100
4101
4102   GenoPro::Global::Tags::DialogLayout_p GenoPro::Global::Tags::element_DialogLayout()
4103   {
4104     FSM::warnNullNode(_DialogLayout, "DialogLayout", "{}DialogLayout", 0);
4105     return _DialogLayout;
4106   }
4107
4108   void GenoPro::Global::Tags::mark_present_DialogLayout()
4109   {
4110     return get_sequence()->mark_present_DialogLayout();
4111   }
4112
4113
4114   /* attribute  functions  */
4115
4116
4117   GenoPro::Global::Tags::attr_ID_ptr GenoPro::Global::Tags::create_attr_ID(FsmCbOptions& options)
4118   {
4119     static DOMStringPtr myName = new DOMString("ID");
4120     static DOMStringPtr myNsUri = NULL;
4121
4122     if(_attr_ID) {
4123       return _attr_ID;
4124     }
4125     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
4126     GenoPro::Global::Tags::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
4127
4128     if(options.isSampleCreate && (node->stringValue() == "") ) {
4129       node->stringValue(node->sampleValue());
4130     }
4131
4132     _attr_ID = node;
4133
4134     return node;
4135   }
4136
4137
4138     void GenoPro::Global::Tags::set_attr_ID(DOMString val)
4139     {
4140
4141       attribute_attr_ID()->stringValue(val);
4142     }
4143
4144     DOMString GenoPro::Global::Tags::get_attr_ID_string()
4145     {
4146
4147       return attribute_attr_ID()->stringValue();
4148     }
4149
4150
4151   GenoPro::Global::Tags::attr_ID_p GenoPro::Global::Tags::attribute_attr_ID()
4152   {
4153     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
4154     return _attr_ID;
4155   }
4156
4157   //constructor
4158   GenoPro::Global::Tags::sequence::sequence(Tags* that):
4159     _that(that)
4160   {
4161     XsdFsmBasePtr fsmArray[] = {
4162     new XsdFSM<TagData_ptr>( Particle(new DOMString("libgno"), DOMString("TagData"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<TagData_ptr, Tags, FsmCbOptions>(_that, &Tags::create_TagData)),
4163       new XsdFSM<DialogLayout_ptr>( Particle(new DOMString("libgno"), DOMString("DialogLayout"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DialogLayout_ptr, Tags, FsmCbOptions>(_that, &Tags::create_DialogLayout)),
4164
4165       NULL
4166     } ;
4167
4168     XsdSequenceFsmOfFSMs::init(fsmArray);
4169   }
4170
4171
4172
4173   List<GenoPro::Global::Tags::TagData_ptr> GenoPro::Global::Tags::sequence::elements_TagData()
4174   {
4175
4176     List<TagData_ptr> nodeList;
4177     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
4178     if(fsm_p)
4179     {
4180       XsdFSM<TagData_ptr> *unitFsm = dynamic_cast<XsdFSM<TagData_ptr> *>(fsm_p);
4181       if(unitFsm) {
4182         //nodeList = unitFsm->nodeList().stl_list();
4183         nodeList = unitFsm->nodeList();
4184       }
4185     }
4186     return nodeList;
4187
4188   }
4189
4190
4191   GenoPro::Global::Tags::TagData_p GenoPro::Global::Tags::sequence::element_TagData_at(unsigned int idx)
4192   {
4193     return elements_TagData().at(idx);
4194   }
4195
4196
4197   GenoPro::Global::Tags::TagData_p GenoPro::Global::Tags::sequence::add_node_TagData()
4198   {
4199     DOMStringPtr nsUriPtr = new DOMString("libgno");
4200     XsdEvent event(nsUriPtr, NULL, DOMString("TagData"), XsdEvent::ELEMENT_START, false);
4201     this->processEventThrow(event);
4202     return elements_TagData().back();
4203   }
4204
4205   List<GenoPro::Global::Tags::TagData_ptr> GenoPro::Global::Tags::sequence::set_count_TagData(unsigned int size)
4206   {
4207     if( (size > -1) || (size < 1)) {
4208       ostringstream oss;
4209       oss << "set_count_TagData: size should be in range: [" << 1
4210         << "," << "unbounded" << "]";
4211       throw IndexOutOfBoundsException(oss.str());
4212     }
4213
4214     unsigned int prevSize = elements_TagData().size();
4215     if(size < prevSize) {
4216       //FIXME: allow later:
4217       throw XPlus::RuntimeException("resize lesser than current size not allowed");
4218     }
4219
4220     for(unsigned int j=prevSize; j<size; j++)
4221     {
4222       // pretend docBuilding to avoid computation of adding after first loop
4223       XsdEvent event(new DOMString("libgno"), NULL, DOMString("TagData"), XsdEvent::ELEMENT_START, false);
4224       this->processEventThrow(event);
4225     }
4226
4227     return elements_TagData();
4228   }
4229
4230
4231
4232   GenoPro::Global::Tags::DialogLayout_p GenoPro::Global::Tags::sequence::element_DialogLayout()
4233   {
4234       GenoPro::Global::Tags::DialogLayout_p node_p = NULL;
4235     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
4236     if(fsm_p)
4237     {
4238       XsdFSM<DialogLayout_ptr> *unitFsm = dynamic_cast<XsdFSM<DialogLayout_ptr> *>(fsm_p);
4239       if(unitFsm && unitFsm->nodeList().size()>0) {
4240         assert(unitFsm->nodeList().size()==1);
4241         node_p = unitFsm->nodeList().at(0);
4242       }
4243     }
4244
4245     FSM::warnNullNode(node_p, "DialogLayout", "{}DialogLayout", 0);
4246     return node_p;
4247
4248   }
4249
4250
4251
4252   void GenoPro::Global::Tags::sequence::mark_present_DialogLayout()
4253   {
4254     DOMStringPtr nsUriPtr = new DOMString("libgno");
4255     XsdEvent event(nsUriPtr, NULL, DOMString("DialogLayout"), XsdEvent::ELEMENT_START, false);
4256     this->processEventThrow(event);
4257   }
4258
4259
4260
4261   //constructor
4262
4263   GenoPro::Global::Tags::TagData::TagData(ElementCreateArgs args):
4264       XMLSchema::XmlElement<anyType>(args),
4265
4266     _fsmAttrs(NULL),
4267     _fsmElems(NULL)
4268
4269     , _sequence(new sequence(this) )
4270
4271   {
4272     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
4273     initFSM();
4274     if(args.ownerDoc && args.ownerDoc->buildTree())
4275     {
4276       if(args.ownerDoc->createSample()) {
4277         _fsm->fireSampleEvents();
4278       }
4279       else {
4280         _fsm->fireRequiredEvents();
4281       }
4282     }
4283   }
4284
4285   void GenoPro::Global::Tags::TagData::initFSM()
4286   {
4287     XsdFsmBasePtr fsmsAttrs[] = {
4288   new XsdFSM<attr_Name_ptr>( Particle(NULL, DOMString("Name"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Name_ptr, TagData, FsmCbOptions>(this, &TagData::create_attr_Name)),
4289
4290       NULL
4291     };
4292
4293     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
4294
4295     _fsm->replaceContentFsm(_sequence);
4296
4297     _fsmAttrs = _fsm->attributeFsm();
4298     _fsmElems = _fsm->contentFsm();
4299
4300   }
4301
4302   /* element functions  */
4303
4304
4305   GenoPro::Global::Tags::TagData::DisplayName_ptr GenoPro::Global::Tags::TagData::create_DisplayName(FsmCbOptions& options)
4306   {
4307     static DOMStringPtr myName = new DOMString("DisplayName");
4308     static DOMStringPtr myNsUri = new DOMString("libgno");
4309
4310     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
4311     GenoPro::Global::Tags::TagData::DisplayName_p node = XSD::createElementTmpl<DisplayName, XMLSchema::Types::bt_normalizedString*>(t);
4312
4313     if(options.isSampleCreate && (node->stringValue() == "") ) {
4314       node->stringValue(node->sampleValue());
4315     }
4316
4317     _DisplayName = node;
4318
4319     return node;
4320   }
4321
4322
4323   GenoPro::Global::Tags::TagData::DisplayName_p GenoPro::Global::Tags::TagData::element_DisplayName()
4324   {
4325     FSM::warnNullNode(_DisplayName, "DisplayName", "{http://www.w3.org/2001/XMLSchema}DisplayName", 0);
4326     return _DisplayName;
4327   }
4328
4329   void GenoPro::Global::Tags::TagData::set_DisplayName(DOMString val)
4330   {
4331     get_sequence()->set_DisplayName(val);
4332   }
4333
4334   DOMString GenoPro::Global::Tags::TagData::get_DisplayName_string()
4335   {
4336     return get_sequence()->get_DisplayName_string();
4337   }
4338
4339
4340   void GenoPro::Global::Tags::TagData::mark_present_DisplayName()
4341   {
4342     return get_sequence()->mark_present_DisplayName();
4343   }
4344
4345
4346   /* attribute  functions  */
4347
4348
4349   GenoPro::Global::Tags::TagData::attr_Name_ptr GenoPro::Global::Tags::TagData::create_attr_Name(FsmCbOptions& options)
4350   {
4351     static DOMStringPtr myName = new DOMString("Name");
4352     static DOMStringPtr myNsUri = NULL;
4353
4354     if(_attr_Name) {
4355       return _attr_Name;
4356     }
4357     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
4358     GenoPro::Global::Tags::TagData::attr_Name_p node = XSD::createAttributeTmpl<attr_Name>(t);
4359
4360     if(options.isSampleCreate && (node->stringValue() == "") ) {
4361       node->stringValue(node->sampleValue());
4362     }
4363
4364     _attr_Name = node;
4365
4366     return node;
4367   }
4368
4369
4370     void GenoPro::Global::Tags::TagData::set_attr_Name(DOMString val)
4371     {
4372
4373       attribute_attr_Name()->stringValue(val);
4374     }
4375
4376     DOMString GenoPro::Global::Tags::TagData::get_attr_Name_string()
4377     {
4378
4379       return attribute_attr_Name()->stringValue();
4380     }
4381
4382
4383   GenoPro::Global::Tags::TagData::attr_Name_p GenoPro::Global::Tags::TagData::attribute_attr_Name()
4384   {
4385     FSM::warnNullNode(_attr_Name, "attr_Name", "{http://www.w3.org/2001/XMLSchema}Name", 1);
4386     return _attr_Name;
4387   }
4388
4389   //constructor
4390   GenoPro::Global::Tags::TagData::sequence::sequence(TagData* that):
4391     _that(that)
4392   {
4393     XsdFsmBasePtr fsmArray[] = {
4394     new XsdFSM<DisplayName_ptr>( Particle(new DOMString("libgno"), DOMString("DisplayName"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DisplayName_ptr, TagData, FsmCbOptions>(_that, &TagData::create_DisplayName)),
4395
4396       NULL
4397     } ;
4398
4399     XsdSequenceFsmOfFSMs::init(fsmArray);
4400   }
4401
4402
4403
4404   GenoPro::Global::Tags::TagData::DisplayName_p GenoPro::Global::Tags::TagData::sequence::element_DisplayName()
4405   {
4406       GenoPro::Global::Tags::TagData::DisplayName_p node_p = NULL;
4407     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
4408     if(fsm_p)
4409     {
4410       XsdFSM<DisplayName_ptr> *unitFsm = dynamic_cast<XsdFSM<DisplayName_ptr> *>(fsm_p);
4411       if(unitFsm && unitFsm->nodeList().size()>0) {
4412         assert(unitFsm->nodeList().size()==1);
4413         node_p = unitFsm->nodeList().at(0);
4414       }
4415     }
4416
4417     FSM::warnNullNode(node_p, "DisplayName", "{http://www.w3.org/2001/XMLSchema}DisplayName", 0);
4418     return node_p;
4419
4420   }
4421
4422
4423   void GenoPro::Global::Tags::TagData::sequence::set_DisplayName(DOMString val)
4424   {
4425
4426     mark_present_DisplayName();
4427
4428     element_DisplayName()->stringValue(val);
4429   }
4430
4431   DOMString GenoPro::Global::Tags::TagData::sequence::get_DisplayName_string()
4432   {
4433     return element_DisplayName()->stringValue();
4434   }
4435
4436
4437
4438   void GenoPro::Global::Tags::TagData::sequence::mark_present_DisplayName()
4439   {
4440     DOMStringPtr nsUriPtr = new DOMString("libgno");
4441     XsdEvent event(nsUriPtr, NULL, DOMString("DisplayName"), XsdEvent::ELEMENT_START, false);
4442     this->processEventThrow(event);
4443   }
4444
4445
4446
4447   //constructor
4448
4449   GenoPro::Global::Tags::DialogLayout::DialogLayout(ElementCreateArgs args):
4450       XMLSchema::XmlElement<anyType>(args),
4451
4452     _fsmAttrs(NULL),
4453     _fsmElems(NULL)
4454
4455     , _sequence(new sequence(this) )
4456
4457   {
4458     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
4459     initFSM();
4460     if(args.ownerDoc && args.ownerDoc->buildTree())
4461     {
4462       if(args.ownerDoc->createSample()) {
4463         _fsm->fireSampleEvents();
4464       }
4465       else {
4466         _fsm->fireRequiredEvents();
4467       }
4468     }
4469   }
4470
4471   void GenoPro::Global::Tags::DialogLayout::initFSM()
4472   {
4473     XsdFsmBasePtr fsmsAttrs[] = {
4474   new XsdFSM<attr_Name_ptr>( Particle(NULL, DOMString("Name"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Name_ptr, DialogLayout, FsmCbOptions>(this, &DialogLayout::create_attr_Name)),
4475
4476       NULL
4477     };
4478
4479     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
4480
4481     _fsm->replaceContentFsm(_sequence);
4482
4483     _fsmAttrs = _fsm->attributeFsm();
4484     _fsmElems = _fsm->contentFsm();
4485
4486   }
4487
4488   /* element functions  */
4489
4490
4491   GenoPro::Global::Tags::DialogLayout::Description_ptr GenoPro::Global::Tags::DialogLayout::create_Description(FsmCbOptions& options)
4492   {
4493     static DOMStringPtr myName = new DOMString("Description");
4494     static DOMStringPtr myNsUri = new DOMString("libgno");
4495
4496     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
4497     GenoPro::Global::Tags::DialogLayout::Description_p node = XSD::createElementTmpl<Description, XMLSchema::Types::bt_string*>(t);
4498
4499     if(options.isSampleCreate && (node->stringValue() == "") ) {
4500       node->stringValue(node->sampleValue());
4501     }
4502
4503     _Description = node;
4504
4505     return node;
4506   }
4507
4508
4509   GenoPro::Global::Tags::DialogLayout::Description_p GenoPro::Global::Tags::DialogLayout::element_Description()
4510   {
4511     FSM::warnNullNode(_Description, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
4512     return _Description;
4513   }
4514
4515   void GenoPro::Global::Tags::DialogLayout::set_Description(DOMString val)
4516   {
4517     get_sequence()->set_Description(val);
4518   }
4519
4520   DOMString GenoPro::Global::Tags::DialogLayout::get_Description_string()
4521   {
4522     return get_sequence()->get_Description_string();
4523   }
4524
4525
4526   void GenoPro::Global::Tags::DialogLayout::mark_present_Description()
4527   {
4528     return get_sequence()->mark_present_Description();
4529   }
4530
4531
4532   GenoPro::Global::Tags::DialogLayout::Tags_ptr GenoPro::Global::Tags::DialogLayout::create_Tags(FsmCbOptions& options)
4533   {
4534     static DOMStringPtr myName = new DOMString("Tags");
4535     static DOMStringPtr myNsUri = new DOMString("libgno");
4536
4537     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
4538     GenoPro::Global::Tags::DialogLayout::Tags_p node = XSD::createElementTmpl<Tags, XMLSchema::Types::bt_normalizedString*>(t);
4539
4540     if(options.isSampleCreate && (node->stringValue() == "") ) {
4541       node->stringValue(node->sampleValue());
4542     }
4543
4544     _Tags = node;
4545
4546     return node;
4547   }
4548
4549
4550   GenoPro::Global::Tags::DialogLayout::Tags_p GenoPro::Global::Tags::DialogLayout::element_Tags()
4551   {
4552     FSM::warnNullNode(_Tags, "Tags", "{http://www.w3.org/2001/XMLSchema}Tags", 0);
4553     return _Tags;
4554   }
4555
4556   void GenoPro::Global::Tags::DialogLayout::set_Tags(DOMString val)
4557   {
4558     get_sequence()->set_Tags(val);
4559   }
4560
4561   DOMString GenoPro::Global::Tags::DialogLayout::get_Tags_string()
4562   {
4563     return get_sequence()->get_Tags_string();
4564   }
4565
4566
4567   void GenoPro::Global::Tags::DialogLayout::mark_present_Tags()
4568   {
4569     return get_sequence()->mark_present_Tags();
4570   }
4571
4572
4573   /* attribute  functions  */
4574
4575
4576   GenoPro::Global::Tags::DialogLayout::attr_Name_ptr GenoPro::Global::Tags::DialogLayout::create_attr_Name(FsmCbOptions& options)
4577   {
4578     static DOMStringPtr myName = new DOMString("Name");
4579     static DOMStringPtr myNsUri = NULL;
4580
4581     if(_attr_Name) {
4582       return _attr_Name;
4583     }
4584     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
4585     GenoPro::Global::Tags::DialogLayout::attr_Name_p node = XSD::createAttributeTmpl<attr_Name>(t);
4586
4587     if(options.isSampleCreate && (node->stringValue() == "") ) {
4588       node->stringValue(node->sampleValue());
4589     }
4590
4591     _attr_Name = node;
4592
4593     return node;
4594   }
4595
4596
4597     void GenoPro::Global::Tags::DialogLayout::set_attr_Name(DOMString val)
4598     {
4599
4600       attribute_attr_Name()->stringValue(val);
4601     }
4602
4603     DOMString GenoPro::Global::Tags::DialogLayout::get_attr_Name_string()
4604     {
4605
4606       return attribute_attr_Name()->stringValue();
4607     }
4608
4609
4610   GenoPro::Global::Tags::DialogLayout::attr_Name_p GenoPro::Global::Tags::DialogLayout::attribute_attr_Name()
4611   {
4612     FSM::warnNullNode(_attr_Name, "attr_Name", "{http://www.w3.org/2001/XMLSchema}Name", 1);
4613     return _attr_Name;
4614   }
4615
4616   //constructor
4617   GenoPro::Global::Tags::DialogLayout::sequence::sequence(DialogLayout* that):
4618     _that(that)
4619   {
4620     XsdFsmBasePtr fsmArray[] = {
4621     new XsdFSM<Description_ptr>( Particle(new DOMString("libgno"), DOMString("Description"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Description_ptr, DialogLayout, FsmCbOptions>(_that, &DialogLayout::create_Description)),
4622       new XsdFSM<Tags_ptr>( Particle(new DOMString("libgno"), DOMString("Tags"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Tags_ptr, DialogLayout, FsmCbOptions>(_that, &DialogLayout::create_Tags)),
4623
4624       NULL
4625     } ;
4626
4627     XsdSequenceFsmOfFSMs::init(fsmArray);
4628   }
4629
4630
4631
4632   GenoPro::Global::Tags::DialogLayout::Description_p GenoPro::Global::Tags::DialogLayout::sequence::element_Description()
4633   {
4634       GenoPro::Global::Tags::DialogLayout::Description_p node_p = NULL;
4635     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
4636     if(fsm_p)
4637     {
4638       XsdFSM<Description_ptr> *unitFsm = dynamic_cast<XsdFSM<Description_ptr> *>(fsm_p);
4639       if(unitFsm && unitFsm->nodeList().size()>0) {
4640         assert(unitFsm->nodeList().size()==1);
4641         node_p = unitFsm->nodeList().at(0);
4642       }
4643     }
4644
4645     FSM::warnNullNode(node_p, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
4646     return node_p;
4647
4648   }
4649
4650
4651   void GenoPro::Global::Tags::DialogLayout::sequence::set_Description(DOMString val)
4652   {
4653
4654     mark_present_Description();
4655
4656     element_Description()->stringValue(val);
4657   }
4658
4659   DOMString GenoPro::Global::Tags::DialogLayout::sequence::get_Description_string()
4660   {
4661     return element_Description()->stringValue();
4662   }
4663
4664
4665
4666   void GenoPro::Global::Tags::DialogLayout::sequence::mark_present_Description()
4667   {
4668     DOMStringPtr nsUriPtr = new DOMString("libgno");
4669     XsdEvent event(nsUriPtr, NULL, DOMString("Description"), XsdEvent::ELEMENT_START, false);
4670     this->processEventThrow(event);
4671   }
4672
4673
4674
4675   GenoPro::Global::Tags::DialogLayout::Tags_p GenoPro::Global::Tags::DialogLayout::sequence::element_Tags()
4676   {
4677       GenoPro::Global::Tags::DialogLayout::Tags_p node_p = NULL;
4678     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
4679     if(fsm_p)
4680     {
4681       XsdFSM<Tags_ptr> *unitFsm = dynamic_cast<XsdFSM<Tags_ptr> *>(fsm_p);
4682       if(unitFsm && unitFsm->nodeList().size()>0) {
4683         assert(unitFsm->nodeList().size()==1);
4684         node_p = unitFsm->nodeList().at(0);
4685       }
4686     }
4687
4688     FSM::warnNullNode(node_p, "Tags", "{http://www.w3.org/2001/XMLSchema}Tags", 0);
4689     return node_p;
4690
4691   }
4692
4693
4694   void GenoPro::Global::Tags::DialogLayout::sequence::set_Tags(DOMString val)
4695   {
4696
4697     mark_present_Tags();
4698
4699     element_Tags()->stringValue(val);
4700   }
4701
4702   DOMString GenoPro::Global::Tags::DialogLayout::sequence::get_Tags_string()
4703   {
4704     return element_Tags()->stringValue();
4705   }
4706
4707
4708
4709   void GenoPro::Global::Tags::DialogLayout::sequence::mark_present_Tags()
4710   {
4711     DOMStringPtr nsUriPtr = new DOMString("libgno");
4712     XsdEvent event(nsUriPtr, NULL, DOMString("Tags"), XsdEvent::ELEMENT_START, false);
4713     this->processEventThrow(event);
4714   }
4715
4716
4717
4718   //constructor
4719
4720   GenoPro::Global::Document::Document(ElementCreateArgs args):
4721       XMLSchema::XmlElement<anyType>(args),
4722
4723     _fsmAttrs(NULL),
4724     _fsmElems(NULL)
4725
4726     , _sequence(new sequence(this) )
4727
4728   {
4729     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
4730     initFSM();
4731     if(args.ownerDoc && args.ownerDoc->buildTree())
4732     {
4733       if(args.ownerDoc->createSample()) {
4734         _fsm->fireSampleEvents();
4735       }
4736       else {
4737         _fsm->fireRequiredEvents();
4738       }
4739     }
4740   }
4741
4742   void GenoPro::Global::Document::initFSM()
4743   {
4744     XsdFsmBasePtr fsmsAttrs[] = {
4745
4746       NULL
4747     };
4748
4749     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
4750
4751     _fsm->replaceContentFsm(_sequence);
4752
4753     _fsmAttrs = _fsm->attributeFsm();
4754     _fsmElems = _fsm->contentFsm();
4755
4756   }
4757
4758   /* element functions  */
4759
4760
4761   GenoPro::Global::Document::Title_ptr GenoPro::Global::Document::create_Title(FsmCbOptions& options)
4762   {
4763     static DOMStringPtr myName = new DOMString("Title");
4764     static DOMStringPtr myNsUri = new DOMString("libgno");
4765
4766     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
4767     GenoPro::Global::Document::Title_p node = XSD::createElementTmpl<Title, XMLSchema::Types::bt_string*>(t);
4768
4769     if(options.isSampleCreate && (node->stringValue() == "") ) {
4770       node->stringValue(node->sampleValue());
4771     }
4772
4773     _Title = node;
4774
4775     return node;
4776   }
4777
4778
4779   GenoPro::Global::Document::Title_p GenoPro::Global::Document::element_Title()
4780   {
4781     FSM::warnNullNode(_Title, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
4782     return _Title;
4783   }
4784
4785   void GenoPro::Global::Document::set_Title(DOMString val)
4786   {
4787     get_sequence()->set_Title(val);
4788   }
4789
4790   DOMString GenoPro::Global::Document::get_Title_string()
4791   {
4792     return get_sequence()->get_Title_string();
4793   }
4794
4795
4796   void GenoPro::Global::Document::mark_present_Title()
4797   {
4798     return get_sequence()->mark_present_Title();
4799   }
4800
4801
4802   GenoPro::Global::Document::Description_ptr GenoPro::Global::Document::create_Description(FsmCbOptions& options)
4803   {
4804     static DOMStringPtr myName = new DOMString("Description");
4805     static DOMStringPtr myNsUri = new DOMString("libgno");
4806
4807     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
4808     GenoPro::Global::Document::Description_p node = XSD::createElementTmpl<Description, XMLSchema::Types::bt_string*>(t);
4809
4810     if(options.isSampleCreate && (node->stringValue() == "") ) {
4811       node->stringValue(node->sampleValue());
4812     }
4813
4814     _Description = node;
4815
4816     return node;
4817   }
4818
4819
4820   GenoPro::Global::Document::Description_p GenoPro::Global::Document::element_Description()
4821   {
4822     FSM::warnNullNode(_Description, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
4823     return _Description;
4824   }
4825
4826   void GenoPro::Global::Document::set_Description(DOMString val)
4827   {
4828     get_sequence()->set_Description(val);
4829   }
4830
4831   DOMString GenoPro::Global::Document::get_Description_string()
4832   {
4833     return get_sequence()->get_Description_string();
4834   }
4835
4836
4837   void GenoPro::Global::Document::mark_present_Description()
4838   {
4839     return get_sequence()->mark_present_Description();
4840   }
4841
4842
4843   GenoPro::Global::Document::Comment_ptr GenoPro::Global::Document::create_Comment(FsmCbOptions& options)
4844   {
4845     static DOMStringPtr myName = new DOMString("Comment");
4846     static DOMStringPtr myNsUri = new DOMString("libgno");
4847
4848     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
4849     GenoPro::Global::Document::Comment_p node = XSD::createElementTmpl<Comment, XMLSchema::Types::bt_string*>(t);
4850
4851     if(options.isSampleCreate && (node->stringValue() == "") ) {
4852       node->stringValue(node->sampleValue());
4853     }
4854
4855     _Comment = node;
4856
4857     return node;
4858   }
4859
4860
4861   GenoPro::Global::Document::Comment_p GenoPro::Global::Document::element_Comment()
4862   {
4863     FSM::warnNullNode(_Comment, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
4864     return _Comment;
4865   }
4866
4867   void GenoPro::Global::Document::set_Comment(DOMString val)
4868   {
4869     get_sequence()->set_Comment(val);
4870   }
4871
4872   DOMString GenoPro::Global::Document::get_Comment_string()
4873   {
4874     return get_sequence()->get_Comment_string();
4875   }
4876
4877
4878   void GenoPro::Global::Document::mark_present_Comment()
4879   {
4880     return get_sequence()->mark_present_Comment();
4881   }
4882
4883
4884   /* attribute  functions  */
4885
4886   //constructor
4887   GenoPro::Global::Document::sequence::sequence(Document* that):
4888     _that(that)
4889   {
4890     XsdFsmBasePtr fsmArray[] = {
4891     new XsdFSM<Title_ptr>( Particle(new DOMString("libgno"), DOMString("Title"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Title_ptr, Document, FsmCbOptions>(_that, &Document::create_Title)),
4892       new XsdFSM<Description_ptr>( Particle(new DOMString("libgno"), DOMString("Description"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Description_ptr, Document, FsmCbOptions>(_that, &Document::create_Description)),
4893       new XsdFSM<Comment_ptr>( Particle(new DOMString("libgno"), DOMString("Comment"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Comment_ptr, Document, FsmCbOptions>(_that, &Document::create_Comment)),
4894
4895       NULL
4896     } ;
4897
4898     XsdSequenceFsmOfFSMs::init(fsmArray);
4899   }
4900
4901
4902
4903   GenoPro::Global::Document::Title_p GenoPro::Global::Document::sequence::element_Title()
4904   {
4905       GenoPro::Global::Document::Title_p node_p = NULL;
4906     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
4907     if(fsm_p)
4908     {
4909       XsdFSM<Title_ptr> *unitFsm = dynamic_cast<XsdFSM<Title_ptr> *>(fsm_p);
4910       if(unitFsm && unitFsm->nodeList().size()>0) {
4911         assert(unitFsm->nodeList().size()==1);
4912         node_p = unitFsm->nodeList().at(0);
4913       }
4914     }
4915
4916     FSM::warnNullNode(node_p, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
4917     return node_p;
4918
4919   }
4920
4921
4922   void GenoPro::Global::Document::sequence::set_Title(DOMString val)
4923   {
4924
4925     mark_present_Title();
4926
4927     element_Title()->stringValue(val);
4928   }
4929
4930   DOMString GenoPro::Global::Document::sequence::get_Title_string()
4931   {
4932     return element_Title()->stringValue();
4933   }
4934
4935
4936
4937   void GenoPro::Global::Document::sequence::mark_present_Title()
4938   {
4939     DOMStringPtr nsUriPtr = new DOMString("libgno");
4940     XsdEvent event(nsUriPtr, NULL, DOMString("Title"), XsdEvent::ELEMENT_START, false);
4941     this->processEventThrow(event);
4942   }
4943
4944
4945
4946   GenoPro::Global::Document::Description_p GenoPro::Global::Document::sequence::element_Description()
4947   {
4948       GenoPro::Global::Document::Description_p node_p = NULL;
4949     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
4950     if(fsm_p)
4951     {
4952       XsdFSM<Description_ptr> *unitFsm = dynamic_cast<XsdFSM<Description_ptr> *>(fsm_p);
4953       if(unitFsm && unitFsm->nodeList().size()>0) {
4954         assert(unitFsm->nodeList().size()==1);
4955         node_p = unitFsm->nodeList().at(0);
4956       }
4957     }
4958
4959     FSM::warnNullNode(node_p, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
4960     return node_p;
4961
4962   }
4963
4964
4965   void GenoPro::Global::Document::sequence::set_Description(DOMString val)
4966   {
4967
4968     mark_present_Description();
4969
4970     element_Description()->stringValue(val);
4971   }
4972
4973   DOMString GenoPro::Global::Document::sequence::get_Description_string()
4974   {
4975     return element_Description()->stringValue();
4976   }
4977
4978
4979
4980   void GenoPro::Global::Document::sequence::mark_present_Description()
4981   {
4982     DOMStringPtr nsUriPtr = new DOMString("libgno");
4983     XsdEvent event(nsUriPtr, NULL, DOMString("Description"), XsdEvent::ELEMENT_START, false);
4984     this->processEventThrow(event);
4985   }
4986
4987
4988
4989   GenoPro::Global::Document::Comment_p GenoPro::Global::Document::sequence::element_Comment()
4990   {
4991       GenoPro::Global::Document::Comment_p node_p = NULL;
4992     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
4993     if(fsm_p)
4994     {
4995       XsdFSM<Comment_ptr> *unitFsm = dynamic_cast<XsdFSM<Comment_ptr> *>(fsm_p);
4996       if(unitFsm && unitFsm->nodeList().size()>0) {
4997         assert(unitFsm->nodeList().size()==1);
4998         node_p = unitFsm->nodeList().at(0);
4999       }
5000     }
5001
5002     FSM::warnNullNode(node_p, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
5003     return node_p;
5004
5005   }
5006
5007
5008   void GenoPro::Global::Document::sequence::set_Comment(DOMString val)
5009   {
5010
5011     mark_present_Comment();
5012
5013     element_Comment()->stringValue(val);
5014   }
5015
5016   DOMString GenoPro::Global::Document::sequence::get_Comment_string()
5017   {
5018     return element_Comment()->stringValue();
5019   }
5020
5021
5022
5023   void GenoPro::Global::Document::sequence::mark_present_Comment()
5024   {
5025     DOMStringPtr nsUriPtr = new DOMString("libgno");
5026     XsdEvent event(nsUriPtr, NULL, DOMString("Comment"), XsdEvent::ELEMENT_START, false);
5027     this->processEventThrow(event);
5028   }
5029
5030
5031   //constructor
5032
5033   GenoPro::Global::Options::Options(ElementCreateArgs args):
5034       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
5035
5036     _fsmAttrs(NULL),
5037     _fsmElems(NULL)
5038   {
5039
5040
5041     initFSM();
5042
5043
5044     if(args.ownerDoc && args.ownerDoc->buildTree())
5045
5046     {
5047       if(args.ownerDoc->createSample()) {
5048         _fsm->fireSampleEvents();
5049       }
5050       else {
5051         _fsm->fireRequiredEvents();
5052       }
5053     }
5054   }
5055
5056   void GenoPro::Global::Options::initFSM()
5057   {
5058     XsdFsmBasePtr fsmsAttrs[] = {
5059     new XsdFSM<attr_HideEmotionalRelationships_ptr>( Particle(NULL, DOMString("HideEmotionalRelationships"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_HideEmotionalRelationships_ptr, Options, FsmCbOptions>(this, &Options::create_attr_HideEmotionalRelationships)),
5060
5061       NULL
5062     };
5063
5064     _fsm->appendAttributeFsms(fsmsAttrs);
5065     _fsmAttrs = _fsm->attributeFsm();
5066     _fsmElems = _fsm->contentFsm();
5067
5068    }
5069
5070   /* element functions  */
5071
5072
5073   /* attribute  functions  */
5074
5075
5076   GenoPro::Global::Options::attr_HideEmotionalRelationships_ptr GenoPro::Global::Options::create_attr_HideEmotionalRelationships(FsmCbOptions& options)
5077   {
5078     static DOMStringPtr myName = new DOMString("HideEmotionalRelationships");
5079     static DOMStringPtr myNsUri = NULL;
5080
5081     if(_attr_HideEmotionalRelationships) {
5082       return _attr_HideEmotionalRelationships;
5083     }
5084     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5085     GenoPro::Global::Options::attr_HideEmotionalRelationships_p node = XSD::createAttributeTmpl<attr_HideEmotionalRelationships>(t);
5086
5087     if(options.isSampleCreate && (node->stringValue() == "") ) {
5088       node->stringValue(node->sampleValue());
5089     }
5090
5091     _attr_HideEmotionalRelationships = node;
5092
5093     return node;
5094   }
5095
5096
5097     void GenoPro::Global::Options::set_attr_HideEmotionalRelationships(DOMString val)
5098     {
5099
5100       attribute_attr_HideEmotionalRelationships()->stringValue(val);
5101     }
5102
5103     DOMString GenoPro::Global::Options::get_attr_HideEmotionalRelationships_string()
5104     {
5105
5106       return attribute_attr_HideEmotionalRelationships()->stringValue();
5107     }
5108
5109
5110   GenoPro::Global::Options::attr_HideEmotionalRelationships_p GenoPro::Global::Options::attribute_attr_HideEmotionalRelationships()
5111   {
5112     FSM::warnNullNode(_attr_HideEmotionalRelationships, "attr_HideEmotionalRelationships", "{http://www.w3.org/2001/XMLSchema}HideEmotionalRelationships", 1);
5113     return _attr_HideEmotionalRelationships;
5114   }
5115
5116
5117   //constructor
5118
5119   GenoPro::GenoMaps::GenoMaps(ElementCreateArgs args):
5120       XMLSchema::XmlElement<anyType>(args),
5121
5122     _fsmAttrs(NULL),
5123     _fsmElems(NULL)
5124
5125     , _sequence(new sequence(this) )
5126
5127   {
5128     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
5129     initFSM();
5130     if(args.ownerDoc && args.ownerDoc->buildTree())
5131     {
5132       if(args.ownerDoc->createSample()) {
5133         _fsm->fireSampleEvents();
5134       }
5135       else {
5136         _fsm->fireRequiredEvents();
5137       }
5138     }
5139   }
5140
5141   void GenoPro::GenoMaps::initFSM()
5142   {
5143     XsdFsmBasePtr fsmsAttrs[] = {
5144
5145       NULL
5146     };
5147
5148     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
5149
5150     _fsm->replaceContentFsm(_sequence);
5151
5152     _fsmAttrs = _fsm->attributeFsm();
5153     _fsmElems = _fsm->contentFsm();
5154
5155   }
5156
5157   /* element functions  */
5158
5159
5160   GenoPro::GenoMaps::GenoMap_ptr GenoPro::GenoMaps::create_GenoMap(FsmCbOptions& options)
5161   {
5162     static DOMStringPtr myName = new DOMString("GenoMap");
5163     static DOMStringPtr myNsUri = new DOMString("libgno");
5164
5165     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
5166     GenoPro::GenoMaps::GenoMap_p node = XSD::createElementTmpl<GenoMap, void*>(t);
5167
5168     _list_GenoMap.push_back(node);
5169
5170     return node;
5171   }
5172
5173
5174   GenoPro::GenoMaps::GenoMap_p GenoPro::GenoMaps::element_GenoMap_at(unsigned int idx)
5175   {
5176     if(idx > _list_GenoMap.size()-1) {
5177       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
5178     }
5179
5180     return _list_GenoMap.at(idx);
5181   }
5182
5183   List<GenoPro::GenoMaps::GenoMap_ptr> GenoPro::GenoMaps::elements_GenoMap()
5184   {
5185     return _list_GenoMap;
5186   }
5187
5188   GenoPro::GenoMaps::GenoMap_p GenoPro::GenoMaps::add_node_GenoMap()
5189   {
5190     return get_sequence()->add_node_GenoMap();
5191   }
5192
5193   List<GenoPro::GenoMaps::GenoMap_ptr> GenoPro::GenoMaps::set_count_GenoMap(unsigned int size)
5194   {
5195     return get_sequence()->set_count_GenoMap(size);
5196   }
5197
5198
5199
5200   /* attribute  functions  */
5201
5202   //constructor
5203   GenoPro::GenoMaps::sequence::sequence(GenoMaps* that):
5204     _that(that)
5205   {
5206     XsdFsmBasePtr fsmArray[] = {
5207     new XsdFSM<GenoMap_ptr>( Particle(new DOMString("libgno"), DOMString("GenoMap"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<GenoMap_ptr, GenoMaps, FsmCbOptions>(_that, &GenoMaps::create_GenoMap)),
5208
5209       NULL
5210     } ;
5211
5212     XsdSequenceFsmOfFSMs::init(fsmArray);
5213   }
5214
5215
5216
5217   List<GenoPro::GenoMaps::GenoMap_ptr> GenoPro::GenoMaps::sequence::elements_GenoMap()
5218   {
5219
5220     List<GenoMap_ptr> nodeList;
5221     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
5222     if(fsm_p)
5223     {
5224       XsdFSM<GenoMap_ptr> *unitFsm = dynamic_cast<XsdFSM<GenoMap_ptr> *>(fsm_p);
5225       if(unitFsm) {
5226         //nodeList = unitFsm->nodeList().stl_list();
5227         nodeList = unitFsm->nodeList();
5228       }
5229     }
5230     return nodeList;
5231
5232   }
5233
5234
5235   GenoPro::GenoMaps::GenoMap_p GenoPro::GenoMaps::sequence::element_GenoMap_at(unsigned int idx)
5236   {
5237     return elements_GenoMap().at(idx);
5238   }
5239
5240
5241   GenoPro::GenoMaps::GenoMap_p GenoPro::GenoMaps::sequence::add_node_GenoMap()
5242   {
5243     DOMStringPtr nsUriPtr = new DOMString("libgno");
5244     XsdEvent event(nsUriPtr, NULL, DOMString("GenoMap"), XsdEvent::ELEMENT_START, false);
5245     this->processEventThrow(event);
5246     return elements_GenoMap().back();
5247   }
5248
5249   List<GenoPro::GenoMaps::GenoMap_ptr> GenoPro::GenoMaps::sequence::set_count_GenoMap(unsigned int size)
5250   {
5251     if( (size > -1) || (size < 1)) {
5252       ostringstream oss;
5253       oss << "set_count_GenoMap: size should be in range: [" << 1
5254         << "," << "unbounded" << "]";
5255       throw IndexOutOfBoundsException(oss.str());
5256     }
5257
5258     unsigned int prevSize = elements_GenoMap().size();
5259     if(size < prevSize) {
5260       //FIXME: allow later:
5261       throw XPlus::RuntimeException("resize lesser than current size not allowed");
5262     }
5263
5264     for(unsigned int j=prevSize; j<size; j++)
5265     {
5266       // pretend docBuilding to avoid computation of adding after first loop
5267       XsdEvent event(new DOMString("libgno"), NULL, DOMString("GenoMap"), XsdEvent::ELEMENT_START, false);
5268       this->processEventThrow(event);
5269     }
5270
5271     return elements_GenoMap();
5272   }
5273
5274
5275
5276   //constructor
5277
5278   GenoPro::GenoMaps::GenoMap::GenoMap(ElementCreateArgs args):
5279       XMLSchema::XmlElement<anyType>(args),
5280
5281     _fsmAttrs(NULL),
5282     _fsmElems(NULL)
5283
5284     , _sequence(new sequence(this) )
5285
5286   {
5287     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
5288     initFSM();
5289     if(args.ownerDoc && args.ownerDoc->buildTree())
5290     {
5291       if(args.ownerDoc->createSample()) {
5292         _fsm->fireSampleEvents();
5293       }
5294       else {
5295         _fsm->fireRequiredEvents();
5296       }
5297     }
5298   }
5299
5300   void GenoPro::GenoMaps::GenoMap::initFSM()
5301   {
5302     XsdFsmBasePtr fsmsAttrs[] = {
5303   new XsdFSM<attr_Name_ptr>( Particle(NULL, DOMString("Name"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Name_ptr, GenoMap, FsmCbOptions>(this, &GenoMap::create_attr_Name)),
5304   new XsdFSM<attr_Zoom_ptr>( Particle(NULL, DOMString("Zoom"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Zoom_ptr, GenoMap, FsmCbOptions>(this, &GenoMap::create_attr_Zoom)),
5305   new XsdFSM<attr_Position_ptr>( Particle(NULL, DOMString("Position"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Position_ptr, GenoMap, FsmCbOptions>(this, &GenoMap::create_attr_Position)),
5306   new XsdFSM<attr_BoundaryRect_ptr>( Particle(NULL, DOMString("BoundaryRect"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_BoundaryRect_ptr, GenoMap, FsmCbOptions>(this, &GenoMap::create_attr_BoundaryRect)),
5307
5308       NULL
5309     };
5310
5311     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
5312
5313     _fsm->replaceContentFsm(_sequence);
5314
5315     _fsmAttrs = _fsm->attributeFsm();
5316     _fsmElems = _fsm->contentFsm();
5317
5318   }
5319
5320   /* element functions  */
5321
5322
5323   GenoPro::GenoMaps::GenoMap::Print_ptr GenoPro::GenoMaps::GenoMap::create_Print(FsmCbOptions& options)
5324   {
5325     static DOMStringPtr myName = new DOMString("Print");
5326     static DOMStringPtr myNsUri = new DOMString("libgno");
5327
5328     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
5329     GenoPro::GenoMaps::GenoMap::Print_p node = XSD::createElementTmpl<Print, void*>(t);
5330
5331     if(options.isSampleCreate && (node->stringValue() == "") ) {
5332       node->stringValue(node->sampleValue());
5333     }
5334
5335     _Print = node;
5336
5337     return node;
5338   }
5339
5340
5341   GenoPro::GenoMaps::GenoMap::Print_p GenoPro::GenoMaps::GenoMap::element_Print()
5342   {
5343     FSM::warnNullNode(_Print, "Print", "{}Print", 0);
5344     return _Print;
5345   }
5346
5347   void GenoPro::GenoMaps::GenoMap::mark_present_Print()
5348   {
5349     return get_sequence()->mark_present_Print();
5350   }
5351
5352
5353   /* attribute  functions  */
5354
5355
5356   GenoPro::GenoMaps::GenoMap::attr_Name_ptr GenoPro::GenoMaps::GenoMap::create_attr_Name(FsmCbOptions& options)
5357   {
5358     static DOMStringPtr myName = new DOMString("Name");
5359     static DOMStringPtr myNsUri = NULL;
5360
5361     if(_attr_Name) {
5362       return _attr_Name;
5363     }
5364     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5365     GenoPro::GenoMaps::GenoMap::attr_Name_p node = XSD::createAttributeTmpl<attr_Name>(t);
5366
5367     if(options.isSampleCreate && (node->stringValue() == "") ) {
5368       node->stringValue(node->sampleValue());
5369     }
5370
5371     _attr_Name = node;
5372
5373     return node;
5374   }
5375
5376
5377     void GenoPro::GenoMaps::GenoMap::set_attr_Name(DOMString val)
5378     {
5379
5380       attribute_attr_Name()->stringValue(val);
5381     }
5382
5383     DOMString GenoPro::GenoMaps::GenoMap::get_attr_Name_string()
5384     {
5385
5386       return attribute_attr_Name()->stringValue();
5387     }
5388
5389
5390   GenoPro::GenoMaps::GenoMap::attr_Name_p GenoPro::GenoMaps::GenoMap::attribute_attr_Name()
5391   {
5392     FSM::warnNullNode(_attr_Name, "attr_Name", "{http://www.w3.org/2001/XMLSchema}Name", 1);
5393     return _attr_Name;
5394   }
5395
5396
5397   GenoPro::GenoMaps::GenoMap::attr_Zoom_ptr GenoPro::GenoMaps::GenoMap::create_attr_Zoom(FsmCbOptions& options)
5398   {
5399     static DOMStringPtr myName = new DOMString("Zoom");
5400     static DOMStringPtr myNsUri = NULL;
5401
5402     if(_attr_Zoom) {
5403       return _attr_Zoom;
5404     }
5405     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5406     GenoPro::GenoMaps::GenoMap::attr_Zoom_p node = XSD::createAttributeTmpl<attr_Zoom>(t);
5407
5408     if(options.isSampleCreate && (node->stringValue() == "") ) {
5409       node->stringValue(node->sampleValue());
5410     }
5411
5412     _attr_Zoom = node;
5413
5414     return node;
5415   }
5416
5417
5418     void GenoPro::GenoMaps::GenoMap::set_attr_Zoom(DOMString val)
5419     {
5420
5421       attribute_attr_Zoom()->stringValue(val);
5422     }
5423
5424     DOMString GenoPro::GenoMaps::GenoMap::get_attr_Zoom_string()
5425     {
5426
5427       return attribute_attr_Zoom()->stringValue();
5428     }
5429
5430
5431     void GenoPro::GenoMaps::GenoMap::set_attr_Zoom(int val)
5432     {
5433
5434       attribute_attr_Zoom()->value(val);
5435     }
5436
5437     int GenoPro::GenoMaps::GenoMap::get_attr_Zoom()
5438     {
5439
5440       return attribute_attr_Zoom()->value();
5441     }
5442
5443
5444   GenoPro::GenoMaps::GenoMap::attr_Zoom_p GenoPro::GenoMaps::GenoMap::attribute_attr_Zoom()
5445   {
5446     FSM::warnNullNode(_attr_Zoom, "attr_Zoom", "{http://www.w3.org/2001/XMLSchema}Zoom", 1);
5447     return _attr_Zoom;
5448   }
5449
5450
5451   GenoPro::GenoMaps::GenoMap::attr_Position_ptr GenoPro::GenoMaps::GenoMap::create_attr_Position(FsmCbOptions& options)
5452   {
5453     static DOMStringPtr myName = new DOMString("Position");
5454     static DOMStringPtr myNsUri = NULL;
5455
5456     if(_attr_Position) {
5457       return _attr_Position;
5458     }
5459     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5460     GenoPro::GenoMaps::GenoMap::attr_Position_p node = XSD::createAttributeTmpl<attr_Position>(t);
5461
5462     if(options.isSampleCreate && (node->stringValue() == "") ) {
5463       node->stringValue(node->sampleValue());
5464     }
5465
5466     _attr_Position = node;
5467
5468     return node;
5469   }
5470
5471
5472     void GenoPro::GenoMaps::GenoMap::set_attr_Position(DOMString val)
5473     {
5474
5475       attribute_attr_Position()->stringValue(val);
5476     }
5477
5478     DOMString GenoPro::GenoMaps::GenoMap::get_attr_Position_string()
5479     {
5480
5481       return attribute_attr_Position()->stringValue();
5482     }
5483
5484
5485   GenoPro::GenoMaps::GenoMap::attr_Position_p GenoPro::GenoMaps::GenoMap::attribute_attr_Position()
5486   {
5487     FSM::warnNullNode(_attr_Position, "attr_Position", "{http://www.w3.org/2001/XMLSchema}Position", 1);
5488     return _attr_Position;
5489   }
5490
5491
5492   GenoPro::GenoMaps::GenoMap::attr_BoundaryRect_ptr GenoPro::GenoMaps::GenoMap::create_attr_BoundaryRect(FsmCbOptions& options)
5493   {
5494     static DOMStringPtr myName = new DOMString("BoundaryRect");
5495     static DOMStringPtr myNsUri = NULL;
5496
5497     if(_attr_BoundaryRect) {
5498       return _attr_BoundaryRect;
5499     }
5500     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5501     GenoPro::GenoMaps::GenoMap::attr_BoundaryRect_p node = XSD::createAttributeTmpl<attr_BoundaryRect>(t);
5502
5503     if(options.isSampleCreate && (node->stringValue() == "") ) {
5504       node->stringValue(node->sampleValue());
5505     }
5506
5507     _attr_BoundaryRect = node;
5508
5509     return node;
5510   }
5511
5512
5513     void GenoPro::GenoMaps::GenoMap::set_attr_BoundaryRect(DOMString val)
5514     {
5515
5516       attribute_attr_BoundaryRect()->stringValue(val);
5517     }
5518
5519     DOMString GenoPro::GenoMaps::GenoMap::get_attr_BoundaryRect_string()
5520     {
5521
5522       return attribute_attr_BoundaryRect()->stringValue();
5523     }
5524
5525
5526   GenoPro::GenoMaps::GenoMap::attr_BoundaryRect_p GenoPro::GenoMaps::GenoMap::attribute_attr_BoundaryRect()
5527   {
5528     FSM::warnNullNode(_attr_BoundaryRect, "attr_BoundaryRect", "{http://www.w3.org/2001/XMLSchema}BoundaryRect", 1);
5529     return _attr_BoundaryRect;
5530   }
5531
5532   //constructor
5533   GenoPro::GenoMaps::GenoMap::sequence::sequence(GenoMap* that):
5534     _that(that)
5535   {
5536     XsdFsmBasePtr fsmArray[] = {
5537     new XsdFSM<Print_ptr>( Particle(new DOMString("libgno"), DOMString("Print"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Print_ptr, GenoMap, FsmCbOptions>(_that, &GenoMap::create_Print)),
5538
5539       NULL
5540     } ;
5541
5542     XsdSequenceFsmOfFSMs::init(fsmArray);
5543   }
5544
5545
5546
5547   GenoPro::GenoMaps::GenoMap::Print_p GenoPro::GenoMaps::GenoMap::sequence::element_Print()
5548   {
5549       GenoPro::GenoMaps::GenoMap::Print_p node_p = NULL;
5550     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
5551     if(fsm_p)
5552     {
5553       XsdFSM<Print_ptr> *unitFsm = dynamic_cast<XsdFSM<Print_ptr> *>(fsm_p);
5554       if(unitFsm && unitFsm->nodeList().size()>0) {
5555         assert(unitFsm->nodeList().size()==1);
5556         node_p = unitFsm->nodeList().at(0);
5557       }
5558     }
5559
5560     FSM::warnNullNode(node_p, "Print", "{}Print", 0);
5561     return node_p;
5562
5563   }
5564
5565
5566
5567   void GenoPro::GenoMaps::GenoMap::sequence::mark_present_Print()
5568   {
5569     DOMStringPtr nsUriPtr = new DOMString("libgno");
5570     XsdEvent event(nsUriPtr, NULL, DOMString("Print"), XsdEvent::ELEMENT_START, false);
5571     this->processEventThrow(event);
5572   }
5573
5574
5575   //constructor
5576
5577   GenoPro::GenoMaps::GenoMap::Print::Print(ElementCreateArgs args):
5578       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
5579
5580     _fsmAttrs(NULL),
5581     _fsmElems(NULL)
5582   {
5583
5584
5585     initFSM();
5586
5587
5588     if(args.ownerDoc && args.ownerDoc->buildTree())
5589
5590     {
5591       if(args.ownerDoc->createSample()) {
5592         _fsm->fireSampleEvents();
5593       }
5594       else {
5595         _fsm->fireRequiredEvents();
5596       }
5597     }
5598   }
5599
5600   void GenoPro::GenoMaps::GenoMap::Print::initFSM()
5601   {
5602     XsdFsmBasePtr fsmsAttrs[] = {
5603     new XsdFSM<attr_Landscape_ptr>( Particle(NULL, DOMString("Landscape"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Landscape_ptr, Print, FsmCbOptions>(this, &Print::create_attr_Landscape)),
5604
5605       NULL
5606     };
5607
5608     _fsm->appendAttributeFsms(fsmsAttrs);
5609     _fsmAttrs = _fsm->attributeFsm();
5610     _fsmElems = _fsm->contentFsm();
5611
5612    }
5613
5614   /* element functions  */
5615
5616
5617   /* attribute  functions  */
5618
5619
5620   GenoPro::GenoMaps::GenoMap::Print::attr_Landscape_ptr GenoPro::GenoMaps::GenoMap::Print::create_attr_Landscape(FsmCbOptions& options)
5621   {
5622     static DOMStringPtr myName = new DOMString("Landscape");
5623     static DOMStringPtr myNsUri = NULL;
5624
5625     if(_attr_Landscape) {
5626       return _attr_Landscape;
5627     }
5628     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
5629     GenoPro::GenoMaps::GenoMap::Print::attr_Landscape_p node = XSD::createAttributeTmpl<attr_Landscape>(t);
5630
5631     if(options.isSampleCreate && (node->stringValue() == "") ) {
5632       node->stringValue(node->sampleValue());
5633     }
5634
5635     _attr_Landscape = node;
5636
5637     return node;
5638   }
5639
5640
5641     void GenoPro::GenoMaps::GenoMap::Print::set_attr_Landscape(DOMString val)
5642     {
5643
5644       attribute_attr_Landscape()->stringValue(val);
5645     }
5646
5647     DOMString GenoPro::GenoMaps::GenoMap::Print::get_attr_Landscape_string()
5648     {
5649
5650       return attribute_attr_Landscape()->stringValue();
5651     }
5652
5653
5654   GenoPro::GenoMaps::GenoMap::Print::attr_Landscape_p GenoPro::GenoMaps::GenoMap::Print::attribute_attr_Landscape()
5655   {
5656     FSM::warnNullNode(_attr_Landscape, "attr_Landscape", "{http://www.w3.org/2001/XMLSchema}Landscape", 1);
5657     return _attr_Landscape;
5658   }
5659
5660
5661   //constructor
5662
5663   GenoPro::Individuals::Individuals(ElementCreateArgs args):
5664       XMLSchema::XmlElement<anyType>(args),
5665
5666     _fsmAttrs(NULL),
5667     _fsmElems(NULL)
5668
5669     , _sequence(new sequence(this) )
5670
5671   {
5672     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
5673     initFSM();
5674     if(args.ownerDoc && args.ownerDoc->buildTree())
5675     {
5676       if(args.ownerDoc->createSample()) {
5677         _fsm->fireSampleEvents();
5678       }
5679       else {
5680         _fsm->fireRequiredEvents();
5681       }
5682     }
5683   }
5684
5685   void GenoPro::Individuals::initFSM()
5686   {
5687     XsdFsmBasePtr fsmsAttrs[] = {
5688
5689       NULL
5690     };
5691
5692     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
5693
5694     _fsm->replaceContentFsm(_sequence);
5695
5696     _fsmAttrs = _fsm->attributeFsm();
5697     _fsmElems = _fsm->contentFsm();
5698
5699   }
5700
5701   /* element functions  */
5702
5703
5704   GenoPro::Individuals::Individual_ptr GenoPro::Individuals::create_Individual(FsmCbOptions& options)
5705   {
5706     static DOMStringPtr myName = new DOMString("Individual");
5707     static DOMStringPtr myNsUri = new DOMString("libgno");
5708
5709     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
5710     GenoPro::Individuals::Individual_p node = XSD::createElementTmpl<Individual, void*>(t);
5711
5712     _list_Individual.push_back(node);
5713
5714     return node;
5715   }
5716
5717
5718   GenoPro::Individuals::Individual_p GenoPro::Individuals::element_Individual_at(unsigned int idx)
5719   {
5720     if(idx > _list_Individual.size()-1) {
5721       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
5722     }
5723
5724     return _list_Individual.at(idx);
5725   }
5726
5727   List<GenoPro::Individuals::Individual_ptr> GenoPro::Individuals::elements_Individual()
5728   {
5729     return _list_Individual;
5730   }
5731
5732   GenoPro::Individuals::Individual_p GenoPro::Individuals::add_node_Individual()
5733   {
5734     return get_sequence()->add_node_Individual();
5735   }
5736
5737   List<GenoPro::Individuals::Individual_ptr> GenoPro::Individuals::set_count_Individual(unsigned int size)
5738   {
5739     return get_sequence()->set_count_Individual(size);
5740   }
5741
5742
5743
5744   /* attribute  functions  */
5745
5746   //constructor
5747   GenoPro::Individuals::sequence::sequence(Individuals* that):
5748     _that(that)
5749   {
5750     XsdFsmBasePtr fsmArray[] = {
5751     new XsdFSM<Individual_ptr>( Particle(new DOMString("libgno"), DOMString("Individual"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Individual_ptr, Individuals, FsmCbOptions>(_that, &Individuals::create_Individual)),
5752
5753       NULL
5754     } ;
5755
5756     XsdSequenceFsmOfFSMs::init(fsmArray);
5757   }
5758
5759
5760
5761   List<GenoPro::Individuals::Individual_ptr> GenoPro::Individuals::sequence::elements_Individual()
5762   {
5763
5764     List<Individual_ptr> nodeList;
5765     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
5766     if(fsm_p)
5767     {
5768       XsdFSM<Individual_ptr> *unitFsm = dynamic_cast<XsdFSM<Individual_ptr> *>(fsm_p);
5769       if(unitFsm) {
5770         //nodeList = unitFsm->nodeList().stl_list();
5771         nodeList = unitFsm->nodeList();
5772       }
5773     }
5774     return nodeList;
5775
5776   }
5777
5778
5779   GenoPro::Individuals::Individual_p GenoPro::Individuals::sequence::element_Individual_at(unsigned int idx)
5780   {
5781     return elements_Individual().at(idx);
5782   }
5783
5784
5785   GenoPro::Individuals::Individual_p GenoPro::Individuals::sequence::add_node_Individual()
5786   {
5787     DOMStringPtr nsUriPtr = new DOMString("libgno");
5788     XsdEvent event(nsUriPtr, NULL, DOMString("Individual"), XsdEvent::ELEMENT_START, false);
5789     this->processEventThrow(event);
5790     return elements_Individual().back();
5791   }
5792
5793   List<GenoPro::Individuals::Individual_ptr> GenoPro::Individuals::sequence::set_count_Individual(unsigned int size)
5794   {
5795     if( (size > -1) || (size < 1)) {
5796       ostringstream oss;
5797       oss << "set_count_Individual: size should be in range: [" << 1
5798         << "," << "unbounded" << "]";
5799       throw IndexOutOfBoundsException(oss.str());
5800     }
5801
5802     unsigned int prevSize = elements_Individual().size();
5803     if(size < prevSize) {
5804       //FIXME: allow later:
5805       throw XPlus::RuntimeException("resize lesser than current size not allowed");
5806     }
5807
5808     for(unsigned int j=prevSize; j<size; j++)
5809     {
5810       // pretend docBuilding to avoid computation of adding after first loop
5811       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Individual"), XsdEvent::ELEMENT_START, false);
5812       this->processEventThrow(event);
5813     }
5814
5815     return elements_Individual();
5816   }
5817
5818
5819
5820   //constructor
5821
5822   GenoPro::Individuals::Individual::Individual(ElementCreateArgs args):
5823       XMLSchema::XmlElement<anyType>(args),
5824
5825     _fsmAttrs(NULL),
5826     _fsmElems(NULL)
5827
5828     , _sequence(new sequence(this) )
5829
5830   {
5831     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
5832     initFSM();
5833     if(args.ownerDoc && args.ownerDoc->buildTree())
5834     {
5835       if(args.ownerDoc->createSample()) {
5836         _fsm->fireSampleEvents();
5837       }
5838       else {
5839         _fsm->fireRequiredEvents();
5840       }
5841     }
5842   }
5843
5844   void GenoPro::Individuals::Individual::initFSM()
5845   {
5846     XsdFsmBasePtr fsmsAttrs[] = {
5847   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Individual, FsmCbOptions>(this, &Individual::create_attr_ID)),
5848
5849       NULL
5850     };
5851
5852     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
5853
5854     _fsm->replaceContentFsm(_sequence);
5855
5856     _fsmAttrs = _fsm->attributeFsm();
5857     _fsmElems = _fsm->contentFsm();
5858
5859   }
5860
5861   /* element functions  */
5862
5863
5864   GenoPro::Individuals::Individual::Name_ptr GenoPro::Individuals::Individual::create_Name(FsmCbOptions& options)
5865   {
5866     static DOMStringPtr myName = new DOMString("Name");
5867     static DOMStringPtr myNsUri = new DOMString("libgno");
5868
5869     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
5870     GenoPro::Individuals::Individual::Name_p node = XSD::createElementTmpl<Name, void*>(t);
5871
5872     _Name = node;
5873
5874     return node;
5875   }
5876
5877
5878   GenoPro::Individuals::Individual::Name_p GenoPro::Individuals::Individual::element_Name()
5879   {
5880     FSM::warnNullNode(_Name, "Name", "{}Name", 0);
5881     return _Name;
5882   }
5883
5884   void GenoPro::Individuals::Individual::mark_present_Name()
5885   {
5886     return get_sequence()->mark_present_Name();
5887   }
5888
5889
5890   GenoPro::Individuals::Individual::Position_ptr GenoPro::Individuals::Individual::create_Position(FsmCbOptions& options)
5891   {
5892     static DOMStringPtr myName = new DOMString("Position");
5893     static DOMStringPtr myNsUri = new DOMString("libgno");
5894
5895     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
5896     GenoPro::Individuals::Individual::Position_p node = XSD::createElementTmpl<Position, void*>(t);
5897
5898     if(options.isSampleCreate && (node->stringValue() == "") ) {
5899       node->stringValue(node->sampleValue());
5900     }
5901
5902     _Position = node;
5903
5904     return node;
5905   }
5906
5907
5908   GenoPro::Individuals::Individual::Position_p GenoPro::Individuals::Individual::element_Position()
5909   {
5910     FSM::warnNullNode(_Position, "Position", "{}Position", 0);
5911     return _Position;
5912   }
5913
5914   void GenoPro::Individuals::Individual::mark_present_Position()
5915   {
5916     return get_sequence()->mark_present_Position();
5917   }
5918
5919
5920   GenoPro::Individuals::Individual::Gender_ptr GenoPro::Individuals::Individual::create_Gender(FsmCbOptions& options)
5921   {
5922     static DOMStringPtr myName = new DOMString("Gender");
5923     static DOMStringPtr myNsUri = new DOMString("libgno");
5924
5925     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
5926     GenoPro::Individuals::Individual::Gender_p node = XSD::createElementTmpl<Gender, XMLSchema::Types::bt_normalizedString*>(t);
5927
5928     if(options.isSampleCreate && (node->stringValue() == "") ) {
5929       node->stringValue(node->sampleValue());
5930     }
5931
5932     _Gender = node;
5933
5934     return node;
5935   }
5936
5937
5938   GenoPro::Individuals::Individual::Gender_p GenoPro::Individuals::Individual::element_Gender()
5939   {
5940     FSM::warnNullNode(_Gender, "Gender", "{http://www.w3.org/2001/XMLSchema}Gender", 0);
5941     return _Gender;
5942   }
5943
5944   void GenoPro::Individuals::Individual::set_Gender(DOMString val)
5945   {
5946     get_sequence()->set_Gender(val);
5947   }
5948
5949   DOMString GenoPro::Individuals::Individual::get_Gender_string()
5950   {
5951     return get_sequence()->get_Gender_string();
5952   }
5953
5954
5955   void GenoPro::Individuals::Individual::mark_present_Gender()
5956   {
5957     return get_sequence()->mark_present_Gender();
5958   }
5959
5960
5961   GenoPro::Individuals::Individual::IsDead_ptr GenoPro::Individuals::Individual::create_IsDead(FsmCbOptions& options)
5962   {
5963     static DOMStringPtr myName = new DOMString("IsDead");
5964     static DOMStringPtr myNsUri = new DOMString("libgno");
5965
5966     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
5967     GenoPro::Individuals::Individual::IsDead_p node = XSD::createElementTmpl<IsDead, XMLSchema::Types::bt_normalizedString*>(t);
5968
5969     if(options.isSampleCreate && (node->stringValue() == "") ) {
5970       node->stringValue(node->sampleValue());
5971     }
5972
5973     _IsDead = node;
5974
5975     return node;
5976   }
5977
5978
5979   GenoPro::Individuals::Individual::IsDead_p GenoPro::Individuals::Individual::element_IsDead()
5980   {
5981     FSM::warnNullNode(_IsDead, "IsDead", "{http://www.w3.org/2001/XMLSchema}IsDead", 0);
5982     return _IsDead;
5983   }
5984
5985   void GenoPro::Individuals::Individual::set_IsDead(DOMString val)
5986   {
5987     get_sequence()->set_IsDead(val);
5988   }
5989
5990   DOMString GenoPro::Individuals::Individual::get_IsDead_string()
5991   {
5992     return get_sequence()->get_IsDead_string();
5993   }
5994
5995
5996   void GenoPro::Individuals::Individual::mark_present_IsDead()
5997   {
5998     return get_sequence()->mark_present_IsDead();
5999   }
6000
6001
6002   GenoPro::Individuals::Individual::Death_ptr GenoPro::Individuals::Individual::create_Death(FsmCbOptions& options)
6003   {
6004     static DOMStringPtr myName = new DOMString("Death");
6005     static DOMStringPtr myNsUri = new DOMString("libgno");
6006
6007     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
6008     GenoPro::Individuals::Individual::Death_p node = XSD::createElementTmpl<Death, void*>(t);
6009
6010     _Death = node;
6011
6012     return node;
6013   }
6014
6015
6016   GenoPro::Individuals::Individual::Death_p GenoPro::Individuals::Individual::element_Death()
6017   {
6018     FSM::warnNullNode(_Death, "Death", "{}Death", 0);
6019     return _Death;
6020   }
6021
6022   void GenoPro::Individuals::Individual::mark_present_Death()
6023   {
6024     return get_sequence()->mark_present_Death();
6025   }
6026
6027
6028   GenoPro::Individuals::Individual::child_no_ptr GenoPro::Individuals::Individual::create_child_no(FsmCbOptions& options)
6029   {
6030     static DOMStringPtr myName = new DOMString("child_no");
6031     static DOMStringPtr myNsUri = new DOMString("libgno");
6032
6033     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "int");
6034     GenoPro::Individuals::Individual::child_no_p node = XSD::createElementTmpl<child_no, XMLSchema::Types::bt_int*>(t);
6035
6036     if(options.isSampleCreate && (node->stringValue() == "") ) {
6037       node->stringValue(node->sampleValue());
6038     }
6039
6040     _child_no = node;
6041
6042     return node;
6043   }
6044
6045
6046   GenoPro::Individuals::Individual::child_no_p GenoPro::Individuals::Individual::element_child_no()
6047   {
6048     FSM::warnNullNode(_child_no, "child_no", "{http://www.w3.org/2001/XMLSchema}child_no", 0);
6049     return _child_no;
6050   }
6051
6052   void GenoPro::Individuals::Individual::set_child_no(DOMString val)
6053   {
6054     get_sequence()->set_child_no(val);
6055   }
6056
6057   DOMString GenoPro::Individuals::Individual::get_child_no_string()
6058   {
6059     return get_sequence()->get_child_no_string();
6060   }
6061
6062
6063   void GenoPro::Individuals::Individual::set_child_no(int val)
6064   {
6065     get_sequence()->set_child_no(val);
6066   }
6067
6068   int GenoPro::Individuals::Individual::get_child_no()
6069   {
6070     return get_sequence()->get_child_no();
6071   }
6072
6073
6074   void GenoPro::Individuals::Individual::mark_present_child_no()
6075   {
6076     return get_sequence()->mark_present_child_no();
6077   }
6078
6079
6080   /* attribute  functions  */
6081
6082
6083   GenoPro::Individuals::Individual::attr_ID_ptr GenoPro::Individuals::Individual::create_attr_ID(FsmCbOptions& options)
6084   {
6085     static DOMStringPtr myName = new DOMString("ID");
6086     static DOMStringPtr myNsUri = NULL;
6087
6088     if(_attr_ID) {
6089       return _attr_ID;
6090     }
6091     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
6092     GenoPro::Individuals::Individual::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
6093
6094     if(options.isSampleCreate && (node->stringValue() == "") ) {
6095       node->stringValue(node->sampleValue());
6096     }
6097
6098     _attr_ID = node;
6099
6100     return node;
6101   }
6102
6103
6104     void GenoPro::Individuals::Individual::set_attr_ID(DOMString val)
6105     {
6106
6107       attribute_attr_ID()->stringValue(val);
6108     }
6109
6110     DOMString GenoPro::Individuals::Individual::get_attr_ID_string()
6111     {
6112
6113       return attribute_attr_ID()->stringValue();
6114     }
6115
6116
6117   GenoPro::Individuals::Individual::attr_ID_p GenoPro::Individuals::Individual::attribute_attr_ID()
6118   {
6119     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
6120     return _attr_ID;
6121   }
6122
6123   //constructor
6124   GenoPro::Individuals::Individual::sequence::sequence(Individual* that):
6125     _that(that)
6126   {
6127     XsdFsmBasePtr fsmArray[] = {
6128     new XsdFSM<Name_ptr>( Particle(new DOMString("libgno"), DOMString("Name"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Name_ptr, Individual, FsmCbOptions>(_that, &Individual::create_Name)),
6129       new XsdFSM<Position_ptr>( Particle(new DOMString("libgno"), DOMString("Position"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Position_ptr, Individual, FsmCbOptions>(_that, &Individual::create_Position)),
6130       new XsdFSM<Gender_ptr>( Particle(new DOMString("libgno"), DOMString("Gender"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Gender_ptr, Individual, FsmCbOptions>(_that, &Individual::create_Gender)),
6131       new XsdFSM<IsDead_ptr>( Particle(new DOMString("libgno"), DOMString("IsDead"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<IsDead_ptr, Individual, FsmCbOptions>(_that, &Individual::create_IsDead)),
6132       new XsdFSM<Death_ptr>( Particle(new DOMString("libgno"), DOMString("Death"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Death_ptr, Individual, FsmCbOptions>(_that, &Individual::create_Death)),
6133       new XsdFSM<child_no_ptr>( Particle(new DOMString("libgno"), DOMString("child_no"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<child_no_ptr, Individual, FsmCbOptions>(_that, &Individual::create_child_no)),
6134
6135       NULL
6136     } ;
6137
6138     XsdSequenceFsmOfFSMs::init(fsmArray);
6139   }
6140
6141
6142
6143   GenoPro::Individuals::Individual::Name_p GenoPro::Individuals::Individual::sequence::element_Name()
6144   {
6145       GenoPro::Individuals::Individual::Name_p node_p = NULL;
6146     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
6147     if(fsm_p)
6148     {
6149       XsdFSM<Name_ptr> *unitFsm = dynamic_cast<XsdFSM<Name_ptr> *>(fsm_p);
6150       if(unitFsm && unitFsm->nodeList().size()>0) {
6151         assert(unitFsm->nodeList().size()==1);
6152         node_p = unitFsm->nodeList().at(0);
6153       }
6154     }
6155
6156     FSM::warnNullNode(node_p, "Name", "{}Name", 0);
6157     return node_p;
6158
6159   }
6160
6161
6162
6163   void GenoPro::Individuals::Individual::sequence::mark_present_Name()
6164   {
6165     DOMStringPtr nsUriPtr = new DOMString("libgno");
6166     XsdEvent event(nsUriPtr, NULL, DOMString("Name"), XsdEvent::ELEMENT_START, false);
6167     this->processEventThrow(event);
6168   }
6169
6170
6171
6172   GenoPro::Individuals::Individual::Position_p GenoPro::Individuals::Individual::sequence::element_Position()
6173   {
6174       GenoPro::Individuals::Individual::Position_p node_p = NULL;
6175     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
6176     if(fsm_p)
6177     {
6178       XsdFSM<Position_ptr> *unitFsm = dynamic_cast<XsdFSM<Position_ptr> *>(fsm_p);
6179       if(unitFsm && unitFsm->nodeList().size()>0) {
6180         assert(unitFsm->nodeList().size()==1);
6181         node_p = unitFsm->nodeList().at(0);
6182       }
6183     }
6184
6185     FSM::warnNullNode(node_p, "Position", "{}Position", 0);
6186     return node_p;
6187
6188   }
6189
6190
6191
6192   void GenoPro::Individuals::Individual::sequence::mark_present_Position()
6193   {
6194     DOMStringPtr nsUriPtr = new DOMString("libgno");
6195     XsdEvent event(nsUriPtr, NULL, DOMString("Position"), XsdEvent::ELEMENT_START, false);
6196     this->processEventThrow(event);
6197   }
6198
6199
6200
6201   GenoPro::Individuals::Individual::Gender_p GenoPro::Individuals::Individual::sequence::element_Gender()
6202   {
6203       GenoPro::Individuals::Individual::Gender_p node_p = NULL;
6204     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
6205     if(fsm_p)
6206     {
6207       XsdFSM<Gender_ptr> *unitFsm = dynamic_cast<XsdFSM<Gender_ptr> *>(fsm_p);
6208       if(unitFsm && unitFsm->nodeList().size()>0) {
6209         assert(unitFsm->nodeList().size()==1);
6210         node_p = unitFsm->nodeList().at(0);
6211       }
6212     }
6213
6214     FSM::warnNullNode(node_p, "Gender", "{http://www.w3.org/2001/XMLSchema}Gender", 0);
6215     return node_p;
6216
6217   }
6218
6219
6220   void GenoPro::Individuals::Individual::sequence::set_Gender(DOMString val)
6221   {
6222
6223     mark_present_Gender();
6224
6225     element_Gender()->stringValue(val);
6226   }
6227
6228   DOMString GenoPro::Individuals::Individual::sequence::get_Gender_string()
6229   {
6230     return element_Gender()->stringValue();
6231   }
6232
6233
6234
6235   void GenoPro::Individuals::Individual::sequence::mark_present_Gender()
6236   {
6237     DOMStringPtr nsUriPtr = new DOMString("libgno");
6238     XsdEvent event(nsUriPtr, NULL, DOMString("Gender"), XsdEvent::ELEMENT_START, false);
6239     this->processEventThrow(event);
6240   }
6241
6242
6243
6244   GenoPro::Individuals::Individual::IsDead_p GenoPro::Individuals::Individual::sequence::element_IsDead()
6245   {
6246       GenoPro::Individuals::Individual::IsDead_p node_p = NULL;
6247     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
6248     if(fsm_p)
6249     {
6250       XsdFSM<IsDead_ptr> *unitFsm = dynamic_cast<XsdFSM<IsDead_ptr> *>(fsm_p);
6251       if(unitFsm && unitFsm->nodeList().size()>0) {
6252         assert(unitFsm->nodeList().size()==1);
6253         node_p = unitFsm->nodeList().at(0);
6254       }
6255     }
6256
6257     FSM::warnNullNode(node_p, "IsDead", "{http://www.w3.org/2001/XMLSchema}IsDead", 0);
6258     return node_p;
6259
6260   }
6261
6262
6263   void GenoPro::Individuals::Individual::sequence::set_IsDead(DOMString val)
6264   {
6265
6266     mark_present_IsDead();
6267
6268     element_IsDead()->stringValue(val);
6269   }
6270
6271   DOMString GenoPro::Individuals::Individual::sequence::get_IsDead_string()
6272   {
6273     return element_IsDead()->stringValue();
6274   }
6275
6276
6277
6278   void GenoPro::Individuals::Individual::sequence::mark_present_IsDead()
6279   {
6280     DOMStringPtr nsUriPtr = new DOMString("libgno");
6281     XsdEvent event(nsUriPtr, NULL, DOMString("IsDead"), XsdEvent::ELEMENT_START, false);
6282     this->processEventThrow(event);
6283   }
6284
6285
6286
6287   GenoPro::Individuals::Individual::Death_p GenoPro::Individuals::Individual::sequence::element_Death()
6288   {
6289       GenoPro::Individuals::Individual::Death_p node_p = NULL;
6290     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
6291     if(fsm_p)
6292     {
6293       XsdFSM<Death_ptr> *unitFsm = dynamic_cast<XsdFSM<Death_ptr> *>(fsm_p);
6294       if(unitFsm && unitFsm->nodeList().size()>0) {
6295         assert(unitFsm->nodeList().size()==1);
6296         node_p = unitFsm->nodeList().at(0);
6297       }
6298     }
6299
6300     FSM::warnNullNode(node_p, "Death", "{}Death", 0);
6301     return node_p;
6302
6303   }
6304
6305
6306
6307   void GenoPro::Individuals::Individual::sequence::mark_present_Death()
6308   {
6309     DOMStringPtr nsUriPtr = new DOMString("libgno");
6310     XsdEvent event(nsUriPtr, NULL, DOMString("Death"), XsdEvent::ELEMENT_START, false);
6311     this->processEventThrow(event);
6312   }
6313
6314
6315
6316   GenoPro::Individuals::Individual::child_no_p GenoPro::Individuals::Individual::sequence::element_child_no()
6317   {
6318       GenoPro::Individuals::Individual::child_no_p node_p = NULL;
6319     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
6320     if(fsm_p)
6321     {
6322       XsdFSM<child_no_ptr> *unitFsm = dynamic_cast<XsdFSM<child_no_ptr> *>(fsm_p);
6323       if(unitFsm && unitFsm->nodeList().size()>0) {
6324         assert(unitFsm->nodeList().size()==1);
6325         node_p = unitFsm->nodeList().at(0);
6326       }
6327     }
6328
6329     FSM::warnNullNode(node_p, "child_no", "{http://www.w3.org/2001/XMLSchema}child_no", 0);
6330     return node_p;
6331
6332   }
6333
6334
6335   void GenoPro::Individuals::Individual::sequence::set_child_no(DOMString val)
6336   {
6337
6338     mark_present_child_no();
6339
6340     element_child_no()->stringValue(val);
6341   }
6342
6343   DOMString GenoPro::Individuals::Individual::sequence::get_child_no_string()
6344   {
6345     return element_child_no()->stringValue();
6346   }
6347
6348
6349   void GenoPro::Individuals::Individual::sequence::set_child_no(int val)
6350   {
6351
6352     mark_present_child_no();
6353
6354     element_child_no()->value(val);
6355   }
6356
6357   int GenoPro::Individuals::Individual::sequence::get_child_no()
6358   {
6359     return element_child_no()->value();
6360   }
6361
6362
6363
6364   void GenoPro::Individuals::Individual::sequence::mark_present_child_no()
6365   {
6366     DOMStringPtr nsUriPtr = new DOMString("libgno");
6367     XsdEvent event(nsUriPtr, NULL, DOMString("child_no"), XsdEvent::ELEMENT_START, false);
6368     this->processEventThrow(event);
6369   }
6370
6371
6372
6373   //constructor
6374
6375   GenoPro::Individuals::Individual::Name::Name(ElementCreateArgs args):
6376       XMLSchema::XmlElement<anyType>(args),
6377
6378     _fsmAttrs(NULL),
6379     _fsmElems(NULL)
6380
6381     , _sequence(new sequence(this) )
6382
6383   {
6384     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
6385     initFSM();
6386     if(args.ownerDoc && args.ownerDoc->buildTree())
6387     {
6388       if(args.ownerDoc->createSample()) {
6389         _fsm->fireSampleEvents();
6390       }
6391       else {
6392         _fsm->fireRequiredEvents();
6393       }
6394     }
6395   }
6396
6397   void GenoPro::Individuals::Individual::Name::initFSM()
6398   {
6399     XsdFsmBasePtr fsmsAttrs[] = {
6400
6401       NULL
6402     };
6403
6404     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
6405
6406     _fsm->replaceContentFsm(_sequence);
6407
6408     _fsmAttrs = _fsm->attributeFsm();
6409     _fsmElems = _fsm->contentFsm();
6410
6411   }
6412
6413   /* element functions  */
6414
6415
6416   GenoPro::Individuals::Individual::Name::Display_ptr GenoPro::Individuals::Individual::Name::create_Display(FsmCbOptions& options)
6417   {
6418     static DOMStringPtr myName = new DOMString("Display");
6419     static DOMStringPtr myNsUri = new DOMString("libgno");
6420
6421     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
6422     GenoPro::Individuals::Individual::Name::Display_p node = XSD::createElementTmpl<Display, void*>(t);
6423
6424     if(options.isSampleCreate && (node->stringValue() == "") ) {
6425       node->stringValue(node->sampleValue());
6426     }
6427
6428     _Display = node;
6429
6430     return node;
6431   }
6432
6433
6434   GenoPro::Individuals::Individual::Name::Display_p GenoPro::Individuals::Individual::Name::element_Display()
6435   {
6436     FSM::warnNullNode(_Display, "Display", "{}Display", 0);
6437     return _Display;
6438   }
6439
6440   void GenoPro::Individuals::Individual::Name::mark_present_Display()
6441   {
6442     return get_sequence()->mark_present_Display();
6443   }
6444
6445
6446   GenoPro::Individuals::Individual::Name::First_ptr GenoPro::Individuals::Individual::Name::create_First(FsmCbOptions& options)
6447   {
6448     static DOMStringPtr myName = new DOMString("First");
6449     static DOMStringPtr myNsUri = new DOMString("libgno");
6450
6451     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
6452     GenoPro::Individuals::Individual::Name::First_p node = XSD::createElementTmpl<First, XMLSchema::Types::bt_normalizedString*>(t);
6453
6454     if(options.isSampleCreate && (node->stringValue() == "") ) {
6455       node->stringValue(node->sampleValue());
6456     }
6457
6458     _First = node;
6459
6460     return node;
6461   }
6462
6463
6464   GenoPro::Individuals::Individual::Name::First_p GenoPro::Individuals::Individual::Name::element_First()
6465   {
6466     FSM::warnNullNode(_First, "First", "{http://www.w3.org/2001/XMLSchema}First", 0);
6467     return _First;
6468   }
6469
6470   void GenoPro::Individuals::Individual::Name::set_First(DOMString val)
6471   {
6472     get_sequence()->set_First(val);
6473   }
6474
6475   DOMString GenoPro::Individuals::Individual::Name::get_First_string()
6476   {
6477     return get_sequence()->get_First_string();
6478   }
6479
6480
6481   void GenoPro::Individuals::Individual::Name::mark_present_First()
6482   {
6483     return get_sequence()->mark_present_First();
6484   }
6485
6486
6487   GenoPro::Individuals::Individual::Name::Last_ptr GenoPro::Individuals::Individual::Name::create_Last(FsmCbOptions& options)
6488   {
6489     static DOMStringPtr myName = new DOMString("Last");
6490     static DOMStringPtr myNsUri = new DOMString("libgno");
6491
6492     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
6493     GenoPro::Individuals::Individual::Name::Last_p node = XSD::createElementTmpl<Last, XMLSchema::Types::bt_normalizedString*>(t);
6494
6495     if(options.isSampleCreate && (node->stringValue() == "") ) {
6496       node->stringValue(node->sampleValue());
6497     }
6498
6499     _Last = node;
6500
6501     return node;
6502   }
6503
6504
6505   GenoPro::Individuals::Individual::Name::Last_p GenoPro::Individuals::Individual::Name::element_Last()
6506   {
6507     FSM::warnNullNode(_Last, "Last", "{http://www.w3.org/2001/XMLSchema}Last", 0);
6508     return _Last;
6509   }
6510
6511   void GenoPro::Individuals::Individual::Name::set_Last(DOMString val)
6512   {
6513     get_sequence()->set_Last(val);
6514   }
6515
6516   DOMString GenoPro::Individuals::Individual::Name::get_Last_string()
6517   {
6518     return get_sequence()->get_Last_string();
6519   }
6520
6521
6522   void GenoPro::Individuals::Individual::Name::mark_present_Last()
6523   {
6524     return get_sequence()->mark_present_Last();
6525   }
6526
6527
6528   /* attribute  functions  */
6529
6530   //constructor
6531   GenoPro::Individuals::Individual::Name::sequence::sequence(Name* that):
6532     _that(that)
6533   {
6534     XsdFsmBasePtr fsmArray[] = {
6535     new XsdFSM<Display_ptr>( Particle(new DOMString("libgno"), DOMString("Display"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Display_ptr, Name, FsmCbOptions>(_that, &Name::create_Display)),
6536       new XsdFSM<First_ptr>( Particle(new DOMString("libgno"), DOMString("First"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<First_ptr, Name, FsmCbOptions>(_that, &Name::create_First)),
6537       new XsdFSM<Last_ptr>( Particle(new DOMString("libgno"), DOMString("Last"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Last_ptr, Name, FsmCbOptions>(_that, &Name::create_Last)),
6538
6539       NULL
6540     } ;
6541
6542     XsdSequenceFsmOfFSMs::init(fsmArray);
6543   }
6544
6545
6546
6547   GenoPro::Individuals::Individual::Name::Display_p GenoPro::Individuals::Individual::Name::sequence::element_Display()
6548   {
6549       GenoPro::Individuals::Individual::Name::Display_p node_p = NULL;
6550     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
6551     if(fsm_p)
6552     {
6553       XsdFSM<Display_ptr> *unitFsm = dynamic_cast<XsdFSM<Display_ptr> *>(fsm_p);
6554       if(unitFsm && unitFsm->nodeList().size()>0) {
6555         assert(unitFsm->nodeList().size()==1);
6556         node_p = unitFsm->nodeList().at(0);
6557       }
6558     }
6559
6560     FSM::warnNullNode(node_p, "Display", "{}Display", 0);
6561     return node_p;
6562
6563   }
6564
6565
6566
6567   void GenoPro::Individuals::Individual::Name::sequence::mark_present_Display()
6568   {
6569     DOMStringPtr nsUriPtr = new DOMString("libgno");
6570     XsdEvent event(nsUriPtr, NULL, DOMString("Display"), XsdEvent::ELEMENT_START, false);
6571     this->processEventThrow(event);
6572   }
6573
6574
6575
6576   GenoPro::Individuals::Individual::Name::First_p GenoPro::Individuals::Individual::Name::sequence::element_First()
6577   {
6578       GenoPro::Individuals::Individual::Name::First_p node_p = NULL;
6579     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
6580     if(fsm_p)
6581     {
6582       XsdFSM<First_ptr> *unitFsm = dynamic_cast<XsdFSM<First_ptr> *>(fsm_p);
6583       if(unitFsm && unitFsm->nodeList().size()>0) {
6584         assert(unitFsm->nodeList().size()==1);
6585         node_p = unitFsm->nodeList().at(0);
6586       }
6587     }
6588
6589     FSM::warnNullNode(node_p, "First", "{http://www.w3.org/2001/XMLSchema}First", 0);
6590     return node_p;
6591
6592   }
6593
6594
6595   void GenoPro::Individuals::Individual::Name::sequence::set_First(DOMString val)
6596   {
6597
6598     mark_present_First();
6599
6600     element_First()->stringValue(val);
6601   }
6602
6603   DOMString GenoPro::Individuals::Individual::Name::sequence::get_First_string()
6604   {
6605     return element_First()->stringValue();
6606   }
6607
6608
6609
6610   void GenoPro::Individuals::Individual::Name::sequence::mark_present_First()
6611   {
6612     DOMStringPtr nsUriPtr = new DOMString("libgno");
6613     XsdEvent event(nsUriPtr, NULL, DOMString("First"), XsdEvent::ELEMENT_START, false);
6614     this->processEventThrow(event);
6615   }
6616
6617
6618
6619   GenoPro::Individuals::Individual::Name::Last_p GenoPro::Individuals::Individual::Name::sequence::element_Last()
6620   {
6621       GenoPro::Individuals::Individual::Name::Last_p node_p = NULL;
6622     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
6623     if(fsm_p)
6624     {
6625       XsdFSM<Last_ptr> *unitFsm = dynamic_cast<XsdFSM<Last_ptr> *>(fsm_p);
6626       if(unitFsm && unitFsm->nodeList().size()>0) {
6627         assert(unitFsm->nodeList().size()==1);
6628         node_p = unitFsm->nodeList().at(0);
6629       }
6630     }
6631
6632     FSM::warnNullNode(node_p, "Last", "{http://www.w3.org/2001/XMLSchema}Last", 0);
6633     return node_p;
6634
6635   }
6636
6637
6638   void GenoPro::Individuals::Individual::Name::sequence::set_Last(DOMString val)
6639   {
6640
6641     mark_present_Last();
6642
6643     element_Last()->stringValue(val);
6644   }
6645
6646   DOMString GenoPro::Individuals::Individual::Name::sequence::get_Last_string()
6647   {
6648     return element_Last()->stringValue();
6649   }
6650
6651
6652
6653   void GenoPro::Individuals::Individual::Name::sequence::mark_present_Last()
6654   {
6655     DOMStringPtr nsUriPtr = new DOMString("libgno");
6656     XsdEvent event(nsUriPtr, NULL, DOMString("Last"), XsdEvent::ELEMENT_START, false);
6657     this->processEventThrow(event);
6658   }
6659
6660
6661   //constructor
6662
6663   GenoPro::Individuals::Individual::Name::Display::Display(ElementCreateArgs args):
6664       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
6665
6666     _fsmAttrs(NULL),
6667     _fsmElems(NULL)
6668   {
6669
6670
6671     initFSM();
6672
6673
6674     if(args.ownerDoc && args.ownerDoc->buildTree())
6675
6676     {
6677       if(args.ownerDoc->createSample()) {
6678         _fsm->fireSampleEvents();
6679       }
6680       else {
6681         _fsm->fireRequiredEvents();
6682       }
6683     }
6684   }
6685
6686   void GenoPro::Individuals::Individual::Name::Display::initFSM()
6687   {
6688     XsdFsmBasePtr fsmsAttrs[] = {
6689     new XsdFSM<attr_Lines_ptr>( Particle(NULL, DOMString("Lines"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Lines_ptr, Display, FsmCbOptions>(this, &Display::create_attr_Lines)),
6690
6691       NULL
6692     };
6693
6694     _fsm->appendAttributeFsms(fsmsAttrs);
6695     _fsmAttrs = _fsm->attributeFsm();
6696     _fsmElems = _fsm->contentFsm();
6697
6698    }
6699
6700   /* element functions  */
6701
6702
6703   /* attribute  functions  */
6704
6705
6706   GenoPro::Individuals::Individual::Name::Display::attr_Lines_ptr GenoPro::Individuals::Individual::Name::Display::create_attr_Lines(FsmCbOptions& options)
6707   {
6708     static DOMStringPtr myName = new DOMString("Lines");
6709     static DOMStringPtr myNsUri = NULL;
6710
6711     if(_attr_Lines) {
6712       return _attr_Lines;
6713     }
6714     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
6715     GenoPro::Individuals::Individual::Name::Display::attr_Lines_p node = XSD::createAttributeTmpl<attr_Lines>(t);
6716
6717     if(options.isSampleCreate && (node->stringValue() == "") ) {
6718       node->stringValue(node->sampleValue());
6719     }
6720
6721     _attr_Lines = node;
6722
6723     return node;
6724   }
6725
6726
6727     void GenoPro::Individuals::Individual::Name::Display::set_attr_Lines(DOMString val)
6728     {
6729
6730       attribute_attr_Lines()->stringValue(val);
6731     }
6732
6733     DOMString GenoPro::Individuals::Individual::Name::Display::get_attr_Lines_string()
6734     {
6735
6736       return attribute_attr_Lines()->stringValue();
6737     }
6738
6739
6740     void GenoPro::Individuals::Individual::Name::Display::set_attr_Lines(int val)
6741     {
6742
6743       attribute_attr_Lines()->value(val);
6744     }
6745
6746     int GenoPro::Individuals::Individual::Name::Display::get_attr_Lines()
6747     {
6748
6749       return attribute_attr_Lines()->value();
6750     }
6751
6752
6753   GenoPro::Individuals::Individual::Name::Display::attr_Lines_p GenoPro::Individuals::Individual::Name::Display::attribute_attr_Lines()
6754   {
6755     FSM::warnNullNode(_attr_Lines, "attr_Lines", "{http://www.w3.org/2001/XMLSchema}Lines", 1);
6756     return _attr_Lines;
6757   }
6758
6759   //constructor
6760
6761   GenoPro::Individuals::Individual::Position::Position(ElementCreateArgs args):
6762       XMLSchema::XmlElement<XMLSchema::Types::bt_normalizedString>(args),
6763
6764     _fsmAttrs(NULL),
6765     _fsmElems(NULL)
6766   {
6767
6768
6769     initFSM();
6770
6771
6772     if(args.ownerDoc && args.ownerDoc->buildTree())
6773
6774     {
6775       if(args.ownerDoc->createSample()) {
6776         _fsm->fireSampleEvents();
6777       }
6778       else {
6779         _fsm->fireRequiredEvents();
6780       }
6781     }
6782   }
6783
6784   void GenoPro::Individuals::Individual::Position::initFSM()
6785   {
6786     XsdFsmBasePtr fsmsAttrs[] = {
6787     new XsdFSM<attr_BoundaryRect_ptr>( Particle(NULL, DOMString("BoundaryRect"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_BoundaryRect_ptr, Position, FsmCbOptions>(this, &Position::create_attr_BoundaryRect)),
6788
6789       NULL
6790     };
6791
6792     _fsm->appendAttributeFsms(fsmsAttrs);
6793     _fsmAttrs = _fsm->attributeFsm();
6794     _fsmElems = _fsm->contentFsm();
6795
6796    }
6797
6798   /* element functions  */
6799
6800
6801   /* attribute  functions  */
6802
6803
6804   GenoPro::Individuals::Individual::Position::attr_BoundaryRect_ptr GenoPro::Individuals::Individual::Position::create_attr_BoundaryRect(FsmCbOptions& options)
6805   {
6806     static DOMStringPtr myName = new DOMString("BoundaryRect");
6807     static DOMStringPtr myNsUri = NULL;
6808
6809     if(_attr_BoundaryRect) {
6810       return _attr_BoundaryRect;
6811     }
6812     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
6813     GenoPro::Individuals::Individual::Position::attr_BoundaryRect_p node = XSD::createAttributeTmpl<attr_BoundaryRect>(t);
6814
6815     if(options.isSampleCreate && (node->stringValue() == "") ) {
6816       node->stringValue(node->sampleValue());
6817     }
6818
6819     _attr_BoundaryRect = node;
6820
6821     return node;
6822   }
6823
6824
6825     void GenoPro::Individuals::Individual::Position::set_attr_BoundaryRect(DOMString val)
6826     {
6827
6828       attribute_attr_BoundaryRect()->stringValue(val);
6829     }
6830
6831     DOMString GenoPro::Individuals::Individual::Position::get_attr_BoundaryRect_string()
6832     {
6833
6834       return attribute_attr_BoundaryRect()->stringValue();
6835     }
6836
6837
6838   GenoPro::Individuals::Individual::Position::attr_BoundaryRect_p GenoPro::Individuals::Individual::Position::attribute_attr_BoundaryRect()
6839   {
6840     FSM::warnNullNode(_attr_BoundaryRect, "attr_BoundaryRect", "{http://www.w3.org/2001/XMLSchema}BoundaryRect", 1);
6841     return _attr_BoundaryRect;
6842   }
6843
6844
6845   //constructor
6846
6847   GenoPro::Individuals::Individual::Death::Death(ElementCreateArgs args):
6848       XMLSchema::XmlElement<anyType>(args),
6849
6850     _fsmAttrs(NULL),
6851     _fsmElems(NULL)
6852
6853     , _sequence(new sequence(this) )
6854
6855   {
6856     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
6857     initFSM();
6858     if(args.ownerDoc && args.ownerDoc->buildTree())
6859     {
6860       if(args.ownerDoc->createSample()) {
6861         _fsm->fireSampleEvents();
6862       }
6863       else {
6864         _fsm->fireRequiredEvents();
6865       }
6866     }
6867   }
6868
6869   void GenoPro::Individuals::Individual::Death::initFSM()
6870   {
6871     XsdFsmBasePtr fsmsAttrs[] = {
6872
6873       NULL
6874     };
6875
6876     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
6877
6878     _fsm->replaceContentFsm(_sequence);
6879
6880     _fsmAttrs = _fsm->attributeFsm();
6881     _fsmElems = _fsm->contentFsm();
6882
6883   }
6884
6885   /* element functions  */
6886
6887
6888   GenoPro::Individuals::Individual::Death::Cause_ptr GenoPro::Individuals::Individual::Death::create_Cause(FsmCbOptions& options)
6889   {
6890     static DOMStringPtr myName = new DOMString("Cause");
6891     static DOMStringPtr myNsUri = new DOMString("libgno");
6892
6893     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
6894     GenoPro::Individuals::Individual::Death::Cause_p node = XSD::createElementTmpl<Cause, void*>(t);
6895
6896     _Cause = node;
6897
6898     return node;
6899   }
6900
6901
6902   GenoPro::Individuals::Individual::Death::Cause_p GenoPro::Individuals::Individual::Death::element_Cause()
6903   {
6904     FSM::warnNullNode(_Cause, "Cause", "{}Cause", 0);
6905     return _Cause;
6906   }
6907
6908   void GenoPro::Individuals::Individual::Death::mark_present_Cause()
6909   {
6910     return get_sequence()->mark_present_Cause();
6911   }
6912
6913
6914   GenoPro::Individuals::Individual::Death::Comment_ptr GenoPro::Individuals::Individual::Death::create_Comment(FsmCbOptions& options)
6915   {
6916     static DOMStringPtr myName = new DOMString("Comment");
6917     static DOMStringPtr myNsUri = new DOMString("libgno");
6918
6919     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
6920     GenoPro::Individuals::Individual::Death::Comment_p node = XSD::createElementTmpl<Comment, XMLSchema::Types::bt_string*>(t);
6921
6922     if(options.isSampleCreate && (node->stringValue() == "") ) {
6923       node->stringValue(node->sampleValue());
6924     }
6925
6926     _Comment = node;
6927
6928     return node;
6929   }
6930
6931
6932   GenoPro::Individuals::Individual::Death::Comment_p GenoPro::Individuals::Individual::Death::element_Comment()
6933   {
6934     FSM::warnNullNode(_Comment, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
6935     return _Comment;
6936   }
6937
6938   void GenoPro::Individuals::Individual::Death::set_Comment(DOMString val)
6939   {
6940     get_sequence()->set_Comment(val);
6941   }
6942
6943   DOMString GenoPro::Individuals::Individual::Death::get_Comment_string()
6944   {
6945     return get_sequence()->get_Comment_string();
6946   }
6947
6948
6949   void GenoPro::Individuals::Individual::Death::mark_present_Comment()
6950   {
6951     return get_sequence()->mark_present_Comment();
6952   }
6953
6954
6955   /* attribute  functions  */
6956
6957   //constructor
6958   GenoPro::Individuals::Individual::Death::sequence::sequence(Death* that):
6959     _that(that)
6960   {
6961     XsdFsmBasePtr fsmArray[] = {
6962     new XsdFSM<Cause_ptr>( Particle(new DOMString("libgno"), DOMString("Cause"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Cause_ptr, Death, FsmCbOptions>(_that, &Death::create_Cause)),
6963       new XsdFSM<Comment_ptr>( Particle(new DOMString("libgno"), DOMString("Comment"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Comment_ptr, Death, FsmCbOptions>(_that, &Death::create_Comment)),
6964
6965       NULL
6966     } ;
6967
6968     XsdSequenceFsmOfFSMs::init(fsmArray);
6969   }
6970
6971
6972
6973   GenoPro::Individuals::Individual::Death::Cause_p GenoPro::Individuals::Individual::Death::sequence::element_Cause()
6974   {
6975       GenoPro::Individuals::Individual::Death::Cause_p node_p = NULL;
6976     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
6977     if(fsm_p)
6978     {
6979       XsdFSM<Cause_ptr> *unitFsm = dynamic_cast<XsdFSM<Cause_ptr> *>(fsm_p);
6980       if(unitFsm && unitFsm->nodeList().size()>0) {
6981         assert(unitFsm->nodeList().size()==1);
6982         node_p = unitFsm->nodeList().at(0);
6983       }
6984     }
6985
6986     FSM::warnNullNode(node_p, "Cause", "{}Cause", 0);
6987     return node_p;
6988
6989   }
6990
6991
6992
6993   void GenoPro::Individuals::Individual::Death::sequence::mark_present_Cause()
6994   {
6995     DOMStringPtr nsUriPtr = new DOMString("libgno");
6996     XsdEvent event(nsUriPtr, NULL, DOMString("Cause"), XsdEvent::ELEMENT_START, false);
6997     this->processEventThrow(event);
6998   }
6999
7000
7001
7002   GenoPro::Individuals::Individual::Death::Comment_p GenoPro::Individuals::Individual::Death::sequence::element_Comment()
7003   {
7004       GenoPro::Individuals::Individual::Death::Comment_p node_p = NULL;
7005     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
7006     if(fsm_p)
7007     {
7008       XsdFSM<Comment_ptr> *unitFsm = dynamic_cast<XsdFSM<Comment_ptr> *>(fsm_p);
7009       if(unitFsm && unitFsm->nodeList().size()>0) {
7010         assert(unitFsm->nodeList().size()==1);
7011         node_p = unitFsm->nodeList().at(0);
7012       }
7013     }
7014
7015     FSM::warnNullNode(node_p, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
7016     return node_p;
7017
7018   }
7019
7020
7021   void GenoPro::Individuals::Individual::Death::sequence::set_Comment(DOMString val)
7022   {
7023
7024     mark_present_Comment();
7025
7026     element_Comment()->stringValue(val);
7027   }
7028
7029   DOMString GenoPro::Individuals::Individual::Death::sequence::get_Comment_string()
7030   {
7031     return element_Comment()->stringValue();
7032   }
7033
7034
7035
7036   void GenoPro::Individuals::Individual::Death::sequence::mark_present_Comment()
7037   {
7038     DOMStringPtr nsUriPtr = new DOMString("libgno");
7039     XsdEvent event(nsUriPtr, NULL, DOMString("Comment"), XsdEvent::ELEMENT_START, false);
7040     this->processEventThrow(event);
7041   }
7042
7043
7044
7045   //constructor
7046
7047   GenoPro::Individuals::Individual::Death::Cause::Cause(ElementCreateArgs args):
7048       XMLSchema::XmlElement<anyType>(args),
7049
7050     _fsmAttrs(NULL),
7051     _fsmElems(NULL)
7052
7053     , _sequence(new sequence(this) )
7054
7055   {
7056     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
7057     initFSM();
7058     if(args.ownerDoc && args.ownerDoc->buildTree())
7059     {
7060       if(args.ownerDoc->createSample()) {
7061         _fsm->fireSampleEvents();
7062       }
7063       else {
7064         _fsm->fireRequiredEvents();
7065       }
7066     }
7067   }
7068
7069   void GenoPro::Individuals::Individual::Death::Cause::initFSM()
7070   {
7071     XsdFsmBasePtr fsmsAttrs[] = {
7072
7073       NULL
7074     };
7075
7076     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
7077
7078     _fsm->replaceContentFsm(_sequence);
7079
7080     _fsmAttrs = _fsm->attributeFsm();
7081     _fsmElems = _fsm->contentFsm();
7082
7083   }
7084
7085   /* element functions  */
7086
7087
7088   GenoPro::Individuals::Individual::Death::Cause::Description_ptr GenoPro::Individuals::Individual::Death::Cause::create_Description(FsmCbOptions& options)
7089   {
7090     static DOMStringPtr myName = new DOMString("Description");
7091     static DOMStringPtr myNsUri = new DOMString("libgno");
7092
7093     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
7094     GenoPro::Individuals::Individual::Death::Cause::Description_p node = XSD::createElementTmpl<Description, XMLSchema::Types::bt_string*>(t);
7095
7096     if(options.isSampleCreate && (node->stringValue() == "") ) {
7097       node->stringValue(node->sampleValue());
7098     }
7099
7100     _Description = node;
7101
7102     return node;
7103   }
7104
7105
7106   GenoPro::Individuals::Individual::Death::Cause::Description_p GenoPro::Individuals::Individual::Death::Cause::element_Description()
7107   {
7108     FSM::warnNullNode(_Description, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
7109     return _Description;
7110   }
7111
7112   void GenoPro::Individuals::Individual::Death::Cause::set_Description(DOMString val)
7113   {
7114     get_sequence()->set_Description(val);
7115   }
7116
7117   DOMString GenoPro::Individuals::Individual::Death::Cause::get_Description_string()
7118   {
7119     return get_sequence()->get_Description_string();
7120   }
7121
7122
7123   void GenoPro::Individuals::Individual::Death::Cause::mark_present_Description()
7124   {
7125     return get_sequence()->mark_present_Description();
7126   }
7127
7128
7129   /* attribute  functions  */
7130
7131   //constructor
7132   GenoPro::Individuals::Individual::Death::Cause::sequence::sequence(Cause* that):
7133     _that(that)
7134   {
7135     XsdFsmBasePtr fsmArray[] = {
7136     new XsdFSM<Description_ptr>( Particle(new DOMString("libgno"), DOMString("Description"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Description_ptr, Cause, FsmCbOptions>(_that, &Cause::create_Description)),
7137
7138       NULL
7139     } ;
7140
7141     XsdSequenceFsmOfFSMs::init(fsmArray);
7142   }
7143
7144
7145
7146   GenoPro::Individuals::Individual::Death::Cause::Description_p GenoPro::Individuals::Individual::Death::Cause::sequence::element_Description()
7147   {
7148       GenoPro::Individuals::Individual::Death::Cause::Description_p node_p = NULL;
7149     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
7150     if(fsm_p)
7151     {
7152       XsdFSM<Description_ptr> *unitFsm = dynamic_cast<XsdFSM<Description_ptr> *>(fsm_p);
7153       if(unitFsm && unitFsm->nodeList().size()>0) {
7154         assert(unitFsm->nodeList().size()==1);
7155         node_p = unitFsm->nodeList().at(0);
7156       }
7157     }
7158
7159     FSM::warnNullNode(node_p, "Description", "{http://www.w3.org/2001/XMLSchema}Description", 0);
7160     return node_p;
7161
7162   }
7163
7164
7165   void GenoPro::Individuals::Individual::Death::Cause::sequence::set_Description(DOMString val)
7166   {
7167
7168     mark_present_Description();
7169
7170     element_Description()->stringValue(val);
7171   }
7172
7173   DOMString GenoPro::Individuals::Individual::Death::Cause::sequence::get_Description_string()
7174   {
7175     return element_Description()->stringValue();
7176   }
7177
7178
7179
7180   void GenoPro::Individuals::Individual::Death::Cause::sequence::mark_present_Description()
7181   {
7182     DOMStringPtr nsUriPtr = new DOMString("libgno");
7183     XsdEvent event(nsUriPtr, NULL, DOMString("Description"), XsdEvent::ELEMENT_START, false);
7184     this->processEventThrow(event);
7185   }
7186
7187
7188
7189   //constructor
7190
7191   GenoPro::Families::Families(ElementCreateArgs args):
7192       XMLSchema::XmlElement<anyType>(args),
7193
7194     _fsmAttrs(NULL),
7195     _fsmElems(NULL)
7196
7197     , _sequence(new sequence(this) )
7198
7199   {
7200     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
7201     initFSM();
7202     if(args.ownerDoc && args.ownerDoc->buildTree())
7203     {
7204       if(args.ownerDoc->createSample()) {
7205         _fsm->fireSampleEvents();
7206       }
7207       else {
7208         _fsm->fireRequiredEvents();
7209       }
7210     }
7211   }
7212
7213   void GenoPro::Families::initFSM()
7214   {
7215     XsdFsmBasePtr fsmsAttrs[] = {
7216
7217       NULL
7218     };
7219
7220     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
7221
7222     _fsm->replaceContentFsm(_sequence);
7223
7224     _fsmAttrs = _fsm->attributeFsm();
7225     _fsmElems = _fsm->contentFsm();
7226
7227   }
7228
7229   /* element functions  */
7230
7231
7232   GenoPro::Families::Family_ptr GenoPro::Families::create_Family(FsmCbOptions& options)
7233   {
7234     static DOMStringPtr myName = new DOMString("Family");
7235     static DOMStringPtr myNsUri = new DOMString("libgno");
7236
7237     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
7238     GenoPro::Families::Family_p node = XSD::createElementTmpl<Family, void*>(t);
7239
7240     _list_Family.push_back(node);
7241
7242     return node;
7243   }
7244
7245
7246   GenoPro::Families::Family_p GenoPro::Families::element_Family_at(unsigned int idx)
7247   {
7248     if(idx > _list_Family.size()-1) {
7249       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
7250     }
7251
7252     return _list_Family.at(idx);
7253   }
7254
7255   List<GenoPro::Families::Family_ptr> GenoPro::Families::elements_Family()
7256   {
7257     return _list_Family;
7258   }
7259
7260   GenoPro::Families::Family_p GenoPro::Families::add_node_Family()
7261   {
7262     return get_sequence()->add_node_Family();
7263   }
7264
7265   List<GenoPro::Families::Family_ptr> GenoPro::Families::set_count_Family(unsigned int size)
7266   {
7267     return get_sequence()->set_count_Family(size);
7268   }
7269
7270
7271
7272   /* attribute  functions  */
7273
7274   //constructor
7275   GenoPro::Families::sequence::sequence(Families* that):
7276     _that(that)
7277   {
7278     XsdFsmBasePtr fsmArray[] = {
7279     new XsdFSM<Family_ptr>( Particle(new DOMString("libgno"), DOMString("Family"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Family_ptr, Families, FsmCbOptions>(_that, &Families::create_Family)),
7280
7281       NULL
7282     } ;
7283
7284     XsdSequenceFsmOfFSMs::init(fsmArray);
7285   }
7286
7287
7288
7289   List<GenoPro::Families::Family_ptr> GenoPro::Families::sequence::elements_Family()
7290   {
7291
7292     List<Family_ptr> nodeList;
7293     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
7294     if(fsm_p)
7295     {
7296       XsdFSM<Family_ptr> *unitFsm = dynamic_cast<XsdFSM<Family_ptr> *>(fsm_p);
7297       if(unitFsm) {
7298         //nodeList = unitFsm->nodeList().stl_list();
7299         nodeList = unitFsm->nodeList();
7300       }
7301     }
7302     return nodeList;
7303
7304   }
7305
7306
7307   GenoPro::Families::Family_p GenoPro::Families::sequence::element_Family_at(unsigned int idx)
7308   {
7309     return elements_Family().at(idx);
7310   }
7311
7312
7313   GenoPro::Families::Family_p GenoPro::Families::sequence::add_node_Family()
7314   {
7315     DOMStringPtr nsUriPtr = new DOMString("libgno");
7316     XsdEvent event(nsUriPtr, NULL, DOMString("Family"), XsdEvent::ELEMENT_START, false);
7317     this->processEventThrow(event);
7318     return elements_Family().back();
7319   }
7320
7321   List<GenoPro::Families::Family_ptr> GenoPro::Families::sequence::set_count_Family(unsigned int size)
7322   {
7323     if( (size > -1) || (size < 1)) {
7324       ostringstream oss;
7325       oss << "set_count_Family: size should be in range: [" << 1
7326         << "," << "unbounded" << "]";
7327       throw IndexOutOfBoundsException(oss.str());
7328     }
7329
7330     unsigned int prevSize = elements_Family().size();
7331     if(size < prevSize) {
7332       //FIXME: allow later:
7333       throw XPlus::RuntimeException("resize lesser than current size not allowed");
7334     }
7335
7336     for(unsigned int j=prevSize; j<size; j++)
7337     {
7338       // pretend docBuilding to avoid computation of adding after first loop
7339       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Family"), XsdEvent::ELEMENT_START, false);
7340       this->processEventThrow(event);
7341     }
7342
7343     return elements_Family();
7344   }
7345
7346
7347
7348   //constructor
7349
7350   GenoPro::Families::Family::Family(ElementCreateArgs args):
7351       XMLSchema::XmlElement<anyType>(args),
7352
7353     _fsmAttrs(NULL),
7354     _fsmElems(NULL)
7355
7356     , _sequence(new sequence(this) )
7357
7358   {
7359     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
7360     initFSM();
7361     if(args.ownerDoc && args.ownerDoc->buildTree())
7362     {
7363       if(args.ownerDoc->createSample()) {
7364         _fsm->fireSampleEvents();
7365       }
7366       else {
7367         _fsm->fireRequiredEvents();
7368       }
7369     }
7370   }
7371
7372   void GenoPro::Families::Family::initFSM()
7373   {
7374     XsdFsmBasePtr fsmsAttrs[] = {
7375   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Family, FsmCbOptions>(this, &Family::create_attr_ID)),
7376
7377       NULL
7378     };
7379
7380     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
7381
7382     _fsm->replaceContentFsm(_sequence);
7383
7384     _fsmAttrs = _fsm->attributeFsm();
7385     _fsmElems = _fsm->contentFsm();
7386
7387   }
7388
7389   /* element functions  */
7390
7391
7392   GenoPro::Families::Family::Position_ptr GenoPro::Families::Family::create_Position(FsmCbOptions& options)
7393   {
7394     static DOMStringPtr myName = new DOMString("Position");
7395     static DOMStringPtr myNsUri = new DOMString("libgno");
7396
7397     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
7398     GenoPro::Families::Family::Position_p node = XSD::createElementTmpl<Position, void*>(t);
7399
7400     _Position = node;
7401
7402     return node;
7403   }
7404
7405
7406   GenoPro::Families::Family::Position_p GenoPro::Families::Family::element_Position()
7407   {
7408     FSM::warnNullNode(_Position, "Position", "{}Position", 0);
7409     return _Position;
7410   }
7411
7412   void GenoPro::Families::Family::mark_present_Position()
7413   {
7414     return get_sequence()->mark_present_Position();
7415   }
7416
7417
7418   GenoPro::Families::Family::Relation_ptr GenoPro::Families::Family::create_Relation(FsmCbOptions& options)
7419   {
7420     static DOMStringPtr myName = new DOMString("Relation");
7421     static DOMStringPtr myNsUri = new DOMString("libgno");
7422
7423     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
7424     GenoPro::Families::Family::Relation_p node = XSD::createElementTmpl<Relation, XMLSchema::Types::bt_normalizedString*>(t);
7425
7426     if(options.isSampleCreate && (node->stringValue() == "") ) {
7427       node->stringValue(node->sampleValue());
7428     }
7429
7430     _Relation = node;
7431
7432     return node;
7433   }
7434
7435
7436   GenoPro::Families::Family::Relation_p GenoPro::Families::Family::element_Relation()
7437   {
7438     FSM::warnNullNode(_Relation, "Relation", "{http://www.w3.org/2001/XMLSchema}Relation", 0);
7439     return _Relation;
7440   }
7441
7442   void GenoPro::Families::Family::set_Relation(DOMString val)
7443   {
7444     get_sequence()->set_Relation(val);
7445   }
7446
7447   DOMString GenoPro::Families::Family::get_Relation_string()
7448   {
7449     return get_sequence()->get_Relation_string();
7450   }
7451
7452
7453   void GenoPro::Families::Family::mark_present_Relation()
7454   {
7455     return get_sequence()->mark_present_Relation();
7456   }
7457
7458
7459   /* attribute  functions  */
7460
7461
7462   GenoPro::Families::Family::attr_ID_ptr GenoPro::Families::Family::create_attr_ID(FsmCbOptions& options)
7463   {
7464     static DOMStringPtr myName = new DOMString("ID");
7465     static DOMStringPtr myNsUri = NULL;
7466
7467     if(_attr_ID) {
7468       return _attr_ID;
7469     }
7470     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
7471     GenoPro::Families::Family::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
7472
7473     if(options.isSampleCreate && (node->stringValue() == "") ) {
7474       node->stringValue(node->sampleValue());
7475     }
7476
7477     _attr_ID = node;
7478
7479     return node;
7480   }
7481
7482
7483     void GenoPro::Families::Family::set_attr_ID(DOMString val)
7484     {
7485
7486       attribute_attr_ID()->stringValue(val);
7487     }
7488
7489     DOMString GenoPro::Families::Family::get_attr_ID_string()
7490     {
7491
7492       return attribute_attr_ID()->stringValue();
7493     }
7494
7495
7496   GenoPro::Families::Family::attr_ID_p GenoPro::Families::Family::attribute_attr_ID()
7497   {
7498     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
7499     return _attr_ID;
7500   }
7501
7502   //constructor
7503   GenoPro::Families::Family::sequence::sequence(Family* that):
7504     _that(that)
7505   {
7506     XsdFsmBasePtr fsmArray[] = {
7507     new XsdFSM<Position_ptr>( Particle(new DOMString("libgno"), DOMString("Position"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Position_ptr, Family, FsmCbOptions>(_that, &Family::create_Position)),
7508       new XsdFSM<Relation_ptr>( Particle(new DOMString("libgno"), DOMString("Relation"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Relation_ptr, Family, FsmCbOptions>(_that, &Family::create_Relation)),
7509
7510       NULL
7511     } ;
7512
7513     XsdSequenceFsmOfFSMs::init(fsmArray);
7514   }
7515
7516
7517
7518   GenoPro::Families::Family::Position_p GenoPro::Families::Family::sequence::element_Position()
7519   {
7520       GenoPro::Families::Family::Position_p node_p = NULL;
7521     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
7522     if(fsm_p)
7523     {
7524       XsdFSM<Position_ptr> *unitFsm = dynamic_cast<XsdFSM<Position_ptr> *>(fsm_p);
7525       if(unitFsm && unitFsm->nodeList().size()>0) {
7526         assert(unitFsm->nodeList().size()==1);
7527         node_p = unitFsm->nodeList().at(0);
7528       }
7529     }
7530
7531     FSM::warnNullNode(node_p, "Position", "{}Position", 0);
7532     return node_p;
7533
7534   }
7535
7536
7537
7538   void GenoPro::Families::Family::sequence::mark_present_Position()
7539   {
7540     DOMStringPtr nsUriPtr = new DOMString("libgno");
7541     XsdEvent event(nsUriPtr, NULL, DOMString("Position"), XsdEvent::ELEMENT_START, false);
7542     this->processEventThrow(event);
7543   }
7544
7545
7546
7547   GenoPro::Families::Family::Relation_p GenoPro::Families::Family::sequence::element_Relation()
7548   {
7549       GenoPro::Families::Family::Relation_p node_p = NULL;
7550     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
7551     if(fsm_p)
7552     {
7553       XsdFSM<Relation_ptr> *unitFsm = dynamic_cast<XsdFSM<Relation_ptr> *>(fsm_p);
7554       if(unitFsm && unitFsm->nodeList().size()>0) {
7555         assert(unitFsm->nodeList().size()==1);
7556         node_p = unitFsm->nodeList().at(0);
7557       }
7558     }
7559
7560     FSM::warnNullNode(node_p, "Relation", "{http://www.w3.org/2001/XMLSchema}Relation", 0);
7561     return node_p;
7562
7563   }
7564
7565
7566   void GenoPro::Families::Family::sequence::set_Relation(DOMString val)
7567   {
7568
7569     mark_present_Relation();
7570
7571     element_Relation()->stringValue(val);
7572   }
7573
7574   DOMString GenoPro::Families::Family::sequence::get_Relation_string()
7575   {
7576     return element_Relation()->stringValue();
7577   }
7578
7579
7580
7581   void GenoPro::Families::Family::sequence::mark_present_Relation()
7582   {
7583     DOMStringPtr nsUriPtr = new DOMString("libgno");
7584     XsdEvent event(nsUriPtr, NULL, DOMString("Relation"), XsdEvent::ELEMENT_START, false);
7585     this->processEventThrow(event);
7586   }
7587
7588
7589
7590   //constructor
7591
7592   GenoPro::Families::Family::Position::Position(ElementCreateArgs args):
7593       XMLSchema::XmlElement<anyType>(args),
7594
7595     _fsmAttrs(NULL),
7596     _fsmElems(NULL)
7597
7598     , _sequence(new sequence(this) )
7599
7600   {
7601     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
7602     initFSM();
7603     if(args.ownerDoc && args.ownerDoc->buildTree())
7604     {
7605       if(args.ownerDoc->createSample()) {
7606         _fsm->fireSampleEvents();
7607       }
7608       else {
7609         _fsm->fireRequiredEvents();
7610       }
7611     }
7612   }
7613
7614   void GenoPro::Families::Family::Position::initFSM()
7615   {
7616     XsdFsmBasePtr fsmsAttrs[] = {
7617
7618       NULL
7619     };
7620
7621     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
7622
7623     _fsm->replaceContentFsm(_sequence);
7624
7625     _fsmAttrs = _fsm->attributeFsm();
7626     _fsmElems = _fsm->contentFsm();
7627
7628   }
7629
7630   /* element functions  */
7631
7632
7633   GenoPro::Families::Family::Position::Top_ptr GenoPro::Families::Family::Position::create_Top(FsmCbOptions& options)
7634   {
7635     static DOMStringPtr myName = new DOMString("Top");
7636     static DOMStringPtr myNsUri = new DOMString("libgno");
7637
7638     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
7639     GenoPro::Families::Family::Position::Top_p node = XSD::createElementTmpl<Top, void*>(t);
7640
7641     _Top = node;
7642
7643     return node;
7644   }
7645
7646
7647   GenoPro::Families::Family::Position::Top_p GenoPro::Families::Family::Position::element_Top()
7648   {
7649     FSM::warnNullNode(_Top, "Top", "{}Top", 0);
7650     return _Top;
7651   }
7652
7653   void GenoPro::Families::Family::Position::mark_present_Top()
7654   {
7655     return get_sequence()->mark_present_Top();
7656   }
7657
7658
7659   GenoPro::Families::Family::Position::Bottom_ptr GenoPro::Families::Family::Position::create_Bottom(FsmCbOptions& options)
7660   {
7661     static DOMStringPtr myName = new DOMString("Bottom");
7662     static DOMStringPtr myNsUri = new DOMString("libgno");
7663
7664     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
7665     GenoPro::Families::Family::Position::Bottom_p node = XSD::createElementTmpl<Bottom, void*>(t);
7666
7667     _Bottom = node;
7668
7669     return node;
7670   }
7671
7672
7673   GenoPro::Families::Family::Position::Bottom_p GenoPro::Families::Family::Position::element_Bottom()
7674   {
7675     FSM::warnNullNode(_Bottom, "Bottom", "{}Bottom", 0);
7676     return _Bottom;
7677   }
7678
7679   void GenoPro::Families::Family::Position::mark_present_Bottom()
7680   {
7681     return get_sequence()->mark_present_Bottom();
7682   }
7683
7684
7685   /* attribute  functions  */
7686
7687   //constructor
7688   GenoPro::Families::Family::Position::sequence::sequence(Position* that):
7689     _that(that)
7690   {
7691     XsdFsmBasePtr fsmArray[] = {
7692     new XsdFSM<Top_ptr>( Particle(new DOMString("libgno"), DOMString("Top"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Top_ptr, Position, FsmCbOptions>(_that, &Position::create_Top)),
7693       new XsdFSM<Bottom_ptr>( Particle(new DOMString("libgno"), DOMString("Bottom"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Bottom_ptr, Position, FsmCbOptions>(_that, &Position::create_Bottom)),
7694
7695       NULL
7696     } ;
7697
7698     XsdSequenceFsmOfFSMs::init(fsmArray);
7699   }
7700
7701
7702
7703   GenoPro::Families::Family::Position::Top_p GenoPro::Families::Family::Position::sequence::element_Top()
7704   {
7705       GenoPro::Families::Family::Position::Top_p node_p = NULL;
7706     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
7707     if(fsm_p)
7708     {
7709       XsdFSM<Top_ptr> *unitFsm = dynamic_cast<XsdFSM<Top_ptr> *>(fsm_p);
7710       if(unitFsm && unitFsm->nodeList().size()>0) {
7711         assert(unitFsm->nodeList().size()==1);
7712         node_p = unitFsm->nodeList().at(0);
7713       }
7714     }
7715
7716     FSM::warnNullNode(node_p, "Top", "{}Top", 0);
7717     return node_p;
7718
7719   }
7720
7721
7722
7723   void GenoPro::Families::Family::Position::sequence::mark_present_Top()
7724   {
7725     DOMStringPtr nsUriPtr = new DOMString("libgno");
7726     XsdEvent event(nsUriPtr, NULL, DOMString("Top"), XsdEvent::ELEMENT_START, false);
7727     this->processEventThrow(event);
7728   }
7729
7730
7731
7732   GenoPro::Families::Family::Position::Bottom_p GenoPro::Families::Family::Position::sequence::element_Bottom()
7733   {
7734       GenoPro::Families::Family::Position::Bottom_p node_p = NULL;
7735     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
7736     if(fsm_p)
7737     {
7738       XsdFSM<Bottom_ptr> *unitFsm = dynamic_cast<XsdFSM<Bottom_ptr> *>(fsm_p);
7739       if(unitFsm && unitFsm->nodeList().size()>0) {
7740         assert(unitFsm->nodeList().size()==1);
7741         node_p = unitFsm->nodeList().at(0);
7742       }
7743     }
7744
7745     FSM::warnNullNode(node_p, "Bottom", "{}Bottom", 0);
7746     return node_p;
7747
7748   }
7749
7750
7751
7752   void GenoPro::Families::Family::Position::sequence::mark_present_Bottom()
7753   {
7754     DOMStringPtr nsUriPtr = new DOMString("libgno");
7755     XsdEvent event(nsUriPtr, NULL, DOMString("Bottom"), XsdEvent::ELEMENT_START, false);
7756     this->processEventThrow(event);
7757   }
7758
7759
7760
7761   //constructor
7762
7763   GenoPro::Families::Family::Position::Top::Top(ElementCreateArgs args):
7764       XMLSchema::XmlElement<anyType>(args),
7765
7766     _fsmAttrs(NULL),
7767     _fsmElems(NULL)
7768
7769     , _sequence(new sequence(this) )
7770
7771   {
7772     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
7773     initFSM();
7774     if(args.ownerDoc && args.ownerDoc->buildTree())
7775     {
7776       if(args.ownerDoc->createSample()) {
7777         _fsm->fireSampleEvents();
7778       }
7779       else {
7780         _fsm->fireRequiredEvents();
7781       }
7782     }
7783   }
7784
7785   void GenoPro::Families::Family::Position::Top::initFSM()
7786   {
7787     XsdFsmBasePtr fsmsAttrs[] = {
7788
7789       NULL
7790     };
7791
7792     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
7793
7794     _fsm->replaceContentFsm(_sequence);
7795
7796     _fsmAttrs = _fsm->attributeFsm();
7797     _fsmElems = _fsm->contentFsm();
7798
7799   }
7800
7801   /* element functions  */
7802
7803
7804   GenoPro::Families::Family::Position::Top::Left_ptr GenoPro::Families::Family::Position::Top::create_Left(FsmCbOptions& options)
7805   {
7806     static DOMStringPtr myName = new DOMString("Left");
7807     static DOMStringPtr myNsUri = new DOMString("libgno");
7808
7809     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
7810     GenoPro::Families::Family::Position::Top::Left_p node = XSD::createElementTmpl<Left, XMLSchema::Types::bt_normalizedString*>(t);
7811
7812     if(options.isSampleCreate && (node->stringValue() == "") ) {
7813       node->stringValue(node->sampleValue());
7814     }
7815
7816     _Left = node;
7817
7818     return node;
7819   }
7820
7821
7822   GenoPro::Families::Family::Position::Top::Left_p GenoPro::Families::Family::Position::Top::element_Left()
7823   {
7824     FSM::warnNullNode(_Left, "Left", "{http://www.w3.org/2001/XMLSchema}Left", 0);
7825     return _Left;
7826   }
7827
7828   void GenoPro::Families::Family::Position::Top::set_Left(DOMString val)
7829   {
7830     get_sequence()->set_Left(val);
7831   }
7832
7833   DOMString GenoPro::Families::Family::Position::Top::get_Left_string()
7834   {
7835     return get_sequence()->get_Left_string();
7836   }
7837
7838
7839   void GenoPro::Families::Family::Position::Top::mark_present_Left()
7840   {
7841     return get_sequence()->mark_present_Left();
7842   }
7843
7844
7845   GenoPro::Families::Family::Position::Top::Right_ptr GenoPro::Families::Family::Position::Top::create_Right(FsmCbOptions& options)
7846   {
7847     static DOMStringPtr myName = new DOMString("Right");
7848     static DOMStringPtr myNsUri = new DOMString("libgno");
7849
7850     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
7851     GenoPro::Families::Family::Position::Top::Right_p node = XSD::createElementTmpl<Right, XMLSchema::Types::bt_normalizedString*>(t);
7852
7853     if(options.isSampleCreate && (node->stringValue() == "") ) {
7854       node->stringValue(node->sampleValue());
7855     }
7856
7857     _Right = node;
7858
7859     return node;
7860   }
7861
7862
7863   GenoPro::Families::Family::Position::Top::Right_p GenoPro::Families::Family::Position::Top::element_Right()
7864   {
7865     FSM::warnNullNode(_Right, "Right", "{http://www.w3.org/2001/XMLSchema}Right", 0);
7866     return _Right;
7867   }
7868
7869   void GenoPro::Families::Family::Position::Top::set_Right(DOMString val)
7870   {
7871     get_sequence()->set_Right(val);
7872   }
7873
7874   DOMString GenoPro::Families::Family::Position::Top::get_Right_string()
7875   {
7876     return get_sequence()->get_Right_string();
7877   }
7878
7879
7880   void GenoPro::Families::Family::Position::Top::mark_present_Right()
7881   {
7882     return get_sequence()->mark_present_Right();
7883   }
7884
7885
7886   /* attribute  functions  */
7887
7888   //constructor
7889   GenoPro::Families::Family::Position::Top::sequence::sequence(Top* that):
7890     _that(that)
7891   {
7892     XsdFsmBasePtr fsmArray[] = {
7893     new XsdFSM<Left_ptr>( Particle(new DOMString("libgno"), DOMString("Left"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Left_ptr, Top, FsmCbOptions>(_that, &Top::create_Left)),
7894       new XsdFSM<Right_ptr>( Particle(new DOMString("libgno"), DOMString("Right"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Right_ptr, Top, FsmCbOptions>(_that, &Top::create_Right)),
7895
7896       NULL
7897     } ;
7898
7899     XsdSequenceFsmOfFSMs::init(fsmArray);
7900   }
7901
7902
7903
7904   GenoPro::Families::Family::Position::Top::Left_p GenoPro::Families::Family::Position::Top::sequence::element_Left()
7905   {
7906       GenoPro::Families::Family::Position::Top::Left_p node_p = NULL;
7907     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
7908     if(fsm_p)
7909     {
7910       XsdFSM<Left_ptr> *unitFsm = dynamic_cast<XsdFSM<Left_ptr> *>(fsm_p);
7911       if(unitFsm && unitFsm->nodeList().size()>0) {
7912         assert(unitFsm->nodeList().size()==1);
7913         node_p = unitFsm->nodeList().at(0);
7914       }
7915     }
7916
7917     FSM::warnNullNode(node_p, "Left", "{http://www.w3.org/2001/XMLSchema}Left", 0);
7918     return node_p;
7919
7920   }
7921
7922
7923   void GenoPro::Families::Family::Position::Top::sequence::set_Left(DOMString val)
7924   {
7925
7926     mark_present_Left();
7927
7928     element_Left()->stringValue(val);
7929   }
7930
7931   DOMString GenoPro::Families::Family::Position::Top::sequence::get_Left_string()
7932   {
7933     return element_Left()->stringValue();
7934   }
7935
7936
7937
7938   void GenoPro::Families::Family::Position::Top::sequence::mark_present_Left()
7939   {
7940     DOMStringPtr nsUriPtr = new DOMString("libgno");
7941     XsdEvent event(nsUriPtr, NULL, DOMString("Left"), XsdEvent::ELEMENT_START, false);
7942     this->processEventThrow(event);
7943   }
7944
7945
7946
7947   GenoPro::Families::Family::Position::Top::Right_p GenoPro::Families::Family::Position::Top::sequence::element_Right()
7948   {
7949       GenoPro::Families::Family::Position::Top::Right_p node_p = NULL;
7950     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
7951     if(fsm_p)
7952     {
7953       XsdFSM<Right_ptr> *unitFsm = dynamic_cast<XsdFSM<Right_ptr> *>(fsm_p);
7954       if(unitFsm && unitFsm->nodeList().size()>0) {
7955         assert(unitFsm->nodeList().size()==1);
7956         node_p = unitFsm->nodeList().at(0);
7957       }
7958     }
7959
7960     FSM::warnNullNode(node_p, "Right", "{http://www.w3.org/2001/XMLSchema}Right", 0);
7961     return node_p;
7962
7963   }
7964
7965
7966   void GenoPro::Families::Family::Position::Top::sequence::set_Right(DOMString val)
7967   {
7968
7969     mark_present_Right();
7970
7971     element_Right()->stringValue(val);
7972   }
7973
7974   DOMString GenoPro::Families::Family::Position::Top::sequence::get_Right_string()
7975   {
7976     return element_Right()->stringValue();
7977   }
7978
7979
7980
7981   void GenoPro::Families::Family::Position::Top::sequence::mark_present_Right()
7982   {
7983     DOMStringPtr nsUriPtr = new DOMString("libgno");
7984     XsdEvent event(nsUriPtr, NULL, DOMString("Right"), XsdEvent::ELEMENT_START, false);
7985     this->processEventThrow(event);
7986   }
7987
7988
7989
7990   //constructor
7991
7992   GenoPro::Families::Family::Position::Bottom::Bottom(ElementCreateArgs args):
7993       XMLSchema::XmlElement<anyType>(args),
7994
7995     _fsmAttrs(NULL),
7996     _fsmElems(NULL)
7997
7998     , _sequence(new sequence(this) )
7999
8000   {
8001     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
8002     initFSM();
8003     if(args.ownerDoc && args.ownerDoc->buildTree())
8004     {
8005       if(args.ownerDoc->createSample()) {
8006         _fsm->fireSampleEvents();
8007       }
8008       else {
8009         _fsm->fireRequiredEvents();
8010       }
8011     }
8012   }
8013
8014   void GenoPro::Families::Family::Position::Bottom::initFSM()
8015   {
8016     XsdFsmBasePtr fsmsAttrs[] = {
8017
8018       NULL
8019     };
8020
8021     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
8022
8023     _fsm->replaceContentFsm(_sequence);
8024
8025     _fsmAttrs = _fsm->attributeFsm();
8026     _fsmElems = _fsm->contentFsm();
8027
8028   }
8029
8030   /* element functions  */
8031
8032
8033   GenoPro::Families::Family::Position::Bottom::Left_ptr GenoPro::Families::Family::Position::Bottom::create_Left(FsmCbOptions& options)
8034   {
8035     static DOMStringPtr myName = new DOMString("Left");
8036     static DOMStringPtr myNsUri = new DOMString("libgno");
8037
8038     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
8039     GenoPro::Families::Family::Position::Bottom::Left_p node = XSD::createElementTmpl<Left, XMLSchema::Types::bt_normalizedString*>(t);
8040
8041     if(options.isSampleCreate && (node->stringValue() == "") ) {
8042       node->stringValue(node->sampleValue());
8043     }
8044
8045     _Left = node;
8046
8047     return node;
8048   }
8049
8050
8051   GenoPro::Families::Family::Position::Bottom::Left_p GenoPro::Families::Family::Position::Bottom::element_Left()
8052   {
8053     FSM::warnNullNode(_Left, "Left", "{http://www.w3.org/2001/XMLSchema}Left", 0);
8054     return _Left;
8055   }
8056
8057   void GenoPro::Families::Family::Position::Bottom::set_Left(DOMString val)
8058   {
8059     get_sequence()->set_Left(val);
8060   }
8061
8062   DOMString GenoPro::Families::Family::Position::Bottom::get_Left_string()
8063   {
8064     return get_sequence()->get_Left_string();
8065   }
8066
8067
8068   void GenoPro::Families::Family::Position::Bottom::mark_present_Left()
8069   {
8070     return get_sequence()->mark_present_Left();
8071   }
8072
8073
8074   GenoPro::Families::Family::Position::Bottom::Right_ptr GenoPro::Families::Family::Position::Bottom::create_Right(FsmCbOptions& options)
8075   {
8076     static DOMStringPtr myName = new DOMString("Right");
8077     static DOMStringPtr myNsUri = new DOMString("libgno");
8078
8079     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
8080     GenoPro::Families::Family::Position::Bottom::Right_p node = XSD::createElementTmpl<Right, XMLSchema::Types::bt_normalizedString*>(t);
8081
8082     if(options.isSampleCreate && (node->stringValue() == "") ) {
8083       node->stringValue(node->sampleValue());
8084     }
8085
8086     _Right = node;
8087
8088     return node;
8089   }
8090
8091
8092   GenoPro::Families::Family::Position::Bottom::Right_p GenoPro::Families::Family::Position::Bottom::element_Right()
8093   {
8094     FSM::warnNullNode(_Right, "Right", "{http://www.w3.org/2001/XMLSchema}Right", 0);
8095     return _Right;
8096   }
8097
8098   void GenoPro::Families::Family::Position::Bottom::set_Right(DOMString val)
8099   {
8100     get_sequence()->set_Right(val);
8101   }
8102
8103   DOMString GenoPro::Families::Family::Position::Bottom::get_Right_string()
8104   {
8105     return get_sequence()->get_Right_string();
8106   }
8107
8108
8109   void GenoPro::Families::Family::Position::Bottom::mark_present_Right()
8110   {
8111     return get_sequence()->mark_present_Right();
8112   }
8113
8114
8115   /* attribute  functions  */
8116
8117   //constructor
8118   GenoPro::Families::Family::Position::Bottom::sequence::sequence(Bottom* that):
8119     _that(that)
8120   {
8121     XsdFsmBasePtr fsmArray[] = {
8122     new XsdFSM<Left_ptr>( Particle(new DOMString("libgno"), DOMString("Left"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Left_ptr, Bottom, FsmCbOptions>(_that, &Bottom::create_Left)),
8123       new XsdFSM<Right_ptr>( Particle(new DOMString("libgno"), DOMString("Right"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Right_ptr, Bottom, FsmCbOptions>(_that, &Bottom::create_Right)),
8124
8125       NULL
8126     } ;
8127
8128     XsdSequenceFsmOfFSMs::init(fsmArray);
8129   }
8130
8131
8132
8133   GenoPro::Families::Family::Position::Bottom::Left_p GenoPro::Families::Family::Position::Bottom::sequence::element_Left()
8134   {
8135       GenoPro::Families::Family::Position::Bottom::Left_p node_p = NULL;
8136     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
8137     if(fsm_p)
8138     {
8139       XsdFSM<Left_ptr> *unitFsm = dynamic_cast<XsdFSM<Left_ptr> *>(fsm_p);
8140       if(unitFsm && unitFsm->nodeList().size()>0) {
8141         assert(unitFsm->nodeList().size()==1);
8142         node_p = unitFsm->nodeList().at(0);
8143       }
8144     }
8145
8146     FSM::warnNullNode(node_p, "Left", "{http://www.w3.org/2001/XMLSchema}Left", 0);
8147     return node_p;
8148
8149   }
8150
8151
8152   void GenoPro::Families::Family::Position::Bottom::sequence::set_Left(DOMString val)
8153   {
8154
8155     mark_present_Left();
8156
8157     element_Left()->stringValue(val);
8158   }
8159
8160   DOMString GenoPro::Families::Family::Position::Bottom::sequence::get_Left_string()
8161   {
8162     return element_Left()->stringValue();
8163   }
8164
8165
8166
8167   void GenoPro::Families::Family::Position::Bottom::sequence::mark_present_Left()
8168   {
8169     DOMStringPtr nsUriPtr = new DOMString("libgno");
8170     XsdEvent event(nsUriPtr, NULL, DOMString("Left"), XsdEvent::ELEMENT_START, false);
8171     this->processEventThrow(event);
8172   }
8173
8174
8175
8176   GenoPro::Families::Family::Position::Bottom::Right_p GenoPro::Families::Family::Position::Bottom::sequence::element_Right()
8177   {
8178       GenoPro::Families::Family::Position::Bottom::Right_p node_p = NULL;
8179     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
8180     if(fsm_p)
8181     {
8182       XsdFSM<Right_ptr> *unitFsm = dynamic_cast<XsdFSM<Right_ptr> *>(fsm_p);
8183       if(unitFsm && unitFsm->nodeList().size()>0) {
8184         assert(unitFsm->nodeList().size()==1);
8185         node_p = unitFsm->nodeList().at(0);
8186       }
8187     }
8188
8189     FSM::warnNullNode(node_p, "Right", "{http://www.w3.org/2001/XMLSchema}Right", 0);
8190     return node_p;
8191
8192   }
8193
8194
8195   void GenoPro::Families::Family::Position::Bottom::sequence::set_Right(DOMString val)
8196   {
8197
8198     mark_present_Right();
8199
8200     element_Right()->stringValue(val);
8201   }
8202
8203   DOMString GenoPro::Families::Family::Position::Bottom::sequence::get_Right_string()
8204   {
8205     return element_Right()->stringValue();
8206   }
8207
8208
8209
8210   void GenoPro::Families::Family::Position::Bottom::sequence::mark_present_Right()
8211   {
8212     DOMStringPtr nsUriPtr = new DOMString("libgno");
8213     XsdEvent event(nsUriPtr, NULL, DOMString("Right"), XsdEvent::ELEMENT_START, false);
8214     this->processEventThrow(event);
8215   }
8216
8217
8218
8219   //constructor
8220
8221   GenoPro::Marriages::Marriages(ElementCreateArgs args):
8222       XMLSchema::XmlElement<anyType>(args),
8223
8224     _fsmAttrs(NULL),
8225     _fsmElems(NULL)
8226
8227     , _sequence(new sequence(this) )
8228
8229   {
8230     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
8231     initFSM();
8232     if(args.ownerDoc && args.ownerDoc->buildTree())
8233     {
8234       if(args.ownerDoc->createSample()) {
8235         _fsm->fireSampleEvents();
8236       }
8237       else {
8238         _fsm->fireRequiredEvents();
8239       }
8240     }
8241   }
8242
8243   void GenoPro::Marriages::initFSM()
8244   {
8245     XsdFsmBasePtr fsmsAttrs[] = {
8246
8247       NULL
8248     };
8249
8250     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
8251
8252     _fsm->replaceContentFsm(_sequence);
8253
8254     _fsmAttrs = _fsm->attributeFsm();
8255     _fsmElems = _fsm->contentFsm();
8256
8257   }
8258
8259   /* element functions  */
8260
8261
8262   GenoPro::Marriages::Marriage_ptr GenoPro::Marriages::create_Marriage(FsmCbOptions& options)
8263   {
8264     static DOMStringPtr myName = new DOMString("Marriage");
8265     static DOMStringPtr myNsUri = new DOMString("libgno");
8266
8267     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
8268     GenoPro::Marriages::Marriage_p node = XSD::createElementTmpl<Marriage, void*>(t);
8269
8270     _list_Marriage.push_back(node);
8271
8272     return node;
8273   }
8274
8275
8276   GenoPro::Marriages::Marriage_p GenoPro::Marriages::element_Marriage_at(unsigned int idx)
8277   {
8278     if(idx > _list_Marriage.size()-1) {
8279       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
8280     }
8281
8282     return _list_Marriage.at(idx);
8283   }
8284
8285   List<GenoPro::Marriages::Marriage_ptr> GenoPro::Marriages::elements_Marriage()
8286   {
8287     return _list_Marriage;
8288   }
8289
8290   GenoPro::Marriages::Marriage_p GenoPro::Marriages::add_node_Marriage()
8291   {
8292     return get_sequence()->add_node_Marriage();
8293   }
8294
8295   List<GenoPro::Marriages::Marriage_ptr> GenoPro::Marriages::set_count_Marriage(unsigned int size)
8296   {
8297     return get_sequence()->set_count_Marriage(size);
8298   }
8299
8300
8301
8302   /* attribute  functions  */
8303
8304   //constructor
8305   GenoPro::Marriages::sequence::sequence(Marriages* that):
8306     _that(that)
8307   {
8308     XsdFsmBasePtr fsmArray[] = {
8309     new XsdFSM<Marriage_ptr>( Particle(new DOMString("libgno"), DOMString("Marriage"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Marriage_ptr, Marriages, FsmCbOptions>(_that, &Marriages::create_Marriage)),
8310
8311       NULL
8312     } ;
8313
8314     XsdSequenceFsmOfFSMs::init(fsmArray);
8315   }
8316
8317
8318
8319   List<GenoPro::Marriages::Marriage_ptr> GenoPro::Marriages::sequence::elements_Marriage()
8320   {
8321
8322     List<Marriage_ptr> nodeList;
8323     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
8324     if(fsm_p)
8325     {
8326       XsdFSM<Marriage_ptr> *unitFsm = dynamic_cast<XsdFSM<Marriage_ptr> *>(fsm_p);
8327       if(unitFsm) {
8328         //nodeList = unitFsm->nodeList().stl_list();
8329         nodeList = unitFsm->nodeList();
8330       }
8331     }
8332     return nodeList;
8333
8334   }
8335
8336
8337   GenoPro::Marriages::Marriage_p GenoPro::Marriages::sequence::element_Marriage_at(unsigned int idx)
8338   {
8339     return elements_Marriage().at(idx);
8340   }
8341
8342
8343   GenoPro::Marriages::Marriage_p GenoPro::Marriages::sequence::add_node_Marriage()
8344   {
8345     DOMStringPtr nsUriPtr = new DOMString("libgno");
8346     XsdEvent event(nsUriPtr, NULL, DOMString("Marriage"), XsdEvent::ELEMENT_START, false);
8347     this->processEventThrow(event);
8348     return elements_Marriage().back();
8349   }
8350
8351   List<GenoPro::Marriages::Marriage_ptr> GenoPro::Marriages::sequence::set_count_Marriage(unsigned int size)
8352   {
8353     if( (size > -1) || (size < 1)) {
8354       ostringstream oss;
8355       oss << "set_count_Marriage: size should be in range: [" << 1
8356         << "," << "unbounded" << "]";
8357       throw IndexOutOfBoundsException(oss.str());
8358     }
8359
8360     unsigned int prevSize = elements_Marriage().size();
8361     if(size < prevSize) {
8362       //FIXME: allow later:
8363       throw XPlus::RuntimeException("resize lesser than current size not allowed");
8364     }
8365
8366     for(unsigned int j=prevSize; j<size; j++)
8367     {
8368       // pretend docBuilding to avoid computation of adding after first loop
8369       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Marriage"), XsdEvent::ELEMENT_START, false);
8370       this->processEventThrow(event);
8371     }
8372
8373     return elements_Marriage();
8374   }
8375
8376
8377
8378   //constructor
8379
8380   GenoPro::Marriages::Marriage::Marriage(ElementCreateArgs args):
8381       XMLSchema::XmlElement<anyType>(args),
8382
8383     _fsmAttrs(NULL),
8384     _fsmElems(NULL)
8385
8386     , _sequence(new sequence(this) )
8387
8388   {
8389     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
8390     initFSM();
8391     if(args.ownerDoc && args.ownerDoc->buildTree())
8392     {
8393       if(args.ownerDoc->createSample()) {
8394         _fsm->fireSampleEvents();
8395       }
8396       else {
8397         _fsm->fireRequiredEvents();
8398       }
8399     }
8400   }
8401
8402   void GenoPro::Marriages::Marriage::initFSM()
8403   {
8404     XsdFsmBasePtr fsmsAttrs[] = {
8405   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Marriage, FsmCbOptions>(this, &Marriage::create_attr_ID)),
8406
8407       NULL
8408     };
8409
8410     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
8411
8412     _fsm->replaceContentFsm(_sequence);
8413
8414     _fsmAttrs = _fsm->attributeFsm();
8415     _fsmElems = _fsm->contentFsm();
8416
8417   }
8418
8419   /* element functions  */
8420
8421
8422   GenoPro::Marriages::Marriage::Type_ptr GenoPro::Marriages::Marriage::create_Type(FsmCbOptions& options)
8423   {
8424     static DOMStringPtr myName = new DOMString("Type");
8425     static DOMStringPtr myNsUri = new DOMString("libgno");
8426
8427     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
8428     GenoPro::Marriages::Marriage::Type_p node = XSD::createElementTmpl<Type, XMLSchema::Types::bt_normalizedString*>(t);
8429
8430     if(options.isSampleCreate && (node->stringValue() == "") ) {
8431       node->stringValue(node->sampleValue());
8432     }
8433
8434     _Type = node;
8435
8436     return node;
8437   }
8438
8439
8440   GenoPro::Marriages::Marriage::Type_p GenoPro::Marriages::Marriage::element_Type()
8441   {
8442     FSM::warnNullNode(_Type, "Type", "{http://www.w3.org/2001/XMLSchema}Type", 0);
8443     return _Type;
8444   }
8445
8446   void GenoPro::Marriages::Marriage::set_Type(DOMString val)
8447   {
8448     get_sequence()->set_Type(val);
8449   }
8450
8451   DOMString GenoPro::Marriages::Marriage::get_Type_string()
8452   {
8453     return get_sequence()->get_Type_string();
8454   }
8455
8456
8457   void GenoPro::Marriages::Marriage::mark_present_Type()
8458   {
8459     return get_sequence()->mark_present_Type();
8460   }
8461
8462
8463   GenoPro::Marriages::Marriage::Date_ptr GenoPro::Marriages::Marriage::create_Date(FsmCbOptions& options)
8464   {
8465     static DOMStringPtr myName = new DOMString("Date");
8466     static DOMStringPtr myNsUri = new DOMString("libgno");
8467
8468     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
8469     GenoPro::Marriages::Marriage::Date_p node = XSD::createElementTmpl<Date, XMLSchema::Types::bt_string*>(t);
8470
8471     if(options.isSampleCreate && (node->stringValue() == "") ) {
8472       node->stringValue(node->sampleValue());
8473     }
8474
8475     _Date = node;
8476
8477     return node;
8478   }
8479
8480
8481   GenoPro::Marriages::Marriage::Date_p GenoPro::Marriages::Marriage::element_Date()
8482   {
8483     FSM::warnNullNode(_Date, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
8484     return _Date;
8485   }
8486
8487   void GenoPro::Marriages::Marriage::set_Date(DOMString val)
8488   {
8489     get_sequence()->set_Date(val);
8490   }
8491
8492   DOMString GenoPro::Marriages::Marriage::get_Date_string()
8493   {
8494     return get_sequence()->get_Date_string();
8495   }
8496
8497
8498   void GenoPro::Marriages::Marriage::mark_present_Date()
8499   {
8500     return get_sequence()->mark_present_Date();
8501   }
8502
8503
8504   GenoPro::Marriages::Marriage::Place_ptr GenoPro::Marriages::Marriage::create_Place(FsmCbOptions& options)
8505   {
8506     static DOMStringPtr myName = new DOMString("Place");
8507     static DOMStringPtr myNsUri = new DOMString("libgno");
8508
8509     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
8510     GenoPro::Marriages::Marriage::Place_p node = XSD::createElementTmpl<Place, XMLSchema::Types::bt_normalizedString*>(t);
8511
8512     if(options.isSampleCreate && (node->stringValue() == "") ) {
8513       node->stringValue(node->sampleValue());
8514     }
8515
8516     _Place = node;
8517
8518     return node;
8519   }
8520
8521
8522   GenoPro::Marriages::Marriage::Place_p GenoPro::Marriages::Marriage::element_Place()
8523   {
8524     FSM::warnNullNode(_Place, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
8525     return _Place;
8526   }
8527
8528   void GenoPro::Marriages::Marriage::set_Place(DOMString val)
8529   {
8530     get_sequence()->set_Place(val);
8531   }
8532
8533   DOMString GenoPro::Marriages::Marriage::get_Place_string()
8534   {
8535     return get_sequence()->get_Place_string();
8536   }
8537
8538
8539   void GenoPro::Marriages::Marriage::mark_present_Place()
8540   {
8541     return get_sequence()->mark_present_Place();
8542   }
8543
8544
8545   GenoPro::Marriages::Marriage::Witnesses_ptr GenoPro::Marriages::Marriage::create_Witnesses(FsmCbOptions& options)
8546   {
8547     static DOMStringPtr myName = new DOMString("Witnesses");
8548     static DOMStringPtr myNsUri = new DOMString("libgno");
8549
8550     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
8551     GenoPro::Marriages::Marriage::Witnesses_p node = XSD::createElementTmpl<Witnesses, XMLSchema::Types::bt_string*>(t);
8552
8553     if(options.isSampleCreate && (node->stringValue() == "") ) {
8554       node->stringValue(node->sampleValue());
8555     }
8556
8557     _Witnesses = node;
8558
8559     return node;
8560   }
8561
8562
8563   GenoPro::Marriages::Marriage::Witnesses_p GenoPro::Marriages::Marriage::element_Witnesses()
8564   {
8565     FSM::warnNullNode(_Witnesses, "Witnesses", "{http://www.w3.org/2001/XMLSchema}Witnesses", 0);
8566     return _Witnesses;
8567   }
8568
8569   void GenoPro::Marriages::Marriage::set_Witnesses(DOMString val)
8570   {
8571     get_sequence()->set_Witnesses(val);
8572   }
8573
8574   DOMString GenoPro::Marriages::Marriage::get_Witnesses_string()
8575   {
8576     return get_sequence()->get_Witnesses_string();
8577   }
8578
8579
8580   void GenoPro::Marriages::Marriage::mark_present_Witnesses()
8581   {
8582     return get_sequence()->mark_present_Witnesses();
8583   }
8584
8585
8586   /* attribute  functions  */
8587
8588
8589   GenoPro::Marriages::Marriage::attr_ID_ptr GenoPro::Marriages::Marriage::create_attr_ID(FsmCbOptions& options)
8590   {
8591     static DOMStringPtr myName = new DOMString("ID");
8592     static DOMStringPtr myNsUri = NULL;
8593
8594     if(_attr_ID) {
8595       return _attr_ID;
8596     }
8597     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
8598     GenoPro::Marriages::Marriage::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
8599
8600     if(options.isSampleCreate && (node->stringValue() == "") ) {
8601       node->stringValue(node->sampleValue());
8602     }
8603
8604     _attr_ID = node;
8605
8606     return node;
8607   }
8608
8609
8610     void GenoPro::Marriages::Marriage::set_attr_ID(DOMString val)
8611     {
8612
8613       attribute_attr_ID()->stringValue(val);
8614     }
8615
8616     DOMString GenoPro::Marriages::Marriage::get_attr_ID_string()
8617     {
8618
8619       return attribute_attr_ID()->stringValue();
8620     }
8621
8622
8623   GenoPro::Marriages::Marriage::attr_ID_p GenoPro::Marriages::Marriage::attribute_attr_ID()
8624   {
8625     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
8626     return _attr_ID;
8627   }
8628
8629   //constructor
8630   GenoPro::Marriages::Marriage::sequence::sequence(Marriage* that):
8631     _that(that)
8632   {
8633     XsdFsmBasePtr fsmArray[] = {
8634     new XsdFSM<Type_ptr>( Particle(new DOMString("libgno"), DOMString("Type"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Type_ptr, Marriage, FsmCbOptions>(_that, &Marriage::create_Type)),
8635       new XsdFSM<Date_ptr>( Particle(new DOMString("libgno"), DOMString("Date"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Date_ptr, Marriage, FsmCbOptions>(_that, &Marriage::create_Date)),
8636       new XsdFSM<Place_ptr>( Particle(new DOMString("libgno"), DOMString("Place"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Place_ptr, Marriage, FsmCbOptions>(_that, &Marriage::create_Place)),
8637       new XsdFSM<Witnesses_ptr>( Particle(new DOMString("libgno"), DOMString("Witnesses"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Witnesses_ptr, Marriage, FsmCbOptions>(_that, &Marriage::create_Witnesses)),
8638
8639       NULL
8640     } ;
8641
8642     XsdSequenceFsmOfFSMs::init(fsmArray);
8643   }
8644
8645
8646
8647   GenoPro::Marriages::Marriage::Type_p GenoPro::Marriages::Marriage::sequence::element_Type()
8648   {
8649       GenoPro::Marriages::Marriage::Type_p node_p = NULL;
8650     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
8651     if(fsm_p)
8652     {
8653       XsdFSM<Type_ptr> *unitFsm = dynamic_cast<XsdFSM<Type_ptr> *>(fsm_p);
8654       if(unitFsm && unitFsm->nodeList().size()>0) {
8655         assert(unitFsm->nodeList().size()==1);
8656         node_p = unitFsm->nodeList().at(0);
8657       }
8658     }
8659
8660     FSM::warnNullNode(node_p, "Type", "{http://www.w3.org/2001/XMLSchema}Type", 0);
8661     return node_p;
8662
8663   }
8664
8665
8666   void GenoPro::Marriages::Marriage::sequence::set_Type(DOMString val)
8667   {
8668
8669     mark_present_Type();
8670
8671     element_Type()->stringValue(val);
8672   }
8673
8674   DOMString GenoPro::Marriages::Marriage::sequence::get_Type_string()
8675   {
8676     return element_Type()->stringValue();
8677   }
8678
8679
8680
8681   void GenoPro::Marriages::Marriage::sequence::mark_present_Type()
8682   {
8683     DOMStringPtr nsUriPtr = new DOMString("libgno");
8684     XsdEvent event(nsUriPtr, NULL, DOMString("Type"), XsdEvent::ELEMENT_START, false);
8685     this->processEventThrow(event);
8686   }
8687
8688
8689
8690   GenoPro::Marriages::Marriage::Date_p GenoPro::Marriages::Marriage::sequence::element_Date()
8691   {
8692       GenoPro::Marriages::Marriage::Date_p node_p = NULL;
8693     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
8694     if(fsm_p)
8695     {
8696       XsdFSM<Date_ptr> *unitFsm = dynamic_cast<XsdFSM<Date_ptr> *>(fsm_p);
8697       if(unitFsm && unitFsm->nodeList().size()>0) {
8698         assert(unitFsm->nodeList().size()==1);
8699         node_p = unitFsm->nodeList().at(0);
8700       }
8701     }
8702
8703     FSM::warnNullNode(node_p, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
8704     return node_p;
8705
8706   }
8707
8708
8709   void GenoPro::Marriages::Marriage::sequence::set_Date(DOMString val)
8710   {
8711
8712     mark_present_Date();
8713
8714     element_Date()->stringValue(val);
8715   }
8716
8717   DOMString GenoPro::Marriages::Marriage::sequence::get_Date_string()
8718   {
8719     return element_Date()->stringValue();
8720   }
8721
8722
8723
8724   void GenoPro::Marriages::Marriage::sequence::mark_present_Date()
8725   {
8726     DOMStringPtr nsUriPtr = new DOMString("libgno");
8727     XsdEvent event(nsUriPtr, NULL, DOMString("Date"), XsdEvent::ELEMENT_START, false);
8728     this->processEventThrow(event);
8729   }
8730
8731
8732
8733   GenoPro::Marriages::Marriage::Place_p GenoPro::Marriages::Marriage::sequence::element_Place()
8734   {
8735       GenoPro::Marriages::Marriage::Place_p node_p = NULL;
8736     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
8737     if(fsm_p)
8738     {
8739       XsdFSM<Place_ptr> *unitFsm = dynamic_cast<XsdFSM<Place_ptr> *>(fsm_p);
8740       if(unitFsm && unitFsm->nodeList().size()>0) {
8741         assert(unitFsm->nodeList().size()==1);
8742         node_p = unitFsm->nodeList().at(0);
8743       }
8744     }
8745
8746     FSM::warnNullNode(node_p, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
8747     return node_p;
8748
8749   }
8750
8751
8752   void GenoPro::Marriages::Marriage::sequence::set_Place(DOMString val)
8753   {
8754
8755     mark_present_Place();
8756
8757     element_Place()->stringValue(val);
8758   }
8759
8760   DOMString GenoPro::Marriages::Marriage::sequence::get_Place_string()
8761   {
8762     return element_Place()->stringValue();
8763   }
8764
8765
8766
8767   void GenoPro::Marriages::Marriage::sequence::mark_present_Place()
8768   {
8769     DOMStringPtr nsUriPtr = new DOMString("libgno");
8770     XsdEvent event(nsUriPtr, NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
8771     this->processEventThrow(event);
8772   }
8773
8774
8775
8776   GenoPro::Marriages::Marriage::Witnesses_p GenoPro::Marriages::Marriage::sequence::element_Witnesses()
8777   {
8778       GenoPro::Marriages::Marriage::Witnesses_p node_p = NULL;
8779     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
8780     if(fsm_p)
8781     {
8782       XsdFSM<Witnesses_ptr> *unitFsm = dynamic_cast<XsdFSM<Witnesses_ptr> *>(fsm_p);
8783       if(unitFsm && unitFsm->nodeList().size()>0) {
8784         assert(unitFsm->nodeList().size()==1);
8785         node_p = unitFsm->nodeList().at(0);
8786       }
8787     }
8788
8789     FSM::warnNullNode(node_p, "Witnesses", "{http://www.w3.org/2001/XMLSchema}Witnesses", 0);
8790     return node_p;
8791
8792   }
8793
8794
8795   void GenoPro::Marriages::Marriage::sequence::set_Witnesses(DOMString val)
8796   {
8797
8798     mark_present_Witnesses();
8799
8800     element_Witnesses()->stringValue(val);
8801   }
8802
8803   DOMString GenoPro::Marriages::Marriage::sequence::get_Witnesses_string()
8804   {
8805     return element_Witnesses()->stringValue();
8806   }
8807
8808
8809
8810   void GenoPro::Marriages::Marriage::sequence::mark_present_Witnesses()
8811   {
8812     DOMStringPtr nsUriPtr = new DOMString("libgno");
8813     XsdEvent event(nsUriPtr, NULL, DOMString("Witnesses"), XsdEvent::ELEMENT_START, false);
8814     this->processEventThrow(event);
8815   }
8816
8817
8818
8819   //constructor
8820
8821   GenoPro::PedigreeLinks::PedigreeLinks(ElementCreateArgs args):
8822       XMLSchema::XmlElement<anyType>(args),
8823
8824     _fsmAttrs(NULL),
8825     _fsmElems(NULL)
8826
8827     , _sequence(new sequence(this) )
8828
8829   {
8830     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
8831     initFSM();
8832     if(args.ownerDoc && args.ownerDoc->buildTree())
8833     {
8834       if(args.ownerDoc->createSample()) {
8835         _fsm->fireSampleEvents();
8836       }
8837       else {
8838         _fsm->fireRequiredEvents();
8839       }
8840     }
8841   }
8842
8843   void GenoPro::PedigreeLinks::initFSM()
8844   {
8845     XsdFsmBasePtr fsmsAttrs[] = {
8846
8847       NULL
8848     };
8849
8850     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
8851
8852     _fsm->replaceContentFsm(_sequence);
8853
8854     _fsmAttrs = _fsm->attributeFsm();
8855     _fsmElems = _fsm->contentFsm();
8856
8857   }
8858
8859   /* element functions  */
8860
8861 #ifndef __PedigreeLinks_PedigreeLink_member_elems_fns
8862 #define __PedigreeLinks_PedigreeLink_member_elems_fns
8863
8864
8865   GenoPro::PedigreeLinks::PedigreeLink_ptr GenoPro::PedigreeLinks::create_PedigreeLink(FsmCbOptions& options)
8866   {
8867     static DOMStringPtr myName = new DOMString("PedigreeLink");
8868     static DOMStringPtr myNsUri = new DOMString("libgno");
8869
8870     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
8871     GenoPro::PedigreeLinks::PedigreeLink_p node = XSD::createElementTmpl<PedigreeLink, void*>(t);
8872
8873     _list_PedigreeLink.push_back(node);
8874
8875     return node;
8876   }
8877
8878
8879   GenoPro::PedigreeLinks::PedigreeLink_p GenoPro::PedigreeLinks::element_PedigreeLink_at(unsigned int idx)
8880   {
8881     if(idx > _list_PedigreeLink.size()-1) {
8882       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
8883     }
8884
8885     return _list_PedigreeLink.at(idx);
8886   }
8887
8888   List<GenoPro::PedigreeLinks::PedigreeLink_ptr> GenoPro::PedigreeLinks::elements_PedigreeLink()
8889   {
8890     return _list_PedigreeLink;
8891   }
8892
8893   GenoPro::PedigreeLinks::PedigreeLink_p GenoPro::PedigreeLinks::add_node_PedigreeLink()
8894   {
8895     return get_sequence()->add_node_PedigreeLink();
8896   }
8897
8898   List<GenoPro::PedigreeLinks::PedigreeLink_ptr> GenoPro::PedigreeLinks::set_count_PedigreeLink(unsigned int size)
8899   {
8900     return get_sequence()->set_count_PedigreeLink(size);
8901   }
8902
8903
8904 #endif // __PedigreeLinks_PedigreeLink_member_elems_fns
8905
8906
8907   /* attribute  functions  */
8908
8909   //constructor
8910   GenoPro::PedigreeLinks::sequence::sequence(PedigreeLinks* that):
8911     _that(that)
8912   {
8913     XsdFsmBasePtr fsmArray[] = {
8914     new XsdFSM<PedigreeLink_ptr>( Particle(new DOMString("libgno"), DOMString("PedigreeLink"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<PedigreeLink_ptr, PedigreeLinks, FsmCbOptions>(_that, &PedigreeLinks::create_PedigreeLink)),
8915
8916       NULL
8917     } ;
8918
8919     XsdSequenceFsmOfFSMs::init(fsmArray);
8920   }
8921
8922
8923
8924   List<GenoPro::PedigreeLinks::PedigreeLink_ptr> GenoPro::PedigreeLinks::sequence::elements_PedigreeLink()
8925   {
8926
8927     List<PedigreeLink_ptr> nodeList;
8928     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
8929     if(fsm_p)
8930     {
8931       XsdFSM<PedigreeLink_ptr> *unitFsm = dynamic_cast<XsdFSM<PedigreeLink_ptr> *>(fsm_p);
8932       if(unitFsm) {
8933         //nodeList = unitFsm->nodeList().stl_list();
8934         nodeList = unitFsm->nodeList();
8935       }
8936     }
8937     return nodeList;
8938
8939   }
8940
8941
8942   GenoPro::PedigreeLinks::PedigreeLink_p GenoPro::PedigreeLinks::sequence::element_PedigreeLink_at(unsigned int idx)
8943   {
8944     return elements_PedigreeLink().at(idx);
8945   }
8946
8947
8948   GenoPro::PedigreeLinks::PedigreeLink_p GenoPro::PedigreeLinks::sequence::add_node_PedigreeLink()
8949   {
8950     DOMStringPtr nsUriPtr = new DOMString("libgno");
8951     XsdEvent event(nsUriPtr, NULL, DOMString("PedigreeLink"), XsdEvent::ELEMENT_START, false);
8952     this->processEventThrow(event);
8953     return elements_PedigreeLink().back();
8954   }
8955
8956   List<GenoPro::PedigreeLinks::PedigreeLink_ptr> GenoPro::PedigreeLinks::sequence::set_count_PedigreeLink(unsigned int size)
8957   {
8958     if( (size > -1) || (size < 1)) {
8959       ostringstream oss;
8960       oss << "set_count_PedigreeLink: size should be in range: [" << 1
8961         << "," << "unbounded" << "]";
8962       throw IndexOutOfBoundsException(oss.str());
8963     }
8964
8965     unsigned int prevSize = elements_PedigreeLink().size();
8966     if(size < prevSize) {
8967       //FIXME: allow later:
8968       throw XPlus::RuntimeException("resize lesser than current size not allowed");
8969     }
8970
8971     for(unsigned int j=prevSize; j<size; j++)
8972     {
8973       // pretend docBuilding to avoid computation of adding after first loop
8974       XsdEvent event(new DOMString("libgno"), NULL, DOMString("PedigreeLink"), XsdEvent::ELEMENT_START, false);
8975       this->processEventThrow(event);
8976     }
8977
8978     return elements_PedigreeLink();
8979   }
8980
8981
8982
8983   //constructor
8984
8985   GenoPro::PedigreeLinks::PedigreeLink::PedigreeLink(ElementCreateArgs args):
8986       XMLSchema::XmlElement<anyType>(args),
8987
8988     _fsmAttrs(NULL),
8989     _fsmElems(NULL)
8990
8991     , _sequence(new sequence(this) )
8992
8993   {
8994     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
8995     initFSM();
8996     if(args.ownerDoc && args.ownerDoc->buildTree())
8997     {
8998       if(args.ownerDoc->createSample()) {
8999         _fsm->fireSampleEvents();
9000       }
9001       else {
9002         _fsm->fireRequiredEvents();
9003       }
9004     }
9005   }
9006
9007   void GenoPro::PedigreeLinks::PedigreeLink::initFSM()
9008   {
9009     XsdFsmBasePtr fsmsAttrs[] = {
9010   new XsdFSM<attr_PedigreeLink_ptr>( Particle(NULL, DOMString("PedigreeLink"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_PedigreeLink_ptr, PedigreeLink, FsmCbOptions>(this, &PedigreeLink::create_attr_PedigreeLink)),
9011   new XsdFSM<attr_Family_ptr>( Particle(NULL, DOMString("Family"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Family_ptr, PedigreeLink, FsmCbOptions>(this, &PedigreeLink::create_attr_Family)),
9012   new XsdFSM<attr_Individual_ptr>( Particle(NULL, DOMString("Individual"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Individual_ptr, PedigreeLink, FsmCbOptions>(this, &PedigreeLink::create_attr_Individual)),
9013
9014       NULL
9015     };
9016
9017     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
9018
9019     _fsm->replaceContentFsm(_sequence);
9020
9021     _fsmAttrs = _fsm->attributeFsm();
9022     _fsmElems = _fsm->contentFsm();
9023
9024   }
9025
9026   /* element functions  */
9027
9028
9029   GenoPro::PedigreeLinks::PedigreeLink::Position_ptr GenoPro::PedigreeLinks::PedigreeLink::create_Position(FsmCbOptions& options)
9030   {
9031     static DOMStringPtr myName = new DOMString("Position");
9032     static DOMStringPtr myNsUri = new DOMString("libgno");
9033
9034     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
9035     GenoPro::PedigreeLinks::PedigreeLink::Position_p node = XSD::createElementTmpl<Position, void*>(t);
9036
9037     if(options.isSampleCreate && (node->stringValue() == "") ) {
9038       node->stringValue(node->sampleValue());
9039     }
9040
9041     _Position = node;
9042
9043     return node;
9044   }
9045
9046
9047   GenoPro::PedigreeLinks::PedigreeLink::Position_p GenoPro::PedigreeLinks::PedigreeLink::element_Position()
9048   {
9049     FSM::warnNullNode(_Position, "Position", "{}Position", 0);
9050     return _Position;
9051   }
9052
9053   void GenoPro::PedigreeLinks::PedigreeLink::mark_present_Position()
9054   {
9055     return get_sequence()->mark_present_Position();
9056   }
9057
9058
9059   /* attribute  functions  */
9060
9061
9062   GenoPro::PedigreeLinks::PedigreeLink::attr_PedigreeLink_ptr GenoPro::PedigreeLinks::PedigreeLink::create_attr_PedigreeLink(FsmCbOptions& options)
9063   {
9064     static DOMStringPtr myName = new DOMString("PedigreeLink");
9065     static DOMStringPtr myNsUri = NULL;
9066
9067     if(_attr_PedigreeLink) {
9068       return _attr_PedigreeLink;
9069     }
9070     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9071     GenoPro::PedigreeLinks::PedigreeLink::attr_PedigreeLink_p node = XSD::createAttributeTmpl<attr_PedigreeLink>(t);
9072
9073     if(options.isSampleCreate && (node->stringValue() == "") ) {
9074       node->stringValue(node->sampleValue());
9075     }
9076
9077     _attr_PedigreeLink = node;
9078
9079     return node;
9080   }
9081
9082
9083     void GenoPro::PedigreeLinks::PedigreeLink::set_attr_PedigreeLink(DOMString val)
9084     {
9085
9086       attribute_attr_PedigreeLink()->stringValue(val);
9087     }
9088
9089     DOMString GenoPro::PedigreeLinks::PedigreeLink::get_attr_PedigreeLink_string()
9090     {
9091
9092       return attribute_attr_PedigreeLink()->stringValue();
9093     }
9094
9095
9096   GenoPro::PedigreeLinks::PedigreeLink::attr_PedigreeLink_p GenoPro::PedigreeLinks::PedigreeLink::attribute_attr_PedigreeLink()
9097   {
9098     FSM::warnNullNode(_attr_PedigreeLink, "attr_PedigreeLink", "{http://www.w3.org/2001/XMLSchema}PedigreeLink", 1);
9099     return _attr_PedigreeLink;
9100   }
9101
9102
9103   GenoPro::PedigreeLinks::PedigreeLink::attr_Family_ptr GenoPro::PedigreeLinks::PedigreeLink::create_attr_Family(FsmCbOptions& options)
9104   {
9105     static DOMStringPtr myName = new DOMString("Family");
9106     static DOMStringPtr myNsUri = NULL;
9107
9108     if(_attr_Family) {
9109       return _attr_Family;
9110     }
9111     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9112     GenoPro::PedigreeLinks::PedigreeLink::attr_Family_p node = XSD::createAttributeTmpl<attr_Family>(t);
9113
9114     if(options.isSampleCreate && (node->stringValue() == "") ) {
9115       node->stringValue(node->sampleValue());
9116     }
9117
9118     _attr_Family = node;
9119
9120     return node;
9121   }
9122
9123
9124     void GenoPro::PedigreeLinks::PedigreeLink::set_attr_Family(DOMString val)
9125     {
9126
9127       attribute_attr_Family()->stringValue(val);
9128     }
9129
9130     DOMString GenoPro::PedigreeLinks::PedigreeLink::get_attr_Family_string()
9131     {
9132
9133       return attribute_attr_Family()->stringValue();
9134     }
9135
9136
9137   GenoPro::PedigreeLinks::PedigreeLink::attr_Family_p GenoPro::PedigreeLinks::PedigreeLink::attribute_attr_Family()
9138   {
9139     FSM::warnNullNode(_attr_Family, "attr_Family", "{http://www.w3.org/2001/XMLSchema}Family", 1);
9140     return _attr_Family;
9141   }
9142
9143
9144   GenoPro::PedigreeLinks::PedigreeLink::attr_Individual_ptr GenoPro::PedigreeLinks::PedigreeLink::create_attr_Individual(FsmCbOptions& options)
9145   {
9146     static DOMStringPtr myName = new DOMString("Individual");
9147     static DOMStringPtr myNsUri = NULL;
9148
9149     if(_attr_Individual) {
9150       return _attr_Individual;
9151     }
9152     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9153     GenoPro::PedigreeLinks::PedigreeLink::attr_Individual_p node = XSD::createAttributeTmpl<attr_Individual>(t);
9154
9155     if(options.isSampleCreate && (node->stringValue() == "") ) {
9156       node->stringValue(node->sampleValue());
9157     }
9158
9159     _attr_Individual = node;
9160
9161     return node;
9162   }
9163
9164
9165     void GenoPro::PedigreeLinks::PedigreeLink::set_attr_Individual(DOMString val)
9166     {
9167
9168       attribute_attr_Individual()->stringValue(val);
9169     }
9170
9171     DOMString GenoPro::PedigreeLinks::PedigreeLink::get_attr_Individual_string()
9172     {
9173
9174       return attribute_attr_Individual()->stringValue();
9175     }
9176
9177
9178   GenoPro::PedigreeLinks::PedigreeLink::attr_Individual_p GenoPro::PedigreeLinks::PedigreeLink::attribute_attr_Individual()
9179   {
9180     FSM::warnNullNode(_attr_Individual, "attr_Individual", "{http://www.w3.org/2001/XMLSchema}Individual", 1);
9181     return _attr_Individual;
9182   }
9183
9184   //constructor
9185   GenoPro::PedigreeLinks::PedigreeLink::sequence::sequence(PedigreeLink* that):
9186     _that(that)
9187   {
9188     XsdFsmBasePtr fsmArray[] = {
9189     new XsdFSM<Position_ptr>( Particle(new DOMString("libgno"), DOMString("Position"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Position_ptr, PedigreeLink, FsmCbOptions>(_that, &PedigreeLink::create_Position)),
9190
9191       NULL
9192     } ;
9193
9194     XsdSequenceFsmOfFSMs::init(fsmArray);
9195   }
9196
9197
9198
9199   GenoPro::PedigreeLinks::PedigreeLink::Position_p GenoPro::PedigreeLinks::PedigreeLink::sequence::element_Position()
9200   {
9201       GenoPro::PedigreeLinks::PedigreeLink::Position_p node_p = NULL;
9202     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
9203     if(fsm_p)
9204     {
9205       XsdFSM<Position_ptr> *unitFsm = dynamic_cast<XsdFSM<Position_ptr> *>(fsm_p);
9206       if(unitFsm && unitFsm->nodeList().size()>0) {
9207         assert(unitFsm->nodeList().size()==1);
9208         node_p = unitFsm->nodeList().at(0);
9209       }
9210     }
9211
9212     FSM::warnNullNode(node_p, "Position", "{}Position", 0);
9213     return node_p;
9214
9215   }
9216
9217
9218
9219   void GenoPro::PedigreeLinks::PedigreeLink::sequence::mark_present_Position()
9220   {
9221     DOMStringPtr nsUriPtr = new DOMString("libgno");
9222     XsdEvent event(nsUriPtr, NULL, DOMString("Position"), XsdEvent::ELEMENT_START, false);
9223     this->processEventThrow(event);
9224   }
9225
9226
9227   //constructor
9228
9229   GenoPro::PedigreeLinks::PedigreeLink::Position::Position(ElementCreateArgs args):
9230       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
9231
9232     _fsmAttrs(NULL),
9233     _fsmElems(NULL)
9234   {
9235
9236
9237     initFSM();
9238
9239
9240     if(args.ownerDoc && args.ownerDoc->buildTree())
9241
9242     {
9243       if(args.ownerDoc->createSample()) {
9244         _fsm->fireSampleEvents();
9245       }
9246       else {
9247         _fsm->fireRequiredEvents();
9248       }
9249     }
9250   }
9251
9252   void GenoPro::PedigreeLinks::PedigreeLink::Position::initFSM()
9253   {
9254     XsdFsmBasePtr fsmsAttrs[] = {
9255     new XsdFSM<attr_z_ptr>( Particle(NULL, DOMString("z"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_z_ptr, Position, FsmCbOptions>(this, &Position::create_attr_z)),
9256
9257       NULL
9258     };
9259
9260     _fsm->appendAttributeFsms(fsmsAttrs);
9261     _fsmAttrs = _fsm->attributeFsm();
9262     _fsmElems = _fsm->contentFsm();
9263
9264    }
9265
9266   /* element functions  */
9267
9268
9269   /* attribute  functions  */
9270
9271
9272   GenoPro::PedigreeLinks::PedigreeLink::Position::attr_z_ptr GenoPro::PedigreeLinks::PedigreeLink::Position::create_attr_z(FsmCbOptions& options)
9273   {
9274     static DOMStringPtr myName = new DOMString("z");
9275     static DOMStringPtr myNsUri = NULL;
9276
9277     if(_attr_z) {
9278       return _attr_z;
9279     }
9280     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9281     GenoPro::PedigreeLinks::PedigreeLink::Position::attr_z_p node = XSD::createAttributeTmpl<attr_z>(t);
9282
9283     if(options.isSampleCreate && (node->stringValue() == "") ) {
9284       node->stringValue(node->sampleValue());
9285     }
9286
9287     _attr_z = node;
9288
9289     return node;
9290   }
9291
9292
9293     void GenoPro::PedigreeLinks::PedigreeLink::Position::set_attr_z(DOMString val)
9294     {
9295
9296       attribute_attr_z()->stringValue(val);
9297     }
9298
9299     DOMString GenoPro::PedigreeLinks::PedigreeLink::Position::get_attr_z_string()
9300     {
9301
9302       return attribute_attr_z()->stringValue();
9303     }
9304
9305
9306     void GenoPro::PedigreeLinks::PedigreeLink::Position::set_attr_z(int val)
9307     {
9308
9309       attribute_attr_z()->value(val);
9310     }
9311
9312     int GenoPro::PedigreeLinks::PedigreeLink::Position::get_attr_z()
9313     {
9314
9315       return attribute_attr_z()->value();
9316     }
9317
9318
9319   GenoPro::PedigreeLinks::PedigreeLink::Position::attr_z_p GenoPro::PedigreeLinks::PedigreeLink::Position::attribute_attr_z()
9320   {
9321     FSM::warnNullNode(_attr_z, "attr_z", "{http://www.w3.org/2001/XMLSchema}z", 1);
9322     return _attr_z;
9323   }
9324
9325
9326   //constructor
9327
9328   GenoPro::Pictures::Pictures(ElementCreateArgs args):
9329       XMLSchema::XmlElement<anyType>(args),
9330
9331     _fsmAttrs(NULL),
9332     _fsmElems(NULL)
9333
9334     , _sequence(new sequence(this) )
9335
9336   {
9337     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
9338     initFSM();
9339     if(args.ownerDoc && args.ownerDoc->buildTree())
9340     {
9341       if(args.ownerDoc->createSample()) {
9342         _fsm->fireSampleEvents();
9343       }
9344       else {
9345         _fsm->fireRequiredEvents();
9346       }
9347     }
9348   }
9349
9350   void GenoPro::Pictures::initFSM()
9351   {
9352     XsdFsmBasePtr fsmsAttrs[] = {
9353
9354       NULL
9355     };
9356
9357     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
9358
9359     _fsm->replaceContentFsm(_sequence);
9360
9361     _fsmAttrs = _fsm->attributeFsm();
9362     _fsmElems = _fsm->contentFsm();
9363
9364   }
9365
9366   /* element functions  */
9367
9368
9369   GenoPro::Pictures::Picture_ptr GenoPro::Pictures::create_Picture(FsmCbOptions& options)
9370   {
9371     static DOMStringPtr myName = new DOMString("Picture");
9372     static DOMStringPtr myNsUri = new DOMString("libgno");
9373
9374     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
9375     GenoPro::Pictures::Picture_p node = XSD::createElementTmpl<Picture, void*>(t);
9376
9377     _list_Picture.push_back(node);
9378
9379     return node;
9380   }
9381
9382
9383   GenoPro::Pictures::Picture_p GenoPro::Pictures::element_Picture_at(unsigned int idx)
9384   {
9385     if(idx > _list_Picture.size()-1) {
9386       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
9387     }
9388
9389     return _list_Picture.at(idx);
9390   }
9391
9392   List<GenoPro::Pictures::Picture_ptr> GenoPro::Pictures::elements_Picture()
9393   {
9394     return _list_Picture;
9395   }
9396
9397   GenoPro::Pictures::Picture_p GenoPro::Pictures::add_node_Picture()
9398   {
9399     return get_sequence()->add_node_Picture();
9400   }
9401
9402   List<GenoPro::Pictures::Picture_ptr> GenoPro::Pictures::set_count_Picture(unsigned int size)
9403   {
9404     return get_sequence()->set_count_Picture(size);
9405   }
9406
9407
9408
9409   /* attribute  functions  */
9410
9411   //constructor
9412   GenoPro::Pictures::sequence::sequence(Pictures* that):
9413     _that(that)
9414   {
9415     XsdFsmBasePtr fsmArray[] = {
9416     new XsdFSM<Picture_ptr>( Particle(new DOMString("libgno"), DOMString("Picture"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Picture_ptr, Pictures, FsmCbOptions>(_that, &Pictures::create_Picture)),
9417
9418       NULL
9419     } ;
9420
9421     XsdSequenceFsmOfFSMs::init(fsmArray);
9422   }
9423
9424
9425
9426   List<GenoPro::Pictures::Picture_ptr> GenoPro::Pictures::sequence::elements_Picture()
9427   {
9428
9429     List<Picture_ptr> nodeList;
9430     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
9431     if(fsm_p)
9432     {
9433       XsdFSM<Picture_ptr> *unitFsm = dynamic_cast<XsdFSM<Picture_ptr> *>(fsm_p);
9434       if(unitFsm) {
9435         //nodeList = unitFsm->nodeList().stl_list();
9436         nodeList = unitFsm->nodeList();
9437       }
9438     }
9439     return nodeList;
9440
9441   }
9442
9443
9444   GenoPro::Pictures::Picture_p GenoPro::Pictures::sequence::element_Picture_at(unsigned int idx)
9445   {
9446     return elements_Picture().at(idx);
9447   }
9448
9449
9450   GenoPro::Pictures::Picture_p GenoPro::Pictures::sequence::add_node_Picture()
9451   {
9452     DOMStringPtr nsUriPtr = new DOMString("libgno");
9453     XsdEvent event(nsUriPtr, NULL, DOMString("Picture"), XsdEvent::ELEMENT_START, false);
9454     this->processEventThrow(event);
9455     return elements_Picture().back();
9456   }
9457
9458   List<GenoPro::Pictures::Picture_ptr> GenoPro::Pictures::sequence::set_count_Picture(unsigned int size)
9459   {
9460     if( (size > -1) || (size < 1)) {
9461       ostringstream oss;
9462       oss << "set_count_Picture: size should be in range: [" << 1
9463         << "," << "unbounded" << "]";
9464       throw IndexOutOfBoundsException(oss.str());
9465     }
9466
9467     unsigned int prevSize = elements_Picture().size();
9468     if(size < prevSize) {
9469       //FIXME: allow later:
9470       throw XPlus::RuntimeException("resize lesser than current size not allowed");
9471     }
9472
9473     for(unsigned int j=prevSize; j<size; j++)
9474     {
9475       // pretend docBuilding to avoid computation of adding after first loop
9476       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Picture"), XsdEvent::ELEMENT_START, false);
9477       this->processEventThrow(event);
9478     }
9479
9480     return elements_Picture();
9481   }
9482
9483
9484
9485   //constructor
9486
9487   GenoPro::Pictures::Picture::Picture(ElementCreateArgs args):
9488       XMLSchema::XmlElement<anyType>(args),
9489
9490     _fsmAttrs(NULL),
9491     _fsmElems(NULL)
9492
9493     , _sequence(new sequence(this) )
9494
9495   {
9496     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
9497     initFSM();
9498     if(args.ownerDoc && args.ownerDoc->buildTree())
9499     {
9500       if(args.ownerDoc->createSample()) {
9501         _fsm->fireSampleEvents();
9502       }
9503       else {
9504         _fsm->fireRequiredEvents();
9505       }
9506     }
9507   }
9508
9509   void GenoPro::Pictures::Picture::initFSM()
9510   {
9511     XsdFsmBasePtr fsmsAttrs[] = {
9512   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Picture, FsmCbOptions>(this, &Picture::create_attr_ID)),
9513
9514       NULL
9515     };
9516
9517     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
9518
9519     _fsm->replaceContentFsm(_sequence);
9520
9521     _fsmAttrs = _fsm->attributeFsm();
9522     _fsmElems = _fsm->contentFsm();
9523
9524   }
9525
9526   /* element functions  */
9527
9528
9529   GenoPro::Pictures::Picture::Path_ptr GenoPro::Pictures::Picture::create_Path(FsmCbOptions& options)
9530   {
9531     static DOMStringPtr myName = new DOMString("Path");
9532     static DOMStringPtr myNsUri = new DOMString("libgno");
9533
9534     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
9535     GenoPro::Pictures::Picture::Path_p node = XSD::createElementTmpl<Path, void*>(t);
9536
9537     if(options.isSampleCreate && (node->stringValue() == "") ) {
9538       node->stringValue(node->sampleValue());
9539     }
9540
9541     _Path = node;
9542
9543     return node;
9544   }
9545
9546
9547   GenoPro::Pictures::Picture::Path_p GenoPro::Pictures::Picture::element_Path()
9548   {
9549     FSM::warnNullNode(_Path, "Path", "{}Path", 0);
9550     return _Path;
9551   }
9552
9553   void GenoPro::Pictures::Picture::mark_present_Path()
9554   {
9555     return get_sequence()->mark_present_Path();
9556   }
9557
9558
9559   GenoPro::Pictures::Picture::Name_ptr GenoPro::Pictures::Picture::create_Name(FsmCbOptions& options)
9560   {
9561     static DOMStringPtr myName = new DOMString("Name");
9562     static DOMStringPtr myNsUri = new DOMString("libgno");
9563
9564     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
9565     GenoPro::Pictures::Picture::Name_p node = XSD::createElementTmpl<Name, XMLSchema::Types::bt_string*>(t);
9566
9567     if(options.isSampleCreate && (node->stringValue() == "") ) {
9568       node->stringValue(node->sampleValue());
9569     }
9570
9571     _Name = node;
9572
9573     return node;
9574   }
9575
9576
9577   GenoPro::Pictures::Picture::Name_p GenoPro::Pictures::Picture::element_Name()
9578   {
9579     FSM::warnNullNode(_Name, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
9580     return _Name;
9581   }
9582
9583   void GenoPro::Pictures::Picture::set_Name(DOMString val)
9584   {
9585     get_sequence()->set_Name(val);
9586   }
9587
9588   DOMString GenoPro::Pictures::Picture::get_Name_string()
9589   {
9590     return get_sequence()->get_Name_string();
9591   }
9592
9593
9594   void GenoPro::Pictures::Picture::mark_present_Name()
9595   {
9596     return get_sequence()->mark_present_Name();
9597   }
9598
9599
9600   GenoPro::Pictures::Picture::Cache_ptr GenoPro::Pictures::Picture::create_Cache(FsmCbOptions& options)
9601   {
9602     static DOMStringPtr myName = new DOMString("Cache");
9603     static DOMStringPtr myNsUri = new DOMString("libgno");
9604
9605     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
9606     GenoPro::Pictures::Picture::Cache_p node = XSD::createElementTmpl<Cache, void*>(t);
9607
9608     if(options.isSampleCreate && (node->stringValue() == "") ) {
9609       node->stringValue(node->sampleValue());
9610     }
9611
9612     _Cache = node;
9613
9614     return node;
9615   }
9616
9617
9618   GenoPro::Pictures::Picture::Cache_p GenoPro::Pictures::Picture::element_Cache()
9619   {
9620     FSM::warnNullNode(_Cache, "Cache", "{}Cache", 0);
9621     return _Cache;
9622   }
9623
9624   void GenoPro::Pictures::Picture::mark_present_Cache()
9625   {
9626     return get_sequence()->mark_present_Cache();
9627   }
9628
9629
9630   GenoPro::Pictures::Picture::Date_ptr GenoPro::Pictures::Picture::create_Date(FsmCbOptions& options)
9631   {
9632     static DOMStringPtr myName = new DOMString("Date");
9633     static DOMStringPtr myNsUri = new DOMString("libgno");
9634
9635     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "dateTime");
9636     GenoPro::Pictures::Picture::Date_p node = XSD::createElementTmpl<Date, XMLSchema::Types::bt_dateTime*>(t);
9637
9638     if(options.isSampleCreate && (node->stringValue() == "") ) {
9639       node->stringValue(node->sampleValue());
9640     }
9641
9642     _Date = node;
9643
9644     return node;
9645   }
9646
9647
9648   GenoPro::Pictures::Picture::Date_p GenoPro::Pictures::Picture::element_Date()
9649   {
9650     FSM::warnNullNode(_Date, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
9651     return _Date;
9652   }
9653
9654   void GenoPro::Pictures::Picture::set_Date(DOMString val)
9655   {
9656     get_sequence()->set_Date(val);
9657   }
9658
9659   DOMString GenoPro::Pictures::Picture::get_Date_string()
9660   {
9661     return get_sequence()->get_Date_string();
9662   }
9663
9664
9665   void GenoPro::Pictures::Picture::set_Date(XPlus::DateTime val)
9666   {
9667     get_sequence()->set_Date(val);
9668   }
9669
9670   XPlus::DateTime GenoPro::Pictures::Picture::get_Date()
9671   {
9672     return get_sequence()->get_Date();
9673   }
9674
9675
9676   void GenoPro::Pictures::Picture::mark_present_Date()
9677   {
9678     return get_sequence()->mark_present_Date();
9679   }
9680
9681
9682   /* attribute  functions  */
9683
9684
9685   GenoPro::Pictures::Picture::attr_ID_ptr GenoPro::Pictures::Picture::create_attr_ID(FsmCbOptions& options)
9686   {
9687     static DOMStringPtr myName = new DOMString("ID");
9688     static DOMStringPtr myNsUri = NULL;
9689
9690     if(_attr_ID) {
9691       return _attr_ID;
9692     }
9693     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9694     GenoPro::Pictures::Picture::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
9695
9696     if(options.isSampleCreate && (node->stringValue() == "") ) {
9697       node->stringValue(node->sampleValue());
9698     }
9699
9700     _attr_ID = node;
9701
9702     return node;
9703   }
9704
9705
9706     void GenoPro::Pictures::Picture::set_attr_ID(DOMString val)
9707     {
9708
9709       attribute_attr_ID()->stringValue(val);
9710     }
9711
9712     DOMString GenoPro::Pictures::Picture::get_attr_ID_string()
9713     {
9714
9715       return attribute_attr_ID()->stringValue();
9716     }
9717
9718
9719   GenoPro::Pictures::Picture::attr_ID_p GenoPro::Pictures::Picture::attribute_attr_ID()
9720   {
9721     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
9722     return _attr_ID;
9723   }
9724
9725   //constructor
9726   GenoPro::Pictures::Picture::sequence::sequence(Picture* that):
9727     _that(that)
9728   {
9729     XsdFsmBasePtr fsmArray[] = {
9730     new XsdFSM<Path_ptr>( Particle(new DOMString("libgno"), DOMString("Path"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Path_ptr, Picture, FsmCbOptions>(_that, &Picture::create_Path)),
9731       new XsdFSM<Name_ptr>( Particle(new DOMString("libgno"), DOMString("Name"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Name_ptr, Picture, FsmCbOptions>(_that, &Picture::create_Name)),
9732       new XsdFSM<Cache_ptr>( Particle(new DOMString("libgno"), DOMString("Cache"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Cache_ptr, Picture, FsmCbOptions>(_that, &Picture::create_Cache)),
9733       new XsdFSM<Date_ptr>( Particle(new DOMString("libgno"), DOMString("Date"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Date_ptr, Picture, FsmCbOptions>(_that, &Picture::create_Date)),
9734
9735       NULL
9736     } ;
9737
9738     XsdSequenceFsmOfFSMs::init(fsmArray);
9739   }
9740
9741
9742
9743   GenoPro::Pictures::Picture::Path_p GenoPro::Pictures::Picture::sequence::element_Path()
9744   {
9745       GenoPro::Pictures::Picture::Path_p node_p = NULL;
9746     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
9747     if(fsm_p)
9748     {
9749       XsdFSM<Path_ptr> *unitFsm = dynamic_cast<XsdFSM<Path_ptr> *>(fsm_p);
9750       if(unitFsm && unitFsm->nodeList().size()>0) {
9751         assert(unitFsm->nodeList().size()==1);
9752         node_p = unitFsm->nodeList().at(0);
9753       }
9754     }
9755
9756     FSM::warnNullNode(node_p, "Path", "{}Path", 0);
9757     return node_p;
9758
9759   }
9760
9761
9762
9763   void GenoPro::Pictures::Picture::sequence::mark_present_Path()
9764   {
9765     DOMStringPtr nsUriPtr = new DOMString("libgno");
9766     XsdEvent event(nsUriPtr, NULL, DOMString("Path"), XsdEvent::ELEMENT_START, false);
9767     this->processEventThrow(event);
9768   }
9769
9770
9771
9772   GenoPro::Pictures::Picture::Name_p GenoPro::Pictures::Picture::sequence::element_Name()
9773   {
9774       GenoPro::Pictures::Picture::Name_p node_p = NULL;
9775     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
9776     if(fsm_p)
9777     {
9778       XsdFSM<Name_ptr> *unitFsm = dynamic_cast<XsdFSM<Name_ptr> *>(fsm_p);
9779       if(unitFsm && unitFsm->nodeList().size()>0) {
9780         assert(unitFsm->nodeList().size()==1);
9781         node_p = unitFsm->nodeList().at(0);
9782       }
9783     }
9784
9785     FSM::warnNullNode(node_p, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
9786     return node_p;
9787
9788   }
9789
9790
9791   void GenoPro::Pictures::Picture::sequence::set_Name(DOMString val)
9792   {
9793
9794     mark_present_Name();
9795
9796     element_Name()->stringValue(val);
9797   }
9798
9799   DOMString GenoPro::Pictures::Picture::sequence::get_Name_string()
9800   {
9801     return element_Name()->stringValue();
9802   }
9803
9804
9805
9806   void GenoPro::Pictures::Picture::sequence::mark_present_Name()
9807   {
9808     DOMStringPtr nsUriPtr = new DOMString("libgno");
9809     XsdEvent event(nsUriPtr, NULL, DOMString("Name"), XsdEvent::ELEMENT_START, false);
9810     this->processEventThrow(event);
9811   }
9812
9813
9814
9815   GenoPro::Pictures::Picture::Cache_p GenoPro::Pictures::Picture::sequence::element_Cache()
9816   {
9817       GenoPro::Pictures::Picture::Cache_p node_p = NULL;
9818     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
9819     if(fsm_p)
9820     {
9821       XsdFSM<Cache_ptr> *unitFsm = dynamic_cast<XsdFSM<Cache_ptr> *>(fsm_p);
9822       if(unitFsm && unitFsm->nodeList().size()>0) {
9823         assert(unitFsm->nodeList().size()==1);
9824         node_p = unitFsm->nodeList().at(0);
9825       }
9826     }
9827
9828     FSM::warnNullNode(node_p, "Cache", "{}Cache", 0);
9829     return node_p;
9830
9831   }
9832
9833
9834
9835   void GenoPro::Pictures::Picture::sequence::mark_present_Cache()
9836   {
9837     DOMStringPtr nsUriPtr = new DOMString("libgno");
9838     XsdEvent event(nsUriPtr, NULL, DOMString("Cache"), XsdEvent::ELEMENT_START, false);
9839     this->processEventThrow(event);
9840   }
9841
9842
9843
9844   GenoPro::Pictures::Picture::Date_p GenoPro::Pictures::Picture::sequence::element_Date()
9845   {
9846       GenoPro::Pictures::Picture::Date_p node_p = NULL;
9847     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
9848     if(fsm_p)
9849     {
9850       XsdFSM<Date_ptr> *unitFsm = dynamic_cast<XsdFSM<Date_ptr> *>(fsm_p);
9851       if(unitFsm && unitFsm->nodeList().size()>0) {
9852         assert(unitFsm->nodeList().size()==1);
9853         node_p = unitFsm->nodeList().at(0);
9854       }
9855     }
9856
9857     FSM::warnNullNode(node_p, "Date", "{http://www.w3.org/2001/XMLSchema}Date", 0);
9858     return node_p;
9859
9860   }
9861
9862
9863   void GenoPro::Pictures::Picture::sequence::set_Date(DOMString val)
9864   {
9865
9866     mark_present_Date();
9867
9868     element_Date()->stringValue(val);
9869   }
9870
9871   DOMString GenoPro::Pictures::Picture::sequence::get_Date_string()
9872   {
9873     return element_Date()->stringValue();
9874   }
9875
9876
9877   void GenoPro::Pictures::Picture::sequence::set_Date(XPlus::DateTime val)
9878   {
9879
9880     mark_present_Date();
9881
9882     element_Date()->value(val);
9883   }
9884
9885   XPlus::DateTime GenoPro::Pictures::Picture::sequence::get_Date()
9886   {
9887     return element_Date()->value();
9888   }
9889
9890
9891
9892   void GenoPro::Pictures::Picture::sequence::mark_present_Date()
9893   {
9894     DOMStringPtr nsUriPtr = new DOMString("libgno");
9895     XsdEvent event(nsUriPtr, NULL, DOMString("Date"), XsdEvent::ELEMENT_START, false);
9896     this->processEventThrow(event);
9897   }
9898
9899
9900   //constructor
9901
9902   GenoPro::Pictures::Picture::Path::Path(ElementCreateArgs args):
9903       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
9904
9905     _fsmAttrs(NULL),
9906     _fsmElems(NULL)
9907   {
9908
9909
9910     initFSM();
9911
9912
9913     if(args.ownerDoc && args.ownerDoc->buildTree())
9914
9915     {
9916       if(args.ownerDoc->createSample()) {
9917         _fsm->fireSampleEvents();
9918       }
9919       else {
9920         _fsm->fireRequiredEvents();
9921       }
9922     }
9923   }
9924
9925   void GenoPro::Pictures::Picture::Path::initFSM()
9926   {
9927     XsdFsmBasePtr fsmsAttrs[] = {
9928     new XsdFSM<attr_Relative_ptr>( Particle(NULL, DOMString("Relative"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Relative_ptr, Path, FsmCbOptions>(this, &Path::create_attr_Relative)),
9929     new XsdFSM<attr_FileUnique_ptr>( Particle(NULL, DOMString("FileUnique"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_FileUnique_ptr, Path, FsmCbOptions>(this, &Path::create_attr_FileUnique)),
9930     new XsdFSM<attr_Report_ptr>( Particle(NULL, DOMString("Report"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Report_ptr, Path, FsmCbOptions>(this, &Path::create_attr_Report)),
9931
9932       NULL
9933     };
9934
9935     _fsm->appendAttributeFsms(fsmsAttrs);
9936     _fsmAttrs = _fsm->attributeFsm();
9937     _fsmElems = _fsm->contentFsm();
9938
9939    }
9940
9941   /* element functions  */
9942
9943
9944   /* attribute  functions  */
9945
9946
9947   GenoPro::Pictures::Picture::Path::attr_Relative_ptr GenoPro::Pictures::Picture::Path::create_attr_Relative(FsmCbOptions& options)
9948   {
9949     static DOMStringPtr myName = new DOMString("Relative");
9950     static DOMStringPtr myNsUri = NULL;
9951
9952     if(_attr_Relative) {
9953       return _attr_Relative;
9954     }
9955     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9956     GenoPro::Pictures::Picture::Path::attr_Relative_p node = XSD::createAttributeTmpl<attr_Relative>(t);
9957
9958     if(options.isSampleCreate && (node->stringValue() == "") ) {
9959       node->stringValue(node->sampleValue());
9960     }
9961
9962     _attr_Relative = node;
9963
9964     return node;
9965   }
9966
9967
9968     void GenoPro::Pictures::Picture::Path::set_attr_Relative(DOMString val)
9969     {
9970
9971       attribute_attr_Relative()->stringValue(val);
9972     }
9973
9974     DOMString GenoPro::Pictures::Picture::Path::get_attr_Relative_string()
9975     {
9976
9977       return attribute_attr_Relative()->stringValue();
9978     }
9979
9980
9981   GenoPro::Pictures::Picture::Path::attr_Relative_p GenoPro::Pictures::Picture::Path::attribute_attr_Relative()
9982   {
9983     FSM::warnNullNode(_attr_Relative, "attr_Relative", "{http://www.w3.org/2001/XMLSchema}Relative", 1);
9984     return _attr_Relative;
9985   }
9986
9987
9988   GenoPro::Pictures::Picture::Path::attr_FileUnique_ptr GenoPro::Pictures::Picture::Path::create_attr_FileUnique(FsmCbOptions& options)
9989   {
9990     static DOMStringPtr myName = new DOMString("FileUnique");
9991     static DOMStringPtr myNsUri = NULL;
9992
9993     if(_attr_FileUnique) {
9994       return _attr_FileUnique;
9995     }
9996     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
9997     GenoPro::Pictures::Picture::Path::attr_FileUnique_p node = XSD::createAttributeTmpl<attr_FileUnique>(t);
9998
9999     if(options.isSampleCreate && (node->stringValue() == "") ) {
10000       node->stringValue(node->sampleValue());
10001     }
10002
10003     _attr_FileUnique = node;
10004
10005     return node;
10006   }
10007
10008
10009     void GenoPro::Pictures::Picture::Path::set_attr_FileUnique(DOMString val)
10010     {
10011
10012       attribute_attr_FileUnique()->stringValue(val);
10013     }
10014
10015     DOMString GenoPro::Pictures::Picture::Path::get_attr_FileUnique_string()
10016     {
10017
10018       return attribute_attr_FileUnique()->stringValue();
10019     }
10020
10021
10022   GenoPro::Pictures::Picture::Path::attr_FileUnique_p GenoPro::Pictures::Picture::Path::attribute_attr_FileUnique()
10023   {
10024     FSM::warnNullNode(_attr_FileUnique, "attr_FileUnique", "{http://www.w3.org/2001/XMLSchema}FileUnique", 1);
10025     return _attr_FileUnique;
10026   }
10027
10028
10029   GenoPro::Pictures::Picture::Path::attr_Report_ptr GenoPro::Pictures::Picture::Path::create_attr_Report(FsmCbOptions& options)
10030   {
10031     static DOMStringPtr myName = new DOMString("Report");
10032     static DOMStringPtr myNsUri = NULL;
10033
10034     if(_attr_Report) {
10035       return _attr_Report;
10036     }
10037     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10038     GenoPro::Pictures::Picture::Path::attr_Report_p node = XSD::createAttributeTmpl<attr_Report>(t);
10039
10040     if(options.isSampleCreate && (node->stringValue() == "") ) {
10041       node->stringValue(node->sampleValue());
10042     }
10043
10044     _attr_Report = node;
10045
10046     return node;
10047   }
10048
10049
10050     void GenoPro::Pictures::Picture::Path::set_attr_Report(DOMString val)
10051     {
10052
10053       attribute_attr_Report()->stringValue(val);
10054     }
10055
10056     DOMString GenoPro::Pictures::Picture::Path::get_attr_Report_string()
10057     {
10058
10059       return attribute_attr_Report()->stringValue();
10060     }
10061
10062
10063   GenoPro::Pictures::Picture::Path::attr_Report_p GenoPro::Pictures::Picture::Path::attribute_attr_Report()
10064   {
10065     FSM::warnNullNode(_attr_Report, "attr_Report", "{http://www.w3.org/2001/XMLSchema}Report", 1);
10066     return _attr_Report;
10067   }
10068
10069   //constructor
10070
10071   GenoPro::Pictures::Picture::Cache::Cache(ElementCreateArgs args):
10072       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
10073
10074     _fsmAttrs(NULL),
10075     _fsmElems(NULL)
10076   {
10077
10078
10079     initFSM();
10080
10081
10082     if(args.ownerDoc && args.ownerDoc->buildTree())
10083
10084     {
10085       if(args.ownerDoc->createSample()) {
10086         _fsm->fireSampleEvents();
10087       }
10088       else {
10089         _fsm->fireRequiredEvents();
10090       }
10091     }
10092   }
10093
10094   void GenoPro::Pictures::Picture::Cache::initFSM()
10095   {
10096     XsdFsmBasePtr fsmsAttrs[] = {
10097     new XsdFSM<attr_FileSize_ptr>( Particle(NULL, DOMString("FileSize"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_FileSize_ptr, Cache, FsmCbOptions>(this, &Cache::create_attr_FileSize)),
10098     new XsdFSM<attr_Dimension_ptr>( Particle(NULL, DOMString("Dimension"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Dimension_ptr, Cache, FsmCbOptions>(this, &Cache::create_attr_Dimension)),
10099     new XsdFSM<attr_Megapixels_ptr>( Particle(NULL, DOMString("Megapixels"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Megapixels_ptr, Cache, FsmCbOptions>(this, &Cache::create_attr_Megapixels)),
10100     new XsdFSM<attr_BPP_ptr>( Particle(NULL, DOMString("BPP"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_BPP_ptr, Cache, FsmCbOptions>(this, &Cache::create_attr_BPP)),
10101     new XsdFSM<attr_DPI_ptr>( Particle(NULL, DOMString("DPI"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_DPI_ptr, Cache, FsmCbOptions>(this, &Cache::create_attr_DPI)),
10102
10103       NULL
10104     };
10105
10106     _fsm->appendAttributeFsms(fsmsAttrs);
10107     _fsmAttrs = _fsm->attributeFsm();
10108     _fsmElems = _fsm->contentFsm();
10109
10110    }
10111
10112   /* element functions  */
10113
10114
10115   /* attribute  functions  */
10116
10117
10118   GenoPro::Pictures::Picture::Cache::attr_FileSize_ptr GenoPro::Pictures::Picture::Cache::create_attr_FileSize(FsmCbOptions& options)
10119   {
10120     static DOMStringPtr myName = new DOMString("FileSize");
10121     static DOMStringPtr myNsUri = NULL;
10122
10123     if(_attr_FileSize) {
10124       return _attr_FileSize;
10125     }
10126     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10127     GenoPro::Pictures::Picture::Cache::attr_FileSize_p node = XSD::createAttributeTmpl<attr_FileSize>(t);
10128
10129     if(options.isSampleCreate && (node->stringValue() == "") ) {
10130       node->stringValue(node->sampleValue());
10131     }
10132
10133     _attr_FileSize = node;
10134
10135     return node;
10136   }
10137
10138
10139     void GenoPro::Pictures::Picture::Cache::set_attr_FileSize(DOMString val)
10140     {
10141
10142       attribute_attr_FileSize()->stringValue(val);
10143     }
10144
10145     DOMString GenoPro::Pictures::Picture::Cache::get_attr_FileSize_string()
10146     {
10147
10148       return attribute_attr_FileSize()->stringValue();
10149     }
10150
10151
10152     void GenoPro::Pictures::Picture::Cache::set_attr_FileSize(int val)
10153     {
10154
10155       attribute_attr_FileSize()->value(val);
10156     }
10157
10158     int GenoPro::Pictures::Picture::Cache::get_attr_FileSize()
10159     {
10160
10161       return attribute_attr_FileSize()->value();
10162     }
10163
10164
10165   GenoPro::Pictures::Picture::Cache::attr_FileSize_p GenoPro::Pictures::Picture::Cache::attribute_attr_FileSize()
10166   {
10167     FSM::warnNullNode(_attr_FileSize, "attr_FileSize", "{http://www.w3.org/2001/XMLSchema}FileSize", 1);
10168     return _attr_FileSize;
10169   }
10170
10171
10172   GenoPro::Pictures::Picture::Cache::attr_Dimension_ptr GenoPro::Pictures::Picture::Cache::create_attr_Dimension(FsmCbOptions& options)
10173   {
10174     static DOMStringPtr myName = new DOMString("Dimension");
10175     static DOMStringPtr myNsUri = NULL;
10176
10177     if(_attr_Dimension) {
10178       return _attr_Dimension;
10179     }
10180     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10181     GenoPro::Pictures::Picture::Cache::attr_Dimension_p node = XSD::createAttributeTmpl<attr_Dimension>(t);
10182
10183     if(options.isSampleCreate && (node->stringValue() == "") ) {
10184       node->stringValue(node->sampleValue());
10185     }
10186
10187     _attr_Dimension = node;
10188
10189     return node;
10190   }
10191
10192
10193     void GenoPro::Pictures::Picture::Cache::set_attr_Dimension(DOMString val)
10194     {
10195
10196       attribute_attr_Dimension()->stringValue(val);
10197     }
10198
10199     DOMString GenoPro::Pictures::Picture::Cache::get_attr_Dimension_string()
10200     {
10201
10202       return attribute_attr_Dimension()->stringValue();
10203     }
10204
10205
10206   GenoPro::Pictures::Picture::Cache::attr_Dimension_p GenoPro::Pictures::Picture::Cache::attribute_attr_Dimension()
10207   {
10208     FSM::warnNullNode(_attr_Dimension, "attr_Dimension", "{http://www.w3.org/2001/XMLSchema}Dimension", 1);
10209     return _attr_Dimension;
10210   }
10211
10212
10213   GenoPro::Pictures::Picture::Cache::attr_Megapixels_ptr GenoPro::Pictures::Picture::Cache::create_attr_Megapixels(FsmCbOptions& options)
10214   {
10215     static DOMStringPtr myName = new DOMString("Megapixels");
10216     static DOMStringPtr myNsUri = NULL;
10217
10218     if(_attr_Megapixels) {
10219       return _attr_Megapixels;
10220     }
10221     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10222     GenoPro::Pictures::Picture::Cache::attr_Megapixels_p node = XSD::createAttributeTmpl<attr_Megapixels>(t);
10223
10224     if(options.isSampleCreate && (node->stringValue() == "") ) {
10225       node->stringValue(node->sampleValue());
10226     }
10227
10228     _attr_Megapixels = node;
10229
10230     return node;
10231   }
10232
10233
10234     void GenoPro::Pictures::Picture::Cache::set_attr_Megapixels(DOMString val)
10235     {
10236
10237       attribute_attr_Megapixels()->stringValue(val);
10238     }
10239
10240     DOMString GenoPro::Pictures::Picture::Cache::get_attr_Megapixels_string()
10241     {
10242
10243       return attribute_attr_Megapixels()->stringValue();
10244     }
10245
10246
10247     void GenoPro::Pictures::Picture::Cache::set_attr_Megapixels(double val)
10248     {
10249
10250       attribute_attr_Megapixels()->value(val);
10251     }
10252
10253     double GenoPro::Pictures::Picture::Cache::get_attr_Megapixels()
10254     {
10255
10256       return attribute_attr_Megapixels()->value();
10257     }
10258
10259
10260   GenoPro::Pictures::Picture::Cache::attr_Megapixels_p GenoPro::Pictures::Picture::Cache::attribute_attr_Megapixels()
10261   {
10262     FSM::warnNullNode(_attr_Megapixels, "attr_Megapixels", "{http://www.w3.org/2001/XMLSchema}Megapixels", 1);
10263     return _attr_Megapixels;
10264   }
10265
10266
10267   GenoPro::Pictures::Picture::Cache::attr_BPP_ptr GenoPro::Pictures::Picture::Cache::create_attr_BPP(FsmCbOptions& options)
10268   {
10269     static DOMStringPtr myName = new DOMString("BPP");
10270     static DOMStringPtr myNsUri = NULL;
10271
10272     if(_attr_BPP) {
10273       return _attr_BPP;
10274     }
10275     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10276     GenoPro::Pictures::Picture::Cache::attr_BPP_p node = XSD::createAttributeTmpl<attr_BPP>(t);
10277
10278     if(options.isSampleCreate && (node->stringValue() == "") ) {
10279       node->stringValue(node->sampleValue());
10280     }
10281
10282     _attr_BPP = node;
10283
10284     return node;
10285   }
10286
10287
10288     void GenoPro::Pictures::Picture::Cache::set_attr_BPP(DOMString val)
10289     {
10290
10291       attribute_attr_BPP()->stringValue(val);
10292     }
10293
10294     DOMString GenoPro::Pictures::Picture::Cache::get_attr_BPP_string()
10295     {
10296
10297       return attribute_attr_BPP()->stringValue();
10298     }
10299
10300
10301     void GenoPro::Pictures::Picture::Cache::set_attr_BPP(int val)
10302     {
10303
10304       attribute_attr_BPP()->value(val);
10305     }
10306
10307     int GenoPro::Pictures::Picture::Cache::get_attr_BPP()
10308     {
10309
10310       return attribute_attr_BPP()->value();
10311     }
10312
10313
10314   GenoPro::Pictures::Picture::Cache::attr_BPP_p GenoPro::Pictures::Picture::Cache::attribute_attr_BPP()
10315   {
10316     FSM::warnNullNode(_attr_BPP, "attr_BPP", "{http://www.w3.org/2001/XMLSchema}BPP", 1);
10317     return _attr_BPP;
10318   }
10319
10320
10321   GenoPro::Pictures::Picture::Cache::attr_DPI_ptr GenoPro::Pictures::Picture::Cache::create_attr_DPI(FsmCbOptions& options)
10322   {
10323     static DOMStringPtr myName = new DOMString("DPI");
10324     static DOMStringPtr myNsUri = NULL;
10325
10326     if(_attr_DPI) {
10327       return _attr_DPI;
10328     }
10329     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10330     GenoPro::Pictures::Picture::Cache::attr_DPI_p node = XSD::createAttributeTmpl<attr_DPI>(t);
10331
10332     if(options.isSampleCreate && (node->stringValue() == "") ) {
10333       node->stringValue(node->sampleValue());
10334     }
10335
10336     _attr_DPI = node;
10337
10338     return node;
10339   }
10340
10341
10342     void GenoPro::Pictures::Picture::Cache::set_attr_DPI(DOMString val)
10343     {
10344
10345       attribute_attr_DPI()->stringValue(val);
10346     }
10347
10348     DOMString GenoPro::Pictures::Picture::Cache::get_attr_DPI_string()
10349     {
10350
10351       return attribute_attr_DPI()->stringValue();
10352     }
10353
10354
10355     void GenoPro::Pictures::Picture::Cache::set_attr_DPI(int val)
10356     {
10357
10358       attribute_attr_DPI()->value(val);
10359     }
10360
10361     int GenoPro::Pictures::Picture::Cache::get_attr_DPI()
10362     {
10363
10364       return attribute_attr_DPI()->value();
10365     }
10366
10367
10368   GenoPro::Pictures::Picture::Cache::attr_DPI_p GenoPro::Pictures::Picture::Cache::attribute_attr_DPI()
10369   {
10370     FSM::warnNullNode(_attr_DPI, "attr_DPI", "{http://www.w3.org/2001/XMLSchema}DPI", 1);
10371     return _attr_DPI;
10372   }
10373
10374
10375   //constructor
10376
10377   GenoPro::Places::Places(ElementCreateArgs args):
10378       XMLSchema::XmlElement<anyType>(args),
10379
10380     _fsmAttrs(NULL),
10381     _fsmElems(NULL)
10382
10383     , _sequence(new sequence(this) )
10384
10385   {
10386     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
10387     initFSM();
10388     if(args.ownerDoc && args.ownerDoc->buildTree())
10389     {
10390       if(args.ownerDoc->createSample()) {
10391         _fsm->fireSampleEvents();
10392       }
10393       else {
10394         _fsm->fireRequiredEvents();
10395       }
10396     }
10397   }
10398
10399   void GenoPro::Places::initFSM()
10400   {
10401     XsdFsmBasePtr fsmsAttrs[] = {
10402
10403       NULL
10404     };
10405
10406     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
10407
10408     _fsm->replaceContentFsm(_sequence);
10409
10410     _fsmAttrs = _fsm->attributeFsm();
10411     _fsmElems = _fsm->contentFsm();
10412
10413   }
10414
10415   /* element functions  */
10416
10417
10418   GenoPro::Places::Place_ptr GenoPro::Places::create_Place(FsmCbOptions& options)
10419   {
10420     static DOMStringPtr myName = new DOMString("Place");
10421     static DOMStringPtr myNsUri = new DOMString("libgno");
10422
10423     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
10424     GenoPro::Places::Place_p node = XSD::createElementTmpl<Place, void*>(t);
10425
10426     _list_Place.push_back(node);
10427
10428     return node;
10429   }
10430
10431
10432   GenoPro::Places::Place_p GenoPro::Places::element_Place_at(unsigned int idx)
10433   {
10434     if(idx > _list_Place.size()-1) {
10435       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
10436     }
10437
10438     return _list_Place.at(idx);
10439   }
10440
10441   List<GenoPro::Places::Place_ptr> GenoPro::Places::elements_Place()
10442   {
10443     return _list_Place;
10444   }
10445
10446   GenoPro::Places::Place_p GenoPro::Places::add_node_Place()
10447   {
10448     return get_sequence()->add_node_Place();
10449   }
10450
10451   List<GenoPro::Places::Place_ptr> GenoPro::Places::set_count_Place(unsigned int size)
10452   {
10453     return get_sequence()->set_count_Place(size);
10454   }
10455
10456
10457
10458   /* attribute  functions  */
10459
10460   //constructor
10461   GenoPro::Places::sequence::sequence(Places* that):
10462     _that(that)
10463   {
10464     XsdFsmBasePtr fsmArray[] = {
10465     new XsdFSM<Place_ptr>( Particle(new DOMString("libgno"), DOMString("Place"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Place_ptr, Places, FsmCbOptions>(_that, &Places::create_Place)),
10466
10467       NULL
10468     } ;
10469
10470     XsdSequenceFsmOfFSMs::init(fsmArray);
10471   }
10472
10473
10474
10475   List<GenoPro::Places::Place_ptr> GenoPro::Places::sequence::elements_Place()
10476   {
10477
10478     List<Place_ptr> nodeList;
10479     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
10480     if(fsm_p)
10481     {
10482       XsdFSM<Place_ptr> *unitFsm = dynamic_cast<XsdFSM<Place_ptr> *>(fsm_p);
10483       if(unitFsm) {
10484         //nodeList = unitFsm->nodeList().stl_list();
10485         nodeList = unitFsm->nodeList();
10486       }
10487     }
10488     return nodeList;
10489
10490   }
10491
10492
10493   GenoPro::Places::Place_p GenoPro::Places::sequence::element_Place_at(unsigned int idx)
10494   {
10495     return elements_Place().at(idx);
10496   }
10497
10498
10499   GenoPro::Places::Place_p GenoPro::Places::sequence::add_node_Place()
10500   {
10501     DOMStringPtr nsUriPtr = new DOMString("libgno");
10502     XsdEvent event(nsUriPtr, NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
10503     this->processEventThrow(event);
10504     return elements_Place().back();
10505   }
10506
10507   List<GenoPro::Places::Place_ptr> GenoPro::Places::sequence::set_count_Place(unsigned int size)
10508   {
10509     if( (size > -1) || (size < 1)) {
10510       ostringstream oss;
10511       oss << "set_count_Place: size should be in range: [" << 1
10512         << "," << "unbounded" << "]";
10513       throw IndexOutOfBoundsException(oss.str());
10514     }
10515
10516     unsigned int prevSize = elements_Place().size();
10517     if(size < prevSize) {
10518       //FIXME: allow later:
10519       throw XPlus::RuntimeException("resize lesser than current size not allowed");
10520     }
10521
10522     for(unsigned int j=prevSize; j<size; j++)
10523     {
10524       // pretend docBuilding to avoid computation of adding after first loop
10525       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
10526       this->processEventThrow(event);
10527     }
10528
10529     return elements_Place();
10530   }
10531
10532
10533
10534   //constructor
10535
10536   GenoPro::Places::Place::Place(ElementCreateArgs args):
10537       XMLSchema::XmlElement<anyType>(args),
10538
10539     _fsmAttrs(NULL),
10540     _fsmElems(NULL)
10541
10542     , _sequence(new sequence(this) )
10543
10544   {
10545     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
10546     initFSM();
10547     if(args.ownerDoc && args.ownerDoc->buildTree())
10548     {
10549       if(args.ownerDoc->createSample()) {
10550         _fsm->fireSampleEvents();
10551       }
10552       else {
10553         _fsm->fireRequiredEvents();
10554       }
10555     }
10556   }
10557
10558   void GenoPro::Places::Place::initFSM()
10559   {
10560     XsdFsmBasePtr fsmsAttrs[] = {
10561   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Place, FsmCbOptions>(this, &Place::create_attr_ID)),
10562
10563       NULL
10564     };
10565
10566     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
10567
10568     _fsm->replaceContentFsm(_sequence);
10569
10570     _fsmAttrs = _fsm->attributeFsm();
10571     _fsmElems = _fsm->contentFsm();
10572
10573   }
10574
10575   /* element functions  */
10576
10577
10578   GenoPro::Places::Place::Pictures_ptr GenoPro::Places::Place::create_Pictures(FsmCbOptions& options)
10579   {
10580     static DOMStringPtr myName = new DOMString("Pictures");
10581     static DOMStringPtr myNsUri = new DOMString("libgno");
10582
10583     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
10584     GenoPro::Places::Place::Pictures_p node = XSD::createElementTmpl<Pictures, void*>(t);
10585
10586     if(options.isSampleCreate && (node->stringValue() == "") ) {
10587       node->stringValue(node->sampleValue());
10588     }
10589
10590     _Pictures = node;
10591
10592     return node;
10593   }
10594
10595
10596   GenoPro::Places::Place::Pictures_p GenoPro::Places::Place::element_Pictures()
10597   {
10598     FSM::warnNullNode(_Pictures, "Pictures", "{}Pictures", 0);
10599     return _Pictures;
10600   }
10601
10602   void GenoPro::Places::Place::mark_present_Pictures()
10603   {
10604     return get_sequence()->mark_present_Pictures();
10605   }
10606
10607
10608   GenoPro::Places::Place::Parent_ptr GenoPro::Places::Place::create_Parent(FsmCbOptions& options)
10609   {
10610     static DOMStringPtr myName = new DOMString("Parent");
10611     static DOMStringPtr myNsUri = new DOMString("libgno");
10612
10613     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
10614     GenoPro::Places::Place::Parent_p node = XSD::createElementTmpl<Parent, XMLSchema::Types::bt_normalizedString*>(t);
10615
10616     if(options.isSampleCreate && (node->stringValue() == "") ) {
10617       node->stringValue(node->sampleValue());
10618     }
10619
10620     _Parent = node;
10621
10622     return node;
10623   }
10624
10625
10626   GenoPro::Places::Place::Parent_p GenoPro::Places::Place::element_Parent()
10627   {
10628     FSM::warnNullNode(_Parent, "Parent", "{http://www.w3.org/2001/XMLSchema}Parent", 0);
10629     return _Parent;
10630   }
10631
10632   void GenoPro::Places::Place::set_Parent(DOMString val)
10633   {
10634     get_sequence()->set_Parent(val);
10635   }
10636
10637   DOMString GenoPro::Places::Place::get_Parent_string()
10638   {
10639     return get_sequence()->get_Parent_string();
10640   }
10641
10642
10643   void GenoPro::Places::Place::mark_present_Parent()
10644   {
10645     return get_sequence()->mark_present_Parent();
10646   }
10647
10648
10649   GenoPro::Places::Place::Category_ptr GenoPro::Places::Place::create_Category(FsmCbOptions& options)
10650   {
10651     static DOMStringPtr myName = new DOMString("Category");
10652     static DOMStringPtr myNsUri = new DOMString("libgno");
10653
10654     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
10655     GenoPro::Places::Place::Category_p node = XSD::createElementTmpl<Category, XMLSchema::Types::bt_normalizedString*>(t);
10656
10657     if(options.isSampleCreate && (node->stringValue() == "") ) {
10658       node->stringValue(node->sampleValue());
10659     }
10660
10661     _Category = node;
10662
10663     return node;
10664   }
10665
10666
10667   GenoPro::Places::Place::Category_p GenoPro::Places::Place::element_Category()
10668   {
10669     FSM::warnNullNode(_Category, "Category", "{http://www.w3.org/2001/XMLSchema}Category", 0);
10670     return _Category;
10671   }
10672
10673   void GenoPro::Places::Place::set_Category(DOMString val)
10674   {
10675     get_sequence()->set_Category(val);
10676   }
10677
10678   DOMString GenoPro::Places::Place::get_Category_string()
10679   {
10680     return get_sequence()->get_Category_string();
10681   }
10682
10683
10684   void GenoPro::Places::Place::mark_present_Category()
10685   {
10686     return get_sequence()->mark_present_Category();
10687   }
10688
10689
10690   GenoPro::Places::Place::Name_ptr GenoPro::Places::Place::create_Name(FsmCbOptions& options)
10691   {
10692     static DOMStringPtr myName = new DOMString("Name");
10693     static DOMStringPtr myNsUri = new DOMString("libgno");
10694
10695     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
10696     GenoPro::Places::Place::Name_p node = XSD::createElementTmpl<Name, XMLSchema::Types::bt_string*>(t);
10697
10698     if(options.isSampleCreate && (node->stringValue() == "") ) {
10699       node->stringValue(node->sampleValue());
10700     }
10701
10702     _Name = node;
10703
10704     return node;
10705   }
10706
10707
10708   GenoPro::Places::Place::Name_p GenoPro::Places::Place::element_Name()
10709   {
10710     FSM::warnNullNode(_Name, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
10711     return _Name;
10712   }
10713
10714   void GenoPro::Places::Place::set_Name(DOMString val)
10715   {
10716     get_sequence()->set_Name(val);
10717   }
10718
10719   DOMString GenoPro::Places::Place::get_Name_string()
10720   {
10721     return get_sequence()->get_Name_string();
10722   }
10723
10724
10725   void GenoPro::Places::Place::mark_present_Name()
10726   {
10727     return get_sequence()->mark_present_Name();
10728   }
10729
10730
10731   GenoPro::Places::Place::Street_ptr GenoPro::Places::Place::create_Street(FsmCbOptions& options)
10732   {
10733     static DOMStringPtr myName = new DOMString("Street");
10734     static DOMStringPtr myNsUri = new DOMString("libgno");
10735
10736     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
10737     GenoPro::Places::Place::Street_p node = XSD::createElementTmpl<Street, XMLSchema::Types::bt_string*>(t);
10738
10739     if(options.isSampleCreate && (node->stringValue() == "") ) {
10740       node->stringValue(node->sampleValue());
10741     }
10742
10743     _Street = node;
10744
10745     return node;
10746   }
10747
10748
10749   GenoPro::Places::Place::Street_p GenoPro::Places::Place::element_Street()
10750   {
10751     FSM::warnNullNode(_Street, "Street", "{http://www.w3.org/2001/XMLSchema}Street", 0);
10752     return _Street;
10753   }
10754
10755   void GenoPro::Places::Place::set_Street(DOMString val)
10756   {
10757     get_sequence()->set_Street(val);
10758   }
10759
10760   DOMString GenoPro::Places::Place::get_Street_string()
10761   {
10762     return get_sequence()->get_Street_string();
10763   }
10764
10765
10766   void GenoPro::Places::Place::mark_present_Street()
10767   {
10768     return get_sequence()->mark_present_Street();
10769   }
10770
10771
10772   GenoPro::Places::Place::City_ptr GenoPro::Places::Place::create_City(FsmCbOptions& options)
10773   {
10774     static DOMStringPtr myName = new DOMString("City");
10775     static DOMStringPtr myNsUri = new DOMString("libgno");
10776
10777     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
10778     GenoPro::Places::Place::City_p node = XSD::createElementTmpl<City, XMLSchema::Types::bt_normalizedString*>(t);
10779
10780     if(options.isSampleCreate && (node->stringValue() == "") ) {
10781       node->stringValue(node->sampleValue());
10782     }
10783
10784     _City = node;
10785
10786     return node;
10787   }
10788
10789
10790   GenoPro::Places::Place::City_p GenoPro::Places::Place::element_City()
10791   {
10792     FSM::warnNullNode(_City, "City", "{http://www.w3.org/2001/XMLSchema}City", 0);
10793     return _City;
10794   }
10795
10796   void GenoPro::Places::Place::set_City(DOMString val)
10797   {
10798     get_sequence()->set_City(val);
10799   }
10800
10801   DOMString GenoPro::Places::Place::get_City_string()
10802   {
10803     return get_sequence()->get_City_string();
10804   }
10805
10806
10807   void GenoPro::Places::Place::mark_present_City()
10808   {
10809     return get_sequence()->mark_present_City();
10810   }
10811
10812
10813   GenoPro::Places::Place::Zip_ptr GenoPro::Places::Place::create_Zip(FsmCbOptions& options)
10814   {
10815     static DOMStringPtr myName = new DOMString("Zip");
10816     static DOMStringPtr myNsUri = new DOMString("libgno");
10817
10818     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
10819     GenoPro::Places::Place::Zip_p node = XSD::createElementTmpl<Zip, XMLSchema::Types::bt_normalizedString*>(t);
10820
10821     if(options.isSampleCreate && (node->stringValue() == "") ) {
10822       node->stringValue(node->sampleValue());
10823     }
10824
10825     _Zip = node;
10826
10827     return node;
10828   }
10829
10830
10831   GenoPro::Places::Place::Zip_p GenoPro::Places::Place::element_Zip()
10832   {
10833     FSM::warnNullNode(_Zip, "Zip", "{http://www.w3.org/2001/XMLSchema}Zip", 0);
10834     return _Zip;
10835   }
10836
10837   void GenoPro::Places::Place::set_Zip(DOMString val)
10838   {
10839     get_sequence()->set_Zip(val);
10840   }
10841
10842   DOMString GenoPro::Places::Place::get_Zip_string()
10843   {
10844     return get_sequence()->get_Zip_string();
10845   }
10846
10847
10848   void GenoPro::Places::Place::mark_present_Zip()
10849   {
10850     return get_sequence()->mark_present_Zip();
10851   }
10852
10853
10854   /* attribute  functions  */
10855
10856
10857   GenoPro::Places::Place::attr_ID_ptr GenoPro::Places::Place::create_attr_ID(FsmCbOptions& options)
10858   {
10859     static DOMStringPtr myName = new DOMString("ID");
10860     static DOMStringPtr myNsUri = NULL;
10861
10862     if(_attr_ID) {
10863       return _attr_ID;
10864     }
10865     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
10866     GenoPro::Places::Place::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
10867
10868     if(options.isSampleCreate && (node->stringValue() == "") ) {
10869       node->stringValue(node->sampleValue());
10870     }
10871
10872     _attr_ID = node;
10873
10874     return node;
10875   }
10876
10877
10878     void GenoPro::Places::Place::set_attr_ID(DOMString val)
10879     {
10880
10881       attribute_attr_ID()->stringValue(val);
10882     }
10883
10884     DOMString GenoPro::Places::Place::get_attr_ID_string()
10885     {
10886
10887       return attribute_attr_ID()->stringValue();
10888     }
10889
10890
10891   GenoPro::Places::Place::attr_ID_p GenoPro::Places::Place::attribute_attr_ID()
10892   {
10893     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
10894     return _attr_ID;
10895   }
10896
10897   //constructor
10898   GenoPro::Places::Place::sequence::sequence(Place* that):
10899     _that(that)
10900   {
10901     XsdFsmBasePtr fsmArray[] = {
10902     new XsdFSM<Pictures_ptr>( Particle(new DOMString("libgno"), DOMString("Pictures"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Pictures_ptr, Place, FsmCbOptions>(_that, &Place::create_Pictures)),
10903       new XsdFSM<Parent_ptr>( Particle(new DOMString("libgno"), DOMString("Parent"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Parent_ptr, Place, FsmCbOptions>(_that, &Place::create_Parent)),
10904       new XsdFSM<Category_ptr>( Particle(new DOMString("libgno"), DOMString("Category"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Category_ptr, Place, FsmCbOptions>(_that, &Place::create_Category)),
10905       new XsdFSM<Name_ptr>( Particle(new DOMString("libgno"), DOMString("Name"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Name_ptr, Place, FsmCbOptions>(_that, &Place::create_Name)),
10906       new XsdFSM<Street_ptr>( Particle(new DOMString("libgno"), DOMString("Street"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Street_ptr, Place, FsmCbOptions>(_that, &Place::create_Street)),
10907       new XsdFSM<City_ptr>( Particle(new DOMString("libgno"), DOMString("City"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<City_ptr, Place, FsmCbOptions>(_that, &Place::create_City)),
10908       new XsdFSM<Zip_ptr>( Particle(new DOMString("libgno"), DOMString("Zip"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Zip_ptr, Place, FsmCbOptions>(_that, &Place::create_Zip)),
10909
10910       NULL
10911     } ;
10912
10913     XsdSequenceFsmOfFSMs::init(fsmArray);
10914   }
10915
10916
10917
10918   GenoPro::Places::Place::Pictures_p GenoPro::Places::Place::sequence::element_Pictures()
10919   {
10920       GenoPro::Places::Place::Pictures_p node_p = NULL;
10921     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
10922     if(fsm_p)
10923     {
10924       XsdFSM<Pictures_ptr> *unitFsm = dynamic_cast<XsdFSM<Pictures_ptr> *>(fsm_p);
10925       if(unitFsm && unitFsm->nodeList().size()>0) {
10926         assert(unitFsm->nodeList().size()==1);
10927         node_p = unitFsm->nodeList().at(0);
10928       }
10929     }
10930
10931     FSM::warnNullNode(node_p, "Pictures", "{}Pictures", 0);
10932     return node_p;
10933
10934   }
10935
10936
10937
10938   void GenoPro::Places::Place::sequence::mark_present_Pictures()
10939   {
10940     DOMStringPtr nsUriPtr = new DOMString("libgno");
10941     XsdEvent event(nsUriPtr, NULL, DOMString("Pictures"), XsdEvent::ELEMENT_START, false);
10942     this->processEventThrow(event);
10943   }
10944
10945
10946
10947   GenoPro::Places::Place::Parent_p GenoPro::Places::Place::sequence::element_Parent()
10948   {
10949       GenoPro::Places::Place::Parent_p node_p = NULL;
10950     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
10951     if(fsm_p)
10952     {
10953       XsdFSM<Parent_ptr> *unitFsm = dynamic_cast<XsdFSM<Parent_ptr> *>(fsm_p);
10954       if(unitFsm && unitFsm->nodeList().size()>0) {
10955         assert(unitFsm->nodeList().size()==1);
10956         node_p = unitFsm->nodeList().at(0);
10957       }
10958     }
10959
10960     FSM::warnNullNode(node_p, "Parent", "{http://www.w3.org/2001/XMLSchema}Parent", 0);
10961     return node_p;
10962
10963   }
10964
10965
10966   void GenoPro::Places::Place::sequence::set_Parent(DOMString val)
10967   {
10968
10969     mark_present_Parent();
10970
10971     element_Parent()->stringValue(val);
10972   }
10973
10974   DOMString GenoPro::Places::Place::sequence::get_Parent_string()
10975   {
10976     return element_Parent()->stringValue();
10977   }
10978
10979
10980
10981   void GenoPro::Places::Place::sequence::mark_present_Parent()
10982   {
10983     DOMStringPtr nsUriPtr = new DOMString("libgno");
10984     XsdEvent event(nsUriPtr, NULL, DOMString("Parent"), XsdEvent::ELEMENT_START, false);
10985     this->processEventThrow(event);
10986   }
10987
10988
10989
10990   GenoPro::Places::Place::Category_p GenoPro::Places::Place::sequence::element_Category()
10991   {
10992       GenoPro::Places::Place::Category_p node_p = NULL;
10993     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
10994     if(fsm_p)
10995     {
10996       XsdFSM<Category_ptr> *unitFsm = dynamic_cast<XsdFSM<Category_ptr> *>(fsm_p);
10997       if(unitFsm && unitFsm->nodeList().size()>0) {
10998         assert(unitFsm->nodeList().size()==1);
10999         node_p = unitFsm->nodeList().at(0);
11000       }
11001     }
11002
11003     FSM::warnNullNode(node_p, "Category", "{http://www.w3.org/2001/XMLSchema}Category", 0);
11004     return node_p;
11005
11006   }
11007
11008
11009   void GenoPro::Places::Place::sequence::set_Category(DOMString val)
11010   {
11011
11012     mark_present_Category();
11013
11014     element_Category()->stringValue(val);
11015   }
11016
11017   DOMString GenoPro::Places::Place::sequence::get_Category_string()
11018   {
11019     return element_Category()->stringValue();
11020   }
11021
11022
11023
11024   void GenoPro::Places::Place::sequence::mark_present_Category()
11025   {
11026     DOMStringPtr nsUriPtr = new DOMString("libgno");
11027     XsdEvent event(nsUriPtr, NULL, DOMString("Category"), XsdEvent::ELEMENT_START, false);
11028     this->processEventThrow(event);
11029   }
11030
11031
11032
11033   GenoPro::Places::Place::Name_p GenoPro::Places::Place::sequence::element_Name()
11034   {
11035       GenoPro::Places::Place::Name_p node_p = NULL;
11036     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
11037     if(fsm_p)
11038     {
11039       XsdFSM<Name_ptr> *unitFsm = dynamic_cast<XsdFSM<Name_ptr> *>(fsm_p);
11040       if(unitFsm && unitFsm->nodeList().size()>0) {
11041         assert(unitFsm->nodeList().size()==1);
11042         node_p = unitFsm->nodeList().at(0);
11043       }
11044     }
11045
11046     FSM::warnNullNode(node_p, "Name", "{http://www.w3.org/2001/XMLSchema}Name", 0);
11047     return node_p;
11048
11049   }
11050
11051
11052   void GenoPro::Places::Place::sequence::set_Name(DOMString val)
11053   {
11054
11055     mark_present_Name();
11056
11057     element_Name()->stringValue(val);
11058   }
11059
11060   DOMString GenoPro::Places::Place::sequence::get_Name_string()
11061   {
11062     return element_Name()->stringValue();
11063   }
11064
11065
11066
11067   void GenoPro::Places::Place::sequence::mark_present_Name()
11068   {
11069     DOMStringPtr nsUriPtr = new DOMString("libgno");
11070     XsdEvent event(nsUriPtr, NULL, DOMString("Name"), XsdEvent::ELEMENT_START, false);
11071     this->processEventThrow(event);
11072   }
11073
11074
11075
11076   GenoPro::Places::Place::Street_p GenoPro::Places::Place::sequence::element_Street()
11077   {
11078       GenoPro::Places::Place::Street_p node_p = NULL;
11079     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
11080     if(fsm_p)
11081     {
11082       XsdFSM<Street_ptr> *unitFsm = dynamic_cast<XsdFSM<Street_ptr> *>(fsm_p);
11083       if(unitFsm && unitFsm->nodeList().size()>0) {
11084         assert(unitFsm->nodeList().size()==1);
11085         node_p = unitFsm->nodeList().at(0);
11086       }
11087     }
11088
11089     FSM::warnNullNode(node_p, "Street", "{http://www.w3.org/2001/XMLSchema}Street", 0);
11090     return node_p;
11091
11092   }
11093
11094
11095   void GenoPro::Places::Place::sequence::set_Street(DOMString val)
11096   {
11097
11098     mark_present_Street();
11099
11100     element_Street()->stringValue(val);
11101   }
11102
11103   DOMString GenoPro::Places::Place::sequence::get_Street_string()
11104   {
11105     return element_Street()->stringValue();
11106   }
11107
11108
11109
11110   void GenoPro::Places::Place::sequence::mark_present_Street()
11111   {
11112     DOMStringPtr nsUriPtr = new DOMString("libgno");
11113     XsdEvent event(nsUriPtr, NULL, DOMString("Street"), XsdEvent::ELEMENT_START, false);
11114     this->processEventThrow(event);
11115   }
11116
11117
11118
11119   GenoPro::Places::Place::City_p GenoPro::Places::Place::sequence::element_City()
11120   {
11121       GenoPro::Places::Place::City_p node_p = NULL;
11122     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
11123     if(fsm_p)
11124     {
11125       XsdFSM<City_ptr> *unitFsm = dynamic_cast<XsdFSM<City_ptr> *>(fsm_p);
11126       if(unitFsm && unitFsm->nodeList().size()>0) {
11127         assert(unitFsm->nodeList().size()==1);
11128         node_p = unitFsm->nodeList().at(0);
11129       }
11130     }
11131
11132     FSM::warnNullNode(node_p, "City", "{http://www.w3.org/2001/XMLSchema}City", 0);
11133     return node_p;
11134
11135   }
11136
11137
11138   void GenoPro::Places::Place::sequence::set_City(DOMString val)
11139   {
11140
11141     mark_present_City();
11142
11143     element_City()->stringValue(val);
11144   }
11145
11146   DOMString GenoPro::Places::Place::sequence::get_City_string()
11147   {
11148     return element_City()->stringValue();
11149   }
11150
11151
11152
11153   void GenoPro::Places::Place::sequence::mark_present_City()
11154   {
11155     DOMStringPtr nsUriPtr = new DOMString("libgno");
11156     XsdEvent event(nsUriPtr, NULL, DOMString("City"), XsdEvent::ELEMENT_START, false);
11157     this->processEventThrow(event);
11158   }
11159
11160
11161
11162   GenoPro::Places::Place::Zip_p GenoPro::Places::Place::sequence::element_Zip()
11163   {
11164       GenoPro::Places::Place::Zip_p node_p = NULL;
11165     XsdFsmBase* fsm_p = this->allFSMs()[6].get();
11166     if(fsm_p)
11167     {
11168       XsdFSM<Zip_ptr> *unitFsm = dynamic_cast<XsdFSM<Zip_ptr> *>(fsm_p);
11169       if(unitFsm && unitFsm->nodeList().size()>0) {
11170         assert(unitFsm->nodeList().size()==1);
11171         node_p = unitFsm->nodeList().at(0);
11172       }
11173     }
11174
11175     FSM::warnNullNode(node_p, "Zip", "{http://www.w3.org/2001/XMLSchema}Zip", 0);
11176     return node_p;
11177
11178   }
11179
11180
11181   void GenoPro::Places::Place::sequence::set_Zip(DOMString val)
11182   {
11183
11184     mark_present_Zip();
11185
11186     element_Zip()->stringValue(val);
11187   }
11188
11189   DOMString GenoPro::Places::Place::sequence::get_Zip_string()
11190   {
11191     return element_Zip()->stringValue();
11192   }
11193
11194
11195
11196   void GenoPro::Places::Place::sequence::mark_present_Zip()
11197   {
11198     DOMStringPtr nsUriPtr = new DOMString("libgno");
11199     XsdEvent event(nsUriPtr, NULL, DOMString("Zip"), XsdEvent::ELEMENT_START, false);
11200     this->processEventThrow(event);
11201   }
11202
11203
11204   //constructor
11205
11206   GenoPro::Places::Place::Pictures::Pictures(ElementCreateArgs args):
11207       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
11208
11209     _fsmAttrs(NULL),
11210     _fsmElems(NULL)
11211   {
11212
11213
11214     initFSM();
11215
11216
11217     if(args.ownerDoc && args.ownerDoc->buildTree())
11218
11219     {
11220       if(args.ownerDoc->createSample()) {
11221         _fsm->fireSampleEvents();
11222       }
11223       else {
11224         _fsm->fireRequiredEvents();
11225       }
11226     }
11227   }
11228
11229   void GenoPro::Places::Place::Pictures::initFSM()
11230   {
11231     XsdFsmBasePtr fsmsAttrs[] = {
11232     new XsdFSM<attr_Primary_ptr>( Particle(NULL, DOMString("Primary"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Primary_ptr, Pictures, FsmCbOptions>(this, &Pictures::create_attr_Primary)),
11233
11234       NULL
11235     };
11236
11237     _fsm->appendAttributeFsms(fsmsAttrs);
11238     _fsmAttrs = _fsm->attributeFsm();
11239     _fsmElems = _fsm->contentFsm();
11240
11241    }
11242
11243   /* element functions  */
11244
11245
11246   /* attribute  functions  */
11247
11248
11249   GenoPro::Places::Place::Pictures::attr_Primary_ptr GenoPro::Places::Place::Pictures::create_attr_Primary(FsmCbOptions& options)
11250   {
11251     static DOMStringPtr myName = new DOMString("Primary");
11252     static DOMStringPtr myNsUri = NULL;
11253
11254     if(_attr_Primary) {
11255       return _attr_Primary;
11256     }
11257     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
11258     GenoPro::Places::Place::Pictures::attr_Primary_p node = XSD::createAttributeTmpl<attr_Primary>(t);
11259
11260     if(options.isSampleCreate && (node->stringValue() == "") ) {
11261       node->stringValue(node->sampleValue());
11262     }
11263
11264     _attr_Primary = node;
11265
11266     return node;
11267   }
11268
11269
11270     void GenoPro::Places::Place::Pictures::set_attr_Primary(DOMString val)
11271     {
11272
11273       attribute_attr_Primary()->stringValue(val);
11274     }
11275
11276     DOMString GenoPro::Places::Place::Pictures::get_attr_Primary_string()
11277     {
11278
11279       return attribute_attr_Primary()->stringValue();
11280     }
11281
11282
11283   GenoPro::Places::Place::Pictures::attr_Primary_p GenoPro::Places::Place::Pictures::attribute_attr_Primary()
11284   {
11285     FSM::warnNullNode(_attr_Primary, "attr_Primary", "{http://www.w3.org/2001/XMLSchema}Primary", 1);
11286     return _attr_Primary;
11287   }
11288
11289
11290   //constructor
11291
11292   GenoPro::Educations::Educations(ElementCreateArgs args):
11293       XMLSchema::XmlElement<anyType>(args),
11294
11295     _fsmAttrs(NULL),
11296     _fsmElems(NULL)
11297
11298     , _sequence(new sequence(this) )
11299
11300   {
11301     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
11302     initFSM();
11303     if(args.ownerDoc && args.ownerDoc->buildTree())
11304     {
11305       if(args.ownerDoc->createSample()) {
11306         _fsm->fireSampleEvents();
11307       }
11308       else {
11309         _fsm->fireRequiredEvents();
11310       }
11311     }
11312   }
11313
11314   void GenoPro::Educations::initFSM()
11315   {
11316     XsdFsmBasePtr fsmsAttrs[] = {
11317
11318       NULL
11319     };
11320
11321     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
11322
11323     _fsm->replaceContentFsm(_sequence);
11324
11325     _fsmAttrs = _fsm->attributeFsm();
11326     _fsmElems = _fsm->contentFsm();
11327
11328   }
11329
11330   /* element functions  */
11331
11332
11333   GenoPro::Educations::Education_ptr GenoPro::Educations::create_Education(FsmCbOptions& options)
11334   {
11335     static DOMStringPtr myName = new DOMString("Education");
11336     static DOMStringPtr myNsUri = new DOMString("libgno");
11337
11338     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
11339     GenoPro::Educations::Education_p node = XSD::createElementTmpl<Education, void*>(t);
11340
11341     _list_Education.push_back(node);
11342
11343     return node;
11344   }
11345
11346
11347   GenoPro::Educations::Education_p GenoPro::Educations::element_Education_at(unsigned int idx)
11348   {
11349     if(idx > _list_Education.size()-1) {
11350       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
11351     }
11352
11353     return _list_Education.at(idx);
11354   }
11355
11356   List<GenoPro::Educations::Education_ptr> GenoPro::Educations::elements_Education()
11357   {
11358     return _list_Education;
11359   }
11360
11361   GenoPro::Educations::Education_p GenoPro::Educations::add_node_Education()
11362   {
11363     return get_sequence()->add_node_Education();
11364   }
11365
11366   List<GenoPro::Educations::Education_ptr> GenoPro::Educations::set_count_Education(unsigned int size)
11367   {
11368     return get_sequence()->set_count_Education(size);
11369   }
11370
11371
11372
11373   /* attribute  functions  */
11374
11375   //constructor
11376   GenoPro::Educations::sequence::sequence(Educations* that):
11377     _that(that)
11378   {
11379     XsdFsmBasePtr fsmArray[] = {
11380     new XsdFSM<Education_ptr>( Particle(new DOMString("libgno"), DOMString("Education"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Education_ptr, Educations, FsmCbOptions>(_that, &Educations::create_Education)),
11381
11382       NULL
11383     } ;
11384
11385     XsdSequenceFsmOfFSMs::init(fsmArray);
11386   }
11387
11388
11389
11390   List<GenoPro::Educations::Education_ptr> GenoPro::Educations::sequence::elements_Education()
11391   {
11392
11393     List<Education_ptr> nodeList;
11394     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
11395     if(fsm_p)
11396     {
11397       XsdFSM<Education_ptr> *unitFsm = dynamic_cast<XsdFSM<Education_ptr> *>(fsm_p);
11398       if(unitFsm) {
11399         //nodeList = unitFsm->nodeList().stl_list();
11400         nodeList = unitFsm->nodeList();
11401       }
11402     }
11403     return nodeList;
11404
11405   }
11406
11407
11408   GenoPro::Educations::Education_p GenoPro::Educations::sequence::element_Education_at(unsigned int idx)
11409   {
11410     return elements_Education().at(idx);
11411   }
11412
11413
11414   GenoPro::Educations::Education_p GenoPro::Educations::sequence::add_node_Education()
11415   {
11416     DOMStringPtr nsUriPtr = new DOMString("libgno");
11417     XsdEvent event(nsUriPtr, NULL, DOMString("Education"), XsdEvent::ELEMENT_START, false);
11418     this->processEventThrow(event);
11419     return elements_Education().back();
11420   }
11421
11422   List<GenoPro::Educations::Education_ptr> GenoPro::Educations::sequence::set_count_Education(unsigned int size)
11423   {
11424     if( (size > -1) || (size < 1)) {
11425       ostringstream oss;
11426       oss << "set_count_Education: size should be in range: [" << 1
11427         << "," << "unbounded" << "]";
11428       throw IndexOutOfBoundsException(oss.str());
11429     }
11430
11431     unsigned int prevSize = elements_Education().size();
11432     if(size < prevSize) {
11433       //FIXME: allow later:
11434       throw XPlus::RuntimeException("resize lesser than current size not allowed");
11435     }
11436
11437     for(unsigned int j=prevSize; j<size; j++)
11438     {
11439       // pretend docBuilding to avoid computation of adding after first loop
11440       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Education"), XsdEvent::ELEMENT_START, false);
11441       this->processEventThrow(event);
11442     }
11443
11444     return elements_Education();
11445   }
11446
11447
11448
11449   //constructor
11450
11451   GenoPro::Educations::Education::Education(ElementCreateArgs args):
11452       XMLSchema::XmlElement<anyType>(args),
11453
11454     _fsmAttrs(NULL),
11455     _fsmElems(NULL)
11456
11457     , _sequence(new sequence(this) )
11458
11459   {
11460     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
11461     initFSM();
11462     if(args.ownerDoc && args.ownerDoc->buildTree())
11463     {
11464       if(args.ownerDoc->createSample()) {
11465         _fsm->fireSampleEvents();
11466       }
11467       else {
11468         _fsm->fireRequiredEvents();
11469       }
11470     }
11471   }
11472
11473   void GenoPro::Educations::Education::initFSM()
11474   {
11475     XsdFsmBasePtr fsmsAttrs[] = {
11476   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Education, FsmCbOptions>(this, &Education::create_attr_ID)),
11477
11478       NULL
11479     };
11480
11481     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
11482
11483     _fsm->replaceContentFsm(_sequence);
11484
11485     _fsmAttrs = _fsm->attributeFsm();
11486     _fsmElems = _fsm->contentFsm();
11487
11488   }
11489
11490   /* element functions  */
11491
11492
11493   GenoPro::Educations::Education::Institution_ptr GenoPro::Educations::Education::create_Institution(FsmCbOptions& options)
11494   {
11495     static DOMStringPtr myName = new DOMString("Institution");
11496     static DOMStringPtr myNsUri = new DOMString("libgno");
11497
11498     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
11499     GenoPro::Educations::Education::Institution_p node = XSD::createElementTmpl<Institution, XMLSchema::Types::bt_string*>(t);
11500
11501     if(options.isSampleCreate && (node->stringValue() == "") ) {
11502       node->stringValue(node->sampleValue());
11503     }
11504
11505     _Institution = node;
11506
11507     return node;
11508   }
11509
11510
11511   GenoPro::Educations::Education::Institution_p GenoPro::Educations::Education::element_Institution()
11512   {
11513     FSM::warnNullNode(_Institution, "Institution", "{http://www.w3.org/2001/XMLSchema}Institution", 0);
11514     return _Institution;
11515   }
11516
11517   void GenoPro::Educations::Education::set_Institution(DOMString val)
11518   {
11519     get_sequence()->set_Institution(val);
11520   }
11521
11522   DOMString GenoPro::Educations::Education::get_Institution_string()
11523   {
11524     return get_sequence()->get_Institution_string();
11525   }
11526
11527
11528   void GenoPro::Educations::Education::mark_present_Institution()
11529   {
11530     return get_sequence()->mark_present_Institution();
11531   }
11532
11533
11534   GenoPro::Educations::Education::Place_ptr GenoPro::Educations::Education::create_Place(FsmCbOptions& options)
11535   {
11536     static DOMStringPtr myName = new DOMString("Place");
11537     static DOMStringPtr myNsUri = new DOMString("libgno");
11538
11539     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
11540     GenoPro::Educations::Education::Place_p node = XSD::createElementTmpl<Place, XMLSchema::Types::bt_normalizedString*>(t);
11541
11542     if(options.isSampleCreate && (node->stringValue() == "") ) {
11543       node->stringValue(node->sampleValue());
11544     }
11545
11546     _Place = node;
11547
11548     return node;
11549   }
11550
11551
11552   GenoPro::Educations::Education::Place_p GenoPro::Educations::Education::element_Place()
11553   {
11554     FSM::warnNullNode(_Place, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
11555     return _Place;
11556   }
11557
11558   void GenoPro::Educations::Education::set_Place(DOMString val)
11559   {
11560     get_sequence()->set_Place(val);
11561   }
11562
11563   DOMString GenoPro::Educations::Education::get_Place_string()
11564   {
11565     return get_sequence()->get_Place_string();
11566   }
11567
11568
11569   void GenoPro::Educations::Education::mark_present_Place()
11570   {
11571     return get_sequence()->mark_present_Place();
11572   }
11573
11574
11575   GenoPro::Educations::Education::Level_ptr GenoPro::Educations::Education::create_Level(FsmCbOptions& options)
11576   {
11577     static DOMStringPtr myName = new DOMString("Level");
11578     static DOMStringPtr myNsUri = new DOMString("libgno");
11579
11580     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
11581     GenoPro::Educations::Education::Level_p node = XSD::createElementTmpl<Level, void*>(t);
11582
11583     _Level = node;
11584
11585     return node;
11586   }
11587
11588
11589   GenoPro::Educations::Education::Level_p GenoPro::Educations::Education::element_Level()
11590   {
11591     FSM::warnNullNode(_Level, "Level", "{}Level", 0);
11592     return _Level;
11593   }
11594
11595   void GenoPro::Educations::Education::mark_present_Level()
11596   {
11597     return get_sequence()->mark_present_Level();
11598   }
11599
11600
11601   GenoPro::Educations::Education::Achievement_ptr GenoPro::Educations::Education::create_Achievement(FsmCbOptions& options)
11602   {
11603     static DOMStringPtr myName = new DOMString("Achievement");
11604     static DOMStringPtr myNsUri = new DOMString("libgno");
11605
11606     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
11607     GenoPro::Educations::Education::Achievement_p node = XSD::createElementTmpl<Achievement, XMLSchema::Types::bt_normalizedString*>(t);
11608
11609     if(options.isSampleCreate && (node->stringValue() == "") ) {
11610       node->stringValue(node->sampleValue());
11611     }
11612
11613     _Achievement = node;
11614
11615     return node;
11616   }
11617
11618
11619   GenoPro::Educations::Education::Achievement_p GenoPro::Educations::Education::element_Achievement()
11620   {
11621     FSM::warnNullNode(_Achievement, "Achievement", "{http://www.w3.org/2001/XMLSchema}Achievement", 0);
11622     return _Achievement;
11623   }
11624
11625   void GenoPro::Educations::Education::set_Achievement(DOMString val)
11626   {
11627     get_sequence()->set_Achievement(val);
11628   }
11629
11630   DOMString GenoPro::Educations::Education::get_Achievement_string()
11631   {
11632     return get_sequence()->get_Achievement_string();
11633   }
11634
11635
11636   void GenoPro::Educations::Education::mark_present_Achievement()
11637   {
11638     return get_sequence()->mark_present_Achievement();
11639   }
11640
11641
11642   GenoPro::Educations::Education::Termination_ptr GenoPro::Educations::Education::create_Termination(FsmCbOptions& options)
11643   {
11644     static DOMStringPtr myName = new DOMString("Termination");
11645     static DOMStringPtr myNsUri = new DOMString("libgno");
11646
11647     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
11648     GenoPro::Educations::Education::Termination_p node = XSD::createElementTmpl<Termination, XMLSchema::Types::bt_normalizedString*>(t);
11649
11650     if(options.isSampleCreate && (node->stringValue() == "") ) {
11651       node->stringValue(node->sampleValue());
11652     }
11653
11654     _Termination = node;
11655
11656     return node;
11657   }
11658
11659
11660   GenoPro::Educations::Education::Termination_p GenoPro::Educations::Education::element_Termination()
11661   {
11662     FSM::warnNullNode(_Termination, "Termination", "{http://www.w3.org/2001/XMLSchema}Termination", 0);
11663     return _Termination;
11664   }
11665
11666   void GenoPro::Educations::Education::set_Termination(DOMString val)
11667   {
11668     get_sequence()->set_Termination(val);
11669   }
11670
11671   DOMString GenoPro::Educations::Education::get_Termination_string()
11672   {
11673     return get_sequence()->get_Termination_string();
11674   }
11675
11676
11677   void GenoPro::Educations::Education::mark_present_Termination()
11678   {
11679     return get_sequence()->mark_present_Termination();
11680   }
11681
11682
11683   GenoPro::Educations::Education::DateStart_ptr GenoPro::Educations::Education::create_DateStart(FsmCbOptions& options)
11684   {
11685     static DOMStringPtr myName = new DOMString("DateStart");
11686     static DOMStringPtr myNsUri = new DOMString("libgno");
11687
11688     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
11689     GenoPro::Educations::Education::DateStart_p node = XSD::createElementTmpl<DateStart, XMLSchema::Types::bt_string*>(t);
11690
11691     if(options.isSampleCreate && (node->stringValue() == "") ) {
11692       node->stringValue(node->sampleValue());
11693     }
11694
11695     _DateStart = node;
11696
11697     return node;
11698   }
11699
11700
11701   GenoPro::Educations::Education::DateStart_p GenoPro::Educations::Education::element_DateStart()
11702   {
11703     FSM::warnNullNode(_DateStart, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
11704     return _DateStart;
11705   }
11706
11707   void GenoPro::Educations::Education::set_DateStart(DOMString val)
11708   {
11709     get_sequence()->set_DateStart(val);
11710   }
11711
11712   DOMString GenoPro::Educations::Education::get_DateStart_string()
11713   {
11714     return get_sequence()->get_DateStart_string();
11715   }
11716
11717
11718   void GenoPro::Educations::Education::mark_present_DateStart()
11719   {
11720     return get_sequence()->mark_present_DateStart();
11721   }
11722
11723
11724   GenoPro::Educations::Education::DateEnd_ptr GenoPro::Educations::Education::create_DateEnd(FsmCbOptions& options)
11725   {
11726     static DOMStringPtr myName = new DOMString("DateEnd");
11727     static DOMStringPtr myNsUri = new DOMString("libgno");
11728
11729     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
11730     GenoPro::Educations::Education::DateEnd_p node = XSD::createElementTmpl<DateEnd, XMLSchema::Types::bt_string*>(t);
11731
11732     if(options.isSampleCreate && (node->stringValue() == "") ) {
11733       node->stringValue(node->sampleValue());
11734     }
11735
11736     _DateEnd = node;
11737
11738     return node;
11739   }
11740
11741
11742   GenoPro::Educations::Education::DateEnd_p GenoPro::Educations::Education::element_DateEnd()
11743   {
11744     FSM::warnNullNode(_DateEnd, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
11745     return _DateEnd;
11746   }
11747
11748   void GenoPro::Educations::Education::set_DateEnd(DOMString val)
11749   {
11750     get_sequence()->set_DateEnd(val);
11751   }
11752
11753   DOMString GenoPro::Educations::Education::get_DateEnd_string()
11754   {
11755     return get_sequence()->get_DateEnd_string();
11756   }
11757
11758
11759   void GenoPro::Educations::Education::mark_present_DateEnd()
11760   {
11761     return get_sequence()->mark_present_DateEnd();
11762   }
11763
11764
11765   GenoPro::Educations::Education::StudyType_ptr GenoPro::Educations::Education::create_StudyType(FsmCbOptions& options)
11766   {
11767     static DOMStringPtr myName = new DOMString("StudyType");
11768     static DOMStringPtr myNsUri = new DOMString("libgno");
11769
11770     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
11771     GenoPro::Educations::Education::StudyType_p node = XSD::createElementTmpl<StudyType, XMLSchema::Types::bt_normalizedString*>(t);
11772
11773     if(options.isSampleCreate && (node->stringValue() == "") ) {
11774       node->stringValue(node->sampleValue());
11775     }
11776
11777     _StudyType = node;
11778
11779     return node;
11780   }
11781
11782
11783   GenoPro::Educations::Education::StudyType_p GenoPro::Educations::Education::element_StudyType()
11784   {
11785     FSM::warnNullNode(_StudyType, "StudyType", "{http://www.w3.org/2001/XMLSchema}StudyType", 0);
11786     return _StudyType;
11787   }
11788
11789   void GenoPro::Educations::Education::set_StudyType(DOMString val)
11790   {
11791     get_sequence()->set_StudyType(val);
11792   }
11793
11794   DOMString GenoPro::Educations::Education::get_StudyType_string()
11795   {
11796     return get_sequence()->get_StudyType_string();
11797   }
11798
11799
11800   void GenoPro::Educations::Education::mark_present_StudyType()
11801   {
11802     return get_sequence()->mark_present_StudyType();
11803   }
11804
11805
11806   GenoPro::Educations::Education::Comment_ptr GenoPro::Educations::Education::create_Comment(FsmCbOptions& options)
11807   {
11808     static DOMStringPtr myName = new DOMString("Comment");
11809     static DOMStringPtr myNsUri = new DOMString("libgno");
11810
11811     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
11812     GenoPro::Educations::Education::Comment_p node = XSD::createElementTmpl<Comment, XMLSchema::Types::bt_string*>(t);
11813
11814     if(options.isSampleCreate && (node->stringValue() == "") ) {
11815       node->stringValue(node->sampleValue());
11816     }
11817
11818     _Comment = node;
11819
11820     return node;
11821   }
11822
11823
11824   GenoPro::Educations::Education::Comment_p GenoPro::Educations::Education::element_Comment()
11825   {
11826     FSM::warnNullNode(_Comment, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
11827     return _Comment;
11828   }
11829
11830   void GenoPro::Educations::Education::set_Comment(DOMString val)
11831   {
11832     get_sequence()->set_Comment(val);
11833   }
11834
11835   DOMString GenoPro::Educations::Education::get_Comment_string()
11836   {
11837     return get_sequence()->get_Comment_string();
11838   }
11839
11840
11841   void GenoPro::Educations::Education::mark_present_Comment()
11842   {
11843     return get_sequence()->mark_present_Comment();
11844   }
11845
11846
11847   /* attribute  functions  */
11848
11849
11850   GenoPro::Educations::Education::attr_ID_ptr GenoPro::Educations::Education::create_attr_ID(FsmCbOptions& options)
11851   {
11852     static DOMStringPtr myName = new DOMString("ID");
11853     static DOMStringPtr myNsUri = NULL;
11854
11855     if(_attr_ID) {
11856       return _attr_ID;
11857     }
11858     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
11859     GenoPro::Educations::Education::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
11860
11861     if(options.isSampleCreate && (node->stringValue() == "") ) {
11862       node->stringValue(node->sampleValue());
11863     }
11864
11865     _attr_ID = node;
11866
11867     return node;
11868   }
11869
11870
11871     void GenoPro::Educations::Education::set_attr_ID(DOMString val)
11872     {
11873
11874       attribute_attr_ID()->stringValue(val);
11875     }
11876
11877     DOMString GenoPro::Educations::Education::get_attr_ID_string()
11878     {
11879
11880       return attribute_attr_ID()->stringValue();
11881     }
11882
11883
11884   GenoPro::Educations::Education::attr_ID_p GenoPro::Educations::Education::attribute_attr_ID()
11885   {
11886     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
11887     return _attr_ID;
11888   }
11889
11890   //constructor
11891   GenoPro::Educations::Education::sequence::sequence(Education* that):
11892     _that(that)
11893   {
11894     XsdFsmBasePtr fsmArray[] = {
11895     new XsdFSM<Institution_ptr>( Particle(new DOMString("libgno"), DOMString("Institution"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Institution_ptr, Education, FsmCbOptions>(_that, &Education::create_Institution)),
11896       new XsdFSM<Place_ptr>( Particle(new DOMString("libgno"), DOMString("Place"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Place_ptr, Education, FsmCbOptions>(_that, &Education::create_Place)),
11897       new XsdFSM<Level_ptr>( Particle(new DOMString("libgno"), DOMString("Level"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Level_ptr, Education, FsmCbOptions>(_that, &Education::create_Level)),
11898       new XsdFSM<Achievement_ptr>( Particle(new DOMString("libgno"), DOMString("Achievement"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Achievement_ptr, Education, FsmCbOptions>(_that, &Education::create_Achievement)),
11899       new XsdFSM<Termination_ptr>( Particle(new DOMString("libgno"), DOMString("Termination"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Termination_ptr, Education, FsmCbOptions>(_that, &Education::create_Termination)),
11900       new XsdFSM<DateStart_ptr>( Particle(new DOMString("libgno"), DOMString("DateStart"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateStart_ptr, Education, FsmCbOptions>(_that, &Education::create_DateStart)),
11901       new XsdFSM<DateEnd_ptr>( Particle(new DOMString("libgno"), DOMString("DateEnd"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateEnd_ptr, Education, FsmCbOptions>(_that, &Education::create_DateEnd)),
11902       new XsdFSM<StudyType_ptr>( Particle(new DOMString("libgno"), DOMString("StudyType"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<StudyType_ptr, Education, FsmCbOptions>(_that, &Education::create_StudyType)),
11903       new XsdFSM<Comment_ptr>( Particle(new DOMString("libgno"), DOMString("Comment"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Comment_ptr, Education, FsmCbOptions>(_that, &Education::create_Comment)),
11904
11905       NULL
11906     } ;
11907
11908     XsdSequenceFsmOfFSMs::init(fsmArray);
11909   }
11910
11911
11912
11913   GenoPro::Educations::Education::Institution_p GenoPro::Educations::Education::sequence::element_Institution()
11914   {
11915       GenoPro::Educations::Education::Institution_p node_p = NULL;
11916     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
11917     if(fsm_p)
11918     {
11919       XsdFSM<Institution_ptr> *unitFsm = dynamic_cast<XsdFSM<Institution_ptr> *>(fsm_p);
11920       if(unitFsm && unitFsm->nodeList().size()>0) {
11921         assert(unitFsm->nodeList().size()==1);
11922         node_p = unitFsm->nodeList().at(0);
11923       }
11924     }
11925
11926     FSM::warnNullNode(node_p, "Institution", "{http://www.w3.org/2001/XMLSchema}Institution", 0);
11927     return node_p;
11928
11929   }
11930
11931
11932   void GenoPro::Educations::Education::sequence::set_Institution(DOMString val)
11933   {
11934
11935     mark_present_Institution();
11936
11937     element_Institution()->stringValue(val);
11938   }
11939
11940   DOMString GenoPro::Educations::Education::sequence::get_Institution_string()
11941   {
11942     return element_Institution()->stringValue();
11943   }
11944
11945
11946
11947   void GenoPro::Educations::Education::sequence::mark_present_Institution()
11948   {
11949     DOMStringPtr nsUriPtr = new DOMString("libgno");
11950     XsdEvent event(nsUriPtr, NULL, DOMString("Institution"), XsdEvent::ELEMENT_START, false);
11951     this->processEventThrow(event);
11952   }
11953
11954
11955
11956   GenoPro::Educations::Education::Place_p GenoPro::Educations::Education::sequence::element_Place()
11957   {
11958       GenoPro::Educations::Education::Place_p node_p = NULL;
11959     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
11960     if(fsm_p)
11961     {
11962       XsdFSM<Place_ptr> *unitFsm = dynamic_cast<XsdFSM<Place_ptr> *>(fsm_p);
11963       if(unitFsm && unitFsm->nodeList().size()>0) {
11964         assert(unitFsm->nodeList().size()==1);
11965         node_p = unitFsm->nodeList().at(0);
11966       }
11967     }
11968
11969     FSM::warnNullNode(node_p, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
11970     return node_p;
11971
11972   }
11973
11974
11975   void GenoPro::Educations::Education::sequence::set_Place(DOMString val)
11976   {
11977
11978     mark_present_Place();
11979
11980     element_Place()->stringValue(val);
11981   }
11982
11983   DOMString GenoPro::Educations::Education::sequence::get_Place_string()
11984   {
11985     return element_Place()->stringValue();
11986   }
11987
11988
11989
11990   void GenoPro::Educations::Education::sequence::mark_present_Place()
11991   {
11992     DOMStringPtr nsUriPtr = new DOMString("libgno");
11993     XsdEvent event(nsUriPtr, NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
11994     this->processEventThrow(event);
11995   }
11996
11997
11998
11999   GenoPro::Educations::Education::Level_p GenoPro::Educations::Education::sequence::element_Level()
12000   {
12001       GenoPro::Educations::Education::Level_p node_p = NULL;
12002     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
12003     if(fsm_p)
12004     {
12005       XsdFSM<Level_ptr> *unitFsm = dynamic_cast<XsdFSM<Level_ptr> *>(fsm_p);
12006       if(unitFsm && unitFsm->nodeList().size()>0) {
12007         assert(unitFsm->nodeList().size()==1);
12008         node_p = unitFsm->nodeList().at(0);
12009       }
12010     }
12011
12012     FSM::warnNullNode(node_p, "Level", "{}Level", 0);
12013     return node_p;
12014
12015   }
12016
12017
12018
12019   void GenoPro::Educations::Education::sequence::mark_present_Level()
12020   {
12021     DOMStringPtr nsUriPtr = new DOMString("libgno");
12022     XsdEvent event(nsUriPtr, NULL, DOMString("Level"), XsdEvent::ELEMENT_START, false);
12023     this->processEventThrow(event);
12024   }
12025
12026
12027
12028   GenoPro::Educations::Education::Achievement_p GenoPro::Educations::Education::sequence::element_Achievement()
12029   {
12030       GenoPro::Educations::Education::Achievement_p node_p = NULL;
12031     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
12032     if(fsm_p)
12033     {
12034       XsdFSM<Achievement_ptr> *unitFsm = dynamic_cast<XsdFSM<Achievement_ptr> *>(fsm_p);
12035       if(unitFsm && unitFsm->nodeList().size()>0) {
12036         assert(unitFsm->nodeList().size()==1);
12037         node_p = unitFsm->nodeList().at(0);
12038       }
12039     }
12040
12041     FSM::warnNullNode(node_p, "Achievement", "{http://www.w3.org/2001/XMLSchema}Achievement", 0);
12042     return node_p;
12043
12044   }
12045
12046
12047   void GenoPro::Educations::Education::sequence::set_Achievement(DOMString val)
12048   {
12049
12050     mark_present_Achievement();
12051
12052     element_Achievement()->stringValue(val);
12053   }
12054
12055   DOMString GenoPro::Educations::Education::sequence::get_Achievement_string()
12056   {
12057     return element_Achievement()->stringValue();
12058   }
12059
12060
12061
12062   void GenoPro::Educations::Education::sequence::mark_present_Achievement()
12063   {
12064     DOMStringPtr nsUriPtr = new DOMString("libgno");
12065     XsdEvent event(nsUriPtr, NULL, DOMString("Achievement"), XsdEvent::ELEMENT_START, false);
12066     this->processEventThrow(event);
12067   }
12068
12069
12070
12071   GenoPro::Educations::Education::Termination_p GenoPro::Educations::Education::sequence::element_Termination()
12072   {
12073       GenoPro::Educations::Education::Termination_p node_p = NULL;
12074     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
12075     if(fsm_p)
12076     {
12077       XsdFSM<Termination_ptr> *unitFsm = dynamic_cast<XsdFSM<Termination_ptr> *>(fsm_p);
12078       if(unitFsm && unitFsm->nodeList().size()>0) {
12079         assert(unitFsm->nodeList().size()==1);
12080         node_p = unitFsm->nodeList().at(0);
12081       }
12082     }
12083
12084     FSM::warnNullNode(node_p, "Termination", "{http://www.w3.org/2001/XMLSchema}Termination", 0);
12085     return node_p;
12086
12087   }
12088
12089
12090   void GenoPro::Educations::Education::sequence::set_Termination(DOMString val)
12091   {
12092
12093     mark_present_Termination();
12094
12095     element_Termination()->stringValue(val);
12096   }
12097
12098   DOMString GenoPro::Educations::Education::sequence::get_Termination_string()
12099   {
12100     return element_Termination()->stringValue();
12101   }
12102
12103
12104
12105   void GenoPro::Educations::Education::sequence::mark_present_Termination()
12106   {
12107     DOMStringPtr nsUriPtr = new DOMString("libgno");
12108     XsdEvent event(nsUriPtr, NULL, DOMString("Termination"), XsdEvent::ELEMENT_START, false);
12109     this->processEventThrow(event);
12110   }
12111
12112
12113
12114   GenoPro::Educations::Education::DateStart_p GenoPro::Educations::Education::sequence::element_DateStart()
12115   {
12116       GenoPro::Educations::Education::DateStart_p node_p = NULL;
12117     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
12118     if(fsm_p)
12119     {
12120       XsdFSM<DateStart_ptr> *unitFsm = dynamic_cast<XsdFSM<DateStart_ptr> *>(fsm_p);
12121       if(unitFsm && unitFsm->nodeList().size()>0) {
12122         assert(unitFsm->nodeList().size()==1);
12123         node_p = unitFsm->nodeList().at(0);
12124       }
12125     }
12126
12127     FSM::warnNullNode(node_p, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
12128     return node_p;
12129
12130   }
12131
12132
12133   void GenoPro::Educations::Education::sequence::set_DateStart(DOMString val)
12134   {
12135
12136     mark_present_DateStart();
12137
12138     element_DateStart()->stringValue(val);
12139   }
12140
12141   DOMString GenoPro::Educations::Education::sequence::get_DateStart_string()
12142   {
12143     return element_DateStart()->stringValue();
12144   }
12145
12146
12147
12148   void GenoPro::Educations::Education::sequence::mark_present_DateStart()
12149   {
12150     DOMStringPtr nsUriPtr = new DOMString("libgno");
12151     XsdEvent event(nsUriPtr, NULL, DOMString("DateStart"), XsdEvent::ELEMENT_START, false);
12152     this->processEventThrow(event);
12153   }
12154
12155
12156
12157   GenoPro::Educations::Education::DateEnd_p GenoPro::Educations::Education::sequence::element_DateEnd()
12158   {
12159       GenoPro::Educations::Education::DateEnd_p node_p = NULL;
12160     XsdFsmBase* fsm_p = this->allFSMs()[6].get();
12161     if(fsm_p)
12162     {
12163       XsdFSM<DateEnd_ptr> *unitFsm = dynamic_cast<XsdFSM<DateEnd_ptr> *>(fsm_p);
12164       if(unitFsm && unitFsm->nodeList().size()>0) {
12165         assert(unitFsm->nodeList().size()==1);
12166         node_p = unitFsm->nodeList().at(0);
12167       }
12168     }
12169
12170     FSM::warnNullNode(node_p, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
12171     return node_p;
12172
12173   }
12174
12175
12176   void GenoPro::Educations::Education::sequence::set_DateEnd(DOMString val)
12177   {
12178
12179     mark_present_DateEnd();
12180
12181     element_DateEnd()->stringValue(val);
12182   }
12183
12184   DOMString GenoPro::Educations::Education::sequence::get_DateEnd_string()
12185   {
12186     return element_DateEnd()->stringValue();
12187   }
12188
12189
12190
12191   void GenoPro::Educations::Education::sequence::mark_present_DateEnd()
12192   {
12193     DOMStringPtr nsUriPtr = new DOMString("libgno");
12194     XsdEvent event(nsUriPtr, NULL, DOMString("DateEnd"), XsdEvent::ELEMENT_START, false);
12195     this->processEventThrow(event);
12196   }
12197
12198
12199
12200   GenoPro::Educations::Education::StudyType_p GenoPro::Educations::Education::sequence::element_StudyType()
12201   {
12202       GenoPro::Educations::Education::StudyType_p node_p = NULL;
12203     XsdFsmBase* fsm_p = this->allFSMs()[7].get();
12204     if(fsm_p)
12205     {
12206       XsdFSM<StudyType_ptr> *unitFsm = dynamic_cast<XsdFSM<StudyType_ptr> *>(fsm_p);
12207       if(unitFsm && unitFsm->nodeList().size()>0) {
12208         assert(unitFsm->nodeList().size()==1);
12209         node_p = unitFsm->nodeList().at(0);
12210       }
12211     }
12212
12213     FSM::warnNullNode(node_p, "StudyType", "{http://www.w3.org/2001/XMLSchema}StudyType", 0);
12214     return node_p;
12215
12216   }
12217
12218
12219   void GenoPro::Educations::Education::sequence::set_StudyType(DOMString val)
12220   {
12221
12222     mark_present_StudyType();
12223
12224     element_StudyType()->stringValue(val);
12225   }
12226
12227   DOMString GenoPro::Educations::Education::sequence::get_StudyType_string()
12228   {
12229     return element_StudyType()->stringValue();
12230   }
12231
12232
12233
12234   void GenoPro::Educations::Education::sequence::mark_present_StudyType()
12235   {
12236     DOMStringPtr nsUriPtr = new DOMString("libgno");
12237     XsdEvent event(nsUriPtr, NULL, DOMString("StudyType"), XsdEvent::ELEMENT_START, false);
12238     this->processEventThrow(event);
12239   }
12240
12241
12242
12243   GenoPro::Educations::Education::Comment_p GenoPro::Educations::Education::sequence::element_Comment()
12244   {
12245       GenoPro::Educations::Education::Comment_p node_p = NULL;
12246     XsdFsmBase* fsm_p = this->allFSMs()[8].get();
12247     if(fsm_p)
12248     {
12249       XsdFSM<Comment_ptr> *unitFsm = dynamic_cast<XsdFSM<Comment_ptr> *>(fsm_p);
12250       if(unitFsm && unitFsm->nodeList().size()>0) {
12251         assert(unitFsm->nodeList().size()==1);
12252         node_p = unitFsm->nodeList().at(0);
12253       }
12254     }
12255
12256     FSM::warnNullNode(node_p, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
12257     return node_p;
12258
12259   }
12260
12261
12262   void GenoPro::Educations::Education::sequence::set_Comment(DOMString val)
12263   {
12264
12265     mark_present_Comment();
12266
12267     element_Comment()->stringValue(val);
12268   }
12269
12270   DOMString GenoPro::Educations::Education::sequence::get_Comment_string()
12271   {
12272     return element_Comment()->stringValue();
12273   }
12274
12275
12276
12277   void GenoPro::Educations::Education::sequence::mark_present_Comment()
12278   {
12279     DOMStringPtr nsUriPtr = new DOMString("libgno");
12280     XsdEvent event(nsUriPtr, NULL, DOMString("Comment"), XsdEvent::ELEMENT_START, false);
12281     this->processEventThrow(event);
12282   }
12283
12284
12285
12286   //constructor
12287
12288   GenoPro::Educations::Education::Level::Level(ElementCreateArgs args):
12289       XMLSchema::XmlElement<anyType>(args),
12290
12291     _fsmAttrs(NULL),
12292     _fsmElems(NULL)
12293
12294     , _sequence(new sequence(this) )
12295
12296   {
12297     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
12298     initFSM();
12299     if(args.ownerDoc && args.ownerDoc->buildTree())
12300     {
12301       if(args.ownerDoc->createSample()) {
12302         _fsm->fireSampleEvents();
12303       }
12304       else {
12305         _fsm->fireRequiredEvents();
12306       }
12307     }
12308   }
12309
12310   void GenoPro::Educations::Education::Level::initFSM()
12311   {
12312     XsdFsmBasePtr fsmsAttrs[] = {
12313
12314       NULL
12315     };
12316
12317     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
12318
12319     _fsm->replaceContentFsm(_sequence);
12320
12321     _fsmAttrs = _fsm->attributeFsm();
12322     _fsmElems = _fsm->contentFsm();
12323
12324   }
12325
12326   /* element functions  */
12327
12328
12329   GenoPro::Educations::Education::Level::Years_ptr GenoPro::Educations::Education::Level::create_Years(FsmCbOptions& options)
12330   {
12331     static DOMStringPtr myName = new DOMString("Years");
12332     static DOMStringPtr myNsUri = new DOMString("libgno");
12333
12334     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "int");
12335     GenoPro::Educations::Education::Level::Years_p node = XSD::createElementTmpl<Years, XMLSchema::Types::bt_int*>(t);
12336
12337     if(options.isSampleCreate && (node->stringValue() == "") ) {
12338       node->stringValue(node->sampleValue());
12339     }
12340
12341     _Years = node;
12342
12343     return node;
12344   }
12345
12346
12347   GenoPro::Educations::Education::Level::Years_p GenoPro::Educations::Education::Level::element_Years()
12348   {
12349     FSM::warnNullNode(_Years, "Years", "{http://www.w3.org/2001/XMLSchema}Years", 0);
12350     return _Years;
12351   }
12352
12353   void GenoPro::Educations::Education::Level::set_Years(DOMString val)
12354   {
12355     get_sequence()->set_Years(val);
12356   }
12357
12358   DOMString GenoPro::Educations::Education::Level::get_Years_string()
12359   {
12360     return get_sequence()->get_Years_string();
12361   }
12362
12363
12364   void GenoPro::Educations::Education::Level::set_Years(int val)
12365   {
12366     get_sequence()->set_Years(val);
12367   }
12368
12369   int GenoPro::Educations::Education::Level::get_Years()
12370   {
12371     return get_sequence()->get_Years();
12372   }
12373
12374
12375   void GenoPro::Educations::Education::Level::mark_present_Years()
12376   {
12377     return get_sequence()->mark_present_Years();
12378   }
12379
12380
12381   /* attribute  functions  */
12382
12383   //constructor
12384   GenoPro::Educations::Education::Level::sequence::sequence(Level* that):
12385     _that(that)
12386   {
12387     XsdFsmBasePtr fsmArray[] = {
12388     new XsdFSM<Years_ptr>( Particle(new DOMString("libgno"), DOMString("Years"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Years_ptr, Level, FsmCbOptions>(_that, &Level::create_Years)),
12389
12390       NULL
12391     } ;
12392
12393     XsdSequenceFsmOfFSMs::init(fsmArray);
12394   }
12395
12396
12397
12398   GenoPro::Educations::Education::Level::Years_p GenoPro::Educations::Education::Level::sequence::element_Years()
12399   {
12400       GenoPro::Educations::Education::Level::Years_p node_p = NULL;
12401     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
12402     if(fsm_p)
12403     {
12404       XsdFSM<Years_ptr> *unitFsm = dynamic_cast<XsdFSM<Years_ptr> *>(fsm_p);
12405       if(unitFsm && unitFsm->nodeList().size()>0) {
12406         assert(unitFsm->nodeList().size()==1);
12407         node_p = unitFsm->nodeList().at(0);
12408       }
12409     }
12410
12411     FSM::warnNullNode(node_p, "Years", "{http://www.w3.org/2001/XMLSchema}Years", 0);
12412     return node_p;
12413
12414   }
12415
12416
12417   void GenoPro::Educations::Education::Level::sequence::set_Years(DOMString val)
12418   {
12419
12420     mark_present_Years();
12421
12422     element_Years()->stringValue(val);
12423   }
12424
12425   DOMString GenoPro::Educations::Education::Level::sequence::get_Years_string()
12426   {
12427     return element_Years()->stringValue();
12428   }
12429
12430
12431   void GenoPro::Educations::Education::Level::sequence::set_Years(int val)
12432   {
12433
12434     mark_present_Years();
12435
12436     element_Years()->value(val);
12437   }
12438
12439   int GenoPro::Educations::Education::Level::sequence::get_Years()
12440   {
12441     return element_Years()->value();
12442   }
12443
12444
12445
12446   void GenoPro::Educations::Education::Level::sequence::mark_present_Years()
12447   {
12448     DOMStringPtr nsUriPtr = new DOMString("libgno");
12449     XsdEvent event(nsUriPtr, NULL, DOMString("Years"), XsdEvent::ELEMENT_START, false);
12450     this->processEventThrow(event);
12451   }
12452
12453
12454
12455   //constructor
12456
12457   GenoPro::Occupations::Occupations(ElementCreateArgs args):
12458       XMLSchema::XmlElement<anyType>(args),
12459
12460     _fsmAttrs(NULL),
12461     _fsmElems(NULL)
12462
12463     , _sequence(new sequence(this) )
12464
12465   {
12466     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
12467     initFSM();
12468     if(args.ownerDoc && args.ownerDoc->buildTree())
12469     {
12470       if(args.ownerDoc->createSample()) {
12471         _fsm->fireSampleEvents();
12472       }
12473       else {
12474         _fsm->fireRequiredEvents();
12475       }
12476     }
12477   }
12478
12479   void GenoPro::Occupations::initFSM()
12480   {
12481     XsdFsmBasePtr fsmsAttrs[] = {
12482
12483       NULL
12484     };
12485
12486     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
12487
12488     _fsm->replaceContentFsm(_sequence);
12489
12490     _fsmAttrs = _fsm->attributeFsm();
12491     _fsmElems = _fsm->contentFsm();
12492
12493   }
12494
12495   /* element functions  */
12496
12497
12498   GenoPro::Occupations::Occupation_ptr GenoPro::Occupations::create_Occupation(FsmCbOptions& options)
12499   {
12500     static DOMStringPtr myName = new DOMString("Occupation");
12501     static DOMStringPtr myNsUri = new DOMString("libgno");
12502
12503     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
12504     GenoPro::Occupations::Occupation_p node = XSD::createElementTmpl<Occupation, void*>(t);
12505
12506     _list_Occupation.push_back(node);
12507
12508     return node;
12509   }
12510
12511
12512   GenoPro::Occupations::Occupation_p GenoPro::Occupations::element_Occupation_at(unsigned int idx)
12513   {
12514     if(idx > _list_Occupation.size()-1) {
12515       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
12516     }
12517
12518     return _list_Occupation.at(idx);
12519   }
12520
12521   List<GenoPro::Occupations::Occupation_ptr> GenoPro::Occupations::elements_Occupation()
12522   {
12523     return _list_Occupation;
12524   }
12525
12526   GenoPro::Occupations::Occupation_p GenoPro::Occupations::add_node_Occupation()
12527   {
12528     return get_sequence()->add_node_Occupation();
12529   }
12530
12531   List<GenoPro::Occupations::Occupation_ptr> GenoPro::Occupations::set_count_Occupation(unsigned int size)
12532   {
12533     return get_sequence()->set_count_Occupation(size);
12534   }
12535
12536
12537
12538   /* attribute  functions  */
12539
12540   //constructor
12541   GenoPro::Occupations::sequence::sequence(Occupations* that):
12542     _that(that)
12543   {
12544     XsdFsmBasePtr fsmArray[] = {
12545     new XsdFSM<Occupation_ptr>( Particle(new DOMString("libgno"), DOMString("Occupation"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Occupation_ptr, Occupations, FsmCbOptions>(_that, &Occupations::create_Occupation)),
12546
12547       NULL
12548     } ;
12549
12550     XsdSequenceFsmOfFSMs::init(fsmArray);
12551   }
12552
12553
12554
12555   List<GenoPro::Occupations::Occupation_ptr> GenoPro::Occupations::sequence::elements_Occupation()
12556   {
12557
12558     List<Occupation_ptr> nodeList;
12559     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
12560     if(fsm_p)
12561     {
12562       XsdFSM<Occupation_ptr> *unitFsm = dynamic_cast<XsdFSM<Occupation_ptr> *>(fsm_p);
12563       if(unitFsm) {
12564         //nodeList = unitFsm->nodeList().stl_list();
12565         nodeList = unitFsm->nodeList();
12566       }
12567     }
12568     return nodeList;
12569
12570   }
12571
12572
12573   GenoPro::Occupations::Occupation_p GenoPro::Occupations::sequence::element_Occupation_at(unsigned int idx)
12574   {
12575     return elements_Occupation().at(idx);
12576   }
12577
12578
12579   GenoPro::Occupations::Occupation_p GenoPro::Occupations::sequence::add_node_Occupation()
12580   {
12581     DOMStringPtr nsUriPtr = new DOMString("libgno");
12582     XsdEvent event(nsUriPtr, NULL, DOMString("Occupation"), XsdEvent::ELEMENT_START, false);
12583     this->processEventThrow(event);
12584     return elements_Occupation().back();
12585   }
12586
12587   List<GenoPro::Occupations::Occupation_ptr> GenoPro::Occupations::sequence::set_count_Occupation(unsigned int size)
12588   {
12589     if( (size > -1) || (size < 1)) {
12590       ostringstream oss;
12591       oss << "set_count_Occupation: size should be in range: [" << 1
12592         << "," << "unbounded" << "]";
12593       throw IndexOutOfBoundsException(oss.str());
12594     }
12595
12596     unsigned int prevSize = elements_Occupation().size();
12597     if(size < prevSize) {
12598       //FIXME: allow later:
12599       throw XPlus::RuntimeException("resize lesser than current size not allowed");
12600     }
12601
12602     for(unsigned int j=prevSize; j<size; j++)
12603     {
12604       // pretend docBuilding to avoid computation of adding after first loop
12605       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Occupation"), XsdEvent::ELEMENT_START, false);
12606       this->processEventThrow(event);
12607     }
12608
12609     return elements_Occupation();
12610   }
12611
12612
12613
12614   //constructor
12615
12616   GenoPro::Occupations::Occupation::Occupation(ElementCreateArgs args):
12617       XMLSchema::XmlElement<anyType>(args),
12618
12619     _fsmAttrs(NULL),
12620     _fsmElems(NULL)
12621
12622     , _sequence(new sequence(this) )
12623
12624   {
12625     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
12626     initFSM();
12627     if(args.ownerDoc && args.ownerDoc->buildTree())
12628     {
12629       if(args.ownerDoc->createSample()) {
12630         _fsm->fireSampleEvents();
12631       }
12632       else {
12633         _fsm->fireRequiredEvents();
12634       }
12635     }
12636   }
12637
12638   void GenoPro::Occupations::Occupation::initFSM()
12639   {
12640     XsdFsmBasePtr fsmsAttrs[] = {
12641   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Occupation, FsmCbOptions>(this, &Occupation::create_attr_ID)),
12642
12643       NULL
12644     };
12645
12646     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
12647
12648     _fsm->replaceContentFsm(_sequence);
12649
12650     _fsmAttrs = _fsm->attributeFsm();
12651     _fsmElems = _fsm->contentFsm();
12652
12653   }
12654
12655   /* element functions  */
12656
12657
12658   GenoPro::Occupations::Occupation::Title_ptr GenoPro::Occupations::Occupation::create_Title(FsmCbOptions& options)
12659   {
12660     static DOMStringPtr myName = new DOMString("Title");
12661     static DOMStringPtr myNsUri = new DOMString("libgno");
12662
12663     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
12664     GenoPro::Occupations::Occupation::Title_p node = XSD::createElementTmpl<Title, XMLSchema::Types::bt_string*>(t);
12665
12666     if(options.isSampleCreate && (node->stringValue() == "") ) {
12667       node->stringValue(node->sampleValue());
12668     }
12669
12670     _Title = node;
12671
12672     return node;
12673   }
12674
12675
12676   GenoPro::Occupations::Occupation::Title_p GenoPro::Occupations::Occupation::element_Title()
12677   {
12678     FSM::warnNullNode(_Title, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
12679     return _Title;
12680   }
12681
12682   void GenoPro::Occupations::Occupation::set_Title(DOMString val)
12683   {
12684     get_sequence()->set_Title(val);
12685   }
12686
12687   DOMString GenoPro::Occupations::Occupation::get_Title_string()
12688   {
12689     return get_sequence()->get_Title_string();
12690   }
12691
12692
12693   void GenoPro::Occupations::Occupation::mark_present_Title()
12694   {
12695     return get_sequence()->mark_present_Title();
12696   }
12697
12698
12699   GenoPro::Occupations::Occupation::Company_ptr GenoPro::Occupations::Occupation::create_Company(FsmCbOptions& options)
12700   {
12701     static DOMStringPtr myName = new DOMString("Company");
12702     static DOMStringPtr myNsUri = new DOMString("libgno");
12703
12704     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
12705     GenoPro::Occupations::Occupation::Company_p node = XSD::createElementTmpl<Company, XMLSchema::Types::bt_string*>(t);
12706
12707     if(options.isSampleCreate && (node->stringValue() == "") ) {
12708       node->stringValue(node->sampleValue());
12709     }
12710
12711     _Company = node;
12712
12713     return node;
12714   }
12715
12716
12717   GenoPro::Occupations::Occupation::Company_p GenoPro::Occupations::Occupation::element_Company()
12718   {
12719     FSM::warnNullNode(_Company, "Company", "{http://www.w3.org/2001/XMLSchema}Company", 0);
12720     return _Company;
12721   }
12722
12723   void GenoPro::Occupations::Occupation::set_Company(DOMString val)
12724   {
12725     get_sequence()->set_Company(val);
12726   }
12727
12728   DOMString GenoPro::Occupations::Occupation::get_Company_string()
12729   {
12730     return get_sequence()->get_Company_string();
12731   }
12732
12733
12734   void GenoPro::Occupations::Occupation::mark_present_Company()
12735   {
12736     return get_sequence()->mark_present_Company();
12737   }
12738
12739
12740   GenoPro::Occupations::Occupation::Industry_ptr GenoPro::Occupations::Occupation::create_Industry(FsmCbOptions& options)
12741   {
12742     static DOMStringPtr myName = new DOMString("Industry");
12743     static DOMStringPtr myNsUri = new DOMString("libgno");
12744
12745     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
12746     GenoPro::Occupations::Occupation::Industry_p node = XSD::createElementTmpl<Industry, XMLSchema::Types::bt_normalizedString*>(t);
12747
12748     if(options.isSampleCreate && (node->stringValue() == "") ) {
12749       node->stringValue(node->sampleValue());
12750     }
12751
12752     _Industry = node;
12753
12754     return node;
12755   }
12756
12757
12758   GenoPro::Occupations::Occupation::Industry_p GenoPro::Occupations::Occupation::element_Industry()
12759   {
12760     FSM::warnNullNode(_Industry, "Industry", "{http://www.w3.org/2001/XMLSchema}Industry", 0);
12761     return _Industry;
12762   }
12763
12764   void GenoPro::Occupations::Occupation::set_Industry(DOMString val)
12765   {
12766     get_sequence()->set_Industry(val);
12767   }
12768
12769   DOMString GenoPro::Occupations::Occupation::get_Industry_string()
12770   {
12771     return get_sequence()->get_Industry_string();
12772   }
12773
12774
12775   void GenoPro::Occupations::Occupation::mark_present_Industry()
12776   {
12777     return get_sequence()->mark_present_Industry();
12778   }
12779
12780
12781   GenoPro::Occupations::Occupation::Place_ptr GenoPro::Occupations::Occupation::create_Place(FsmCbOptions& options)
12782   {
12783     static DOMStringPtr myName = new DOMString("Place");
12784     static DOMStringPtr myNsUri = new DOMString("libgno");
12785
12786     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
12787     GenoPro::Occupations::Occupation::Place_p node = XSD::createElementTmpl<Place, XMLSchema::Types::bt_normalizedString*>(t);
12788
12789     if(options.isSampleCreate && (node->stringValue() == "") ) {
12790       node->stringValue(node->sampleValue());
12791     }
12792
12793     _Place = node;
12794
12795     return node;
12796   }
12797
12798
12799   GenoPro::Occupations::Occupation::Place_p GenoPro::Occupations::Occupation::element_Place()
12800   {
12801     FSM::warnNullNode(_Place, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
12802     return _Place;
12803   }
12804
12805   void GenoPro::Occupations::Occupation::set_Place(DOMString val)
12806   {
12807     get_sequence()->set_Place(val);
12808   }
12809
12810   DOMString GenoPro::Occupations::Occupation::get_Place_string()
12811   {
12812     return get_sequence()->get_Place_string();
12813   }
12814
12815
12816   void GenoPro::Occupations::Occupation::mark_present_Place()
12817   {
12818     return get_sequence()->mark_present_Place();
12819   }
12820
12821
12822   GenoPro::Occupations::Occupation::Source_ptr GenoPro::Occupations::Occupation::create_Source(FsmCbOptions& options)
12823   {
12824     static DOMStringPtr myName = new DOMString("Source");
12825     static DOMStringPtr myNsUri = new DOMString("libgno");
12826
12827     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
12828     GenoPro::Occupations::Occupation::Source_p node = XSD::createElementTmpl<Source, XMLSchema::Types::bt_normalizedString*>(t);
12829
12830     if(options.isSampleCreate && (node->stringValue() == "") ) {
12831       node->stringValue(node->sampleValue());
12832     }
12833
12834     _Source = node;
12835
12836     return node;
12837   }
12838
12839
12840   GenoPro::Occupations::Occupation::Source_p GenoPro::Occupations::Occupation::element_Source()
12841   {
12842     FSM::warnNullNode(_Source, "Source", "{http://www.w3.org/2001/XMLSchema}Source", 0);
12843     return _Source;
12844   }
12845
12846   void GenoPro::Occupations::Occupation::set_Source(DOMString val)
12847   {
12848     get_sequence()->set_Source(val);
12849   }
12850
12851   DOMString GenoPro::Occupations::Occupation::get_Source_string()
12852   {
12853     return get_sequence()->get_Source_string();
12854   }
12855
12856
12857   void GenoPro::Occupations::Occupation::mark_present_Source()
12858   {
12859     return get_sequence()->mark_present_Source();
12860   }
12861
12862
12863   GenoPro::Occupations::Occupation::DateStart_ptr GenoPro::Occupations::Occupation::create_DateStart(FsmCbOptions& options)
12864   {
12865     static DOMStringPtr myName = new DOMString("DateStart");
12866     static DOMStringPtr myNsUri = new DOMString("libgno");
12867
12868     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
12869     GenoPro::Occupations::Occupation::DateStart_p node = XSD::createElementTmpl<DateStart, XMLSchema::Types::bt_string*>(t);
12870
12871     if(options.isSampleCreate && (node->stringValue() == "") ) {
12872       node->stringValue(node->sampleValue());
12873     }
12874
12875     _DateStart = node;
12876
12877     return node;
12878   }
12879
12880
12881   GenoPro::Occupations::Occupation::DateStart_p GenoPro::Occupations::Occupation::element_DateStart()
12882   {
12883     FSM::warnNullNode(_DateStart, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
12884     return _DateStart;
12885   }
12886
12887   void GenoPro::Occupations::Occupation::set_DateStart(DOMString val)
12888   {
12889     get_sequence()->set_DateStart(val);
12890   }
12891
12892   DOMString GenoPro::Occupations::Occupation::get_DateStart_string()
12893   {
12894     return get_sequence()->get_DateStart_string();
12895   }
12896
12897
12898   void GenoPro::Occupations::Occupation::mark_present_DateStart()
12899   {
12900     return get_sequence()->mark_present_DateStart();
12901   }
12902
12903
12904   GenoPro::Occupations::Occupation::DateEnd_ptr GenoPro::Occupations::Occupation::create_DateEnd(FsmCbOptions& options)
12905   {
12906     static DOMStringPtr myName = new DOMString("DateEnd");
12907     static DOMStringPtr myNsUri = new DOMString("libgno");
12908
12909     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
12910     GenoPro::Occupations::Occupation::DateEnd_p node = XSD::createElementTmpl<DateEnd, XMLSchema::Types::bt_string*>(t);
12911
12912     if(options.isSampleCreate && (node->stringValue() == "") ) {
12913       node->stringValue(node->sampleValue());
12914     }
12915
12916     _DateEnd = node;
12917
12918     return node;
12919   }
12920
12921
12922   GenoPro::Occupations::Occupation::DateEnd_p GenoPro::Occupations::Occupation::element_DateEnd()
12923   {
12924     FSM::warnNullNode(_DateEnd, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
12925     return _DateEnd;
12926   }
12927
12928   void GenoPro::Occupations::Occupation::set_DateEnd(DOMString val)
12929   {
12930     get_sequence()->set_DateEnd(val);
12931   }
12932
12933   DOMString GenoPro::Occupations::Occupation::get_DateEnd_string()
12934   {
12935     return get_sequence()->get_DateEnd_string();
12936   }
12937
12938
12939   void GenoPro::Occupations::Occupation::mark_present_DateEnd()
12940   {
12941     return get_sequence()->mark_present_DateEnd();
12942   }
12943
12944
12945   GenoPro::Occupations::Occupation::WorkType_ptr GenoPro::Occupations::Occupation::create_WorkType(FsmCbOptions& options)
12946   {
12947     static DOMStringPtr myName = new DOMString("WorkType");
12948     static DOMStringPtr myNsUri = new DOMString("libgno");
12949
12950     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
12951     GenoPro::Occupations::Occupation::WorkType_p node = XSD::createElementTmpl<WorkType, XMLSchema::Types::bt_normalizedString*>(t);
12952
12953     if(options.isSampleCreate && (node->stringValue() == "") ) {
12954       node->stringValue(node->sampleValue());
12955     }
12956
12957     _WorkType = node;
12958
12959     return node;
12960   }
12961
12962
12963   GenoPro::Occupations::Occupation::WorkType_p GenoPro::Occupations::Occupation::element_WorkType()
12964   {
12965     FSM::warnNullNode(_WorkType, "WorkType", "{http://www.w3.org/2001/XMLSchema}WorkType", 0);
12966     return _WorkType;
12967   }
12968
12969   void GenoPro::Occupations::Occupation::set_WorkType(DOMString val)
12970   {
12971     get_sequence()->set_WorkType(val);
12972   }
12973
12974   DOMString GenoPro::Occupations::Occupation::get_WorkType_string()
12975   {
12976     return get_sequence()->get_WorkType_string();
12977   }
12978
12979
12980   void GenoPro::Occupations::Occupation::mark_present_WorkType()
12981   {
12982     return get_sequence()->mark_present_WorkType();
12983   }
12984
12985
12986   /* attribute  functions  */
12987
12988
12989   GenoPro::Occupations::Occupation::attr_ID_ptr GenoPro::Occupations::Occupation::create_attr_ID(FsmCbOptions& options)
12990   {
12991     static DOMStringPtr myName = new DOMString("ID");
12992     static DOMStringPtr myNsUri = NULL;
12993
12994     if(_attr_ID) {
12995       return _attr_ID;
12996     }
12997     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
12998     GenoPro::Occupations::Occupation::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
12999
13000     if(options.isSampleCreate && (node->stringValue() == "") ) {
13001       node->stringValue(node->sampleValue());
13002     }
13003
13004     _attr_ID = node;
13005
13006     return node;
13007   }
13008
13009
13010     void GenoPro::Occupations::Occupation::set_attr_ID(DOMString val)
13011     {
13012
13013       attribute_attr_ID()->stringValue(val);
13014     }
13015
13016     DOMString GenoPro::Occupations::Occupation::get_attr_ID_string()
13017     {
13018
13019       return attribute_attr_ID()->stringValue();
13020     }
13021
13022
13023   GenoPro::Occupations::Occupation::attr_ID_p GenoPro::Occupations::Occupation::attribute_attr_ID()
13024   {
13025     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
13026     return _attr_ID;
13027   }
13028
13029   //constructor
13030   GenoPro::Occupations::Occupation::sequence::sequence(Occupation* that):
13031     _that(that)
13032   {
13033     XsdFsmBasePtr fsmArray[] = {
13034     new XsdFSM<Title_ptr>( Particle(new DOMString("libgno"), DOMString("Title"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Title_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_Title)),
13035       new XsdFSM<Company_ptr>( Particle(new DOMString("libgno"), DOMString("Company"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Company_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_Company)),
13036       new XsdFSM<Industry_ptr>( Particle(new DOMString("libgno"), DOMString("Industry"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Industry_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_Industry)),
13037       new XsdFSM<Place_ptr>( Particle(new DOMString("libgno"), DOMString("Place"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Place_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_Place)),
13038       new XsdFSM<Source_ptr>( Particle(new DOMString("libgno"), DOMString("Source"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Source_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_Source)),
13039       new XsdFSM<DateStart_ptr>( Particle(new DOMString("libgno"), DOMString("DateStart"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateStart_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_DateStart)),
13040       new XsdFSM<DateEnd_ptr>( Particle(new DOMString("libgno"), DOMString("DateEnd"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateEnd_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_DateEnd)),
13041       new XsdFSM<WorkType_ptr>( Particle(new DOMString("libgno"), DOMString("WorkType"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<WorkType_ptr, Occupation, FsmCbOptions>(_that, &Occupation::create_WorkType)),
13042
13043       NULL
13044     } ;
13045
13046     XsdSequenceFsmOfFSMs::init(fsmArray);
13047   }
13048
13049
13050
13051   GenoPro::Occupations::Occupation::Title_p GenoPro::Occupations::Occupation::sequence::element_Title()
13052   {
13053       GenoPro::Occupations::Occupation::Title_p node_p = NULL;
13054     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
13055     if(fsm_p)
13056     {
13057       XsdFSM<Title_ptr> *unitFsm = dynamic_cast<XsdFSM<Title_ptr> *>(fsm_p);
13058       if(unitFsm && unitFsm->nodeList().size()>0) {
13059         assert(unitFsm->nodeList().size()==1);
13060         node_p = unitFsm->nodeList().at(0);
13061       }
13062     }
13063
13064     FSM::warnNullNode(node_p, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
13065     return node_p;
13066
13067   }
13068
13069
13070   void GenoPro::Occupations::Occupation::sequence::set_Title(DOMString val)
13071   {
13072
13073     mark_present_Title();
13074
13075     element_Title()->stringValue(val);
13076   }
13077
13078   DOMString GenoPro::Occupations::Occupation::sequence::get_Title_string()
13079   {
13080     return element_Title()->stringValue();
13081   }
13082
13083
13084
13085   void GenoPro::Occupations::Occupation::sequence::mark_present_Title()
13086   {
13087     DOMStringPtr nsUriPtr = new DOMString("libgno");
13088     XsdEvent event(nsUriPtr, NULL, DOMString("Title"), XsdEvent::ELEMENT_START, false);
13089     this->processEventThrow(event);
13090   }
13091
13092
13093
13094   GenoPro::Occupations::Occupation::Company_p GenoPro::Occupations::Occupation::sequence::element_Company()
13095   {
13096       GenoPro::Occupations::Occupation::Company_p node_p = NULL;
13097     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
13098     if(fsm_p)
13099     {
13100       XsdFSM<Company_ptr> *unitFsm = dynamic_cast<XsdFSM<Company_ptr> *>(fsm_p);
13101       if(unitFsm && unitFsm->nodeList().size()>0) {
13102         assert(unitFsm->nodeList().size()==1);
13103         node_p = unitFsm->nodeList().at(0);
13104       }
13105     }
13106
13107     FSM::warnNullNode(node_p, "Company", "{http://www.w3.org/2001/XMLSchema}Company", 0);
13108     return node_p;
13109
13110   }
13111
13112
13113   void GenoPro::Occupations::Occupation::sequence::set_Company(DOMString val)
13114   {
13115
13116     mark_present_Company();
13117
13118     element_Company()->stringValue(val);
13119   }
13120
13121   DOMString GenoPro::Occupations::Occupation::sequence::get_Company_string()
13122   {
13123     return element_Company()->stringValue();
13124   }
13125
13126
13127
13128   void GenoPro::Occupations::Occupation::sequence::mark_present_Company()
13129   {
13130     DOMStringPtr nsUriPtr = new DOMString("libgno");
13131     XsdEvent event(nsUriPtr, NULL, DOMString("Company"), XsdEvent::ELEMENT_START, false);
13132     this->processEventThrow(event);
13133   }
13134
13135
13136
13137   GenoPro::Occupations::Occupation::Industry_p GenoPro::Occupations::Occupation::sequence::element_Industry()
13138   {
13139       GenoPro::Occupations::Occupation::Industry_p node_p = NULL;
13140     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
13141     if(fsm_p)
13142     {
13143       XsdFSM<Industry_ptr> *unitFsm = dynamic_cast<XsdFSM<Industry_ptr> *>(fsm_p);
13144       if(unitFsm && unitFsm->nodeList().size()>0) {
13145         assert(unitFsm->nodeList().size()==1);
13146         node_p = unitFsm->nodeList().at(0);
13147       }
13148     }
13149
13150     FSM::warnNullNode(node_p, "Industry", "{http://www.w3.org/2001/XMLSchema}Industry", 0);
13151     return node_p;
13152
13153   }
13154
13155
13156   void GenoPro::Occupations::Occupation::sequence::set_Industry(DOMString val)
13157   {
13158
13159     mark_present_Industry();
13160
13161     element_Industry()->stringValue(val);
13162   }
13163
13164   DOMString GenoPro::Occupations::Occupation::sequence::get_Industry_string()
13165   {
13166     return element_Industry()->stringValue();
13167   }
13168
13169
13170
13171   void GenoPro::Occupations::Occupation::sequence::mark_present_Industry()
13172   {
13173     DOMStringPtr nsUriPtr = new DOMString("libgno");
13174     XsdEvent event(nsUriPtr, NULL, DOMString("Industry"), XsdEvent::ELEMENT_START, false);
13175     this->processEventThrow(event);
13176   }
13177
13178
13179
13180   GenoPro::Occupations::Occupation::Place_p GenoPro::Occupations::Occupation::sequence::element_Place()
13181   {
13182       GenoPro::Occupations::Occupation::Place_p node_p = NULL;
13183     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
13184     if(fsm_p)
13185     {
13186       XsdFSM<Place_ptr> *unitFsm = dynamic_cast<XsdFSM<Place_ptr> *>(fsm_p);
13187       if(unitFsm && unitFsm->nodeList().size()>0) {
13188         assert(unitFsm->nodeList().size()==1);
13189         node_p = unitFsm->nodeList().at(0);
13190       }
13191     }
13192
13193     FSM::warnNullNode(node_p, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
13194     return node_p;
13195
13196   }
13197
13198
13199   void GenoPro::Occupations::Occupation::sequence::set_Place(DOMString val)
13200   {
13201
13202     mark_present_Place();
13203
13204     element_Place()->stringValue(val);
13205   }
13206
13207   DOMString GenoPro::Occupations::Occupation::sequence::get_Place_string()
13208   {
13209     return element_Place()->stringValue();
13210   }
13211
13212
13213
13214   void GenoPro::Occupations::Occupation::sequence::mark_present_Place()
13215   {
13216     DOMStringPtr nsUriPtr = new DOMString("libgno");
13217     XsdEvent event(nsUriPtr, NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
13218     this->processEventThrow(event);
13219   }
13220
13221
13222
13223   GenoPro::Occupations::Occupation::Source_p GenoPro::Occupations::Occupation::sequence::element_Source()
13224   {
13225       GenoPro::Occupations::Occupation::Source_p node_p = NULL;
13226     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
13227     if(fsm_p)
13228     {
13229       XsdFSM<Source_ptr> *unitFsm = dynamic_cast<XsdFSM<Source_ptr> *>(fsm_p);
13230       if(unitFsm && unitFsm->nodeList().size()>0) {
13231         assert(unitFsm->nodeList().size()==1);
13232         node_p = unitFsm->nodeList().at(0);
13233       }
13234     }
13235
13236     FSM::warnNullNode(node_p, "Source", "{http://www.w3.org/2001/XMLSchema}Source", 0);
13237     return node_p;
13238
13239   }
13240
13241
13242   void GenoPro::Occupations::Occupation::sequence::set_Source(DOMString val)
13243   {
13244
13245     mark_present_Source();
13246
13247     element_Source()->stringValue(val);
13248   }
13249
13250   DOMString GenoPro::Occupations::Occupation::sequence::get_Source_string()
13251   {
13252     return element_Source()->stringValue();
13253   }
13254
13255
13256
13257   void GenoPro::Occupations::Occupation::sequence::mark_present_Source()
13258   {
13259     DOMStringPtr nsUriPtr = new DOMString("libgno");
13260     XsdEvent event(nsUriPtr, NULL, DOMString("Source"), XsdEvent::ELEMENT_START, false);
13261     this->processEventThrow(event);
13262   }
13263
13264
13265
13266   GenoPro::Occupations::Occupation::DateStart_p GenoPro::Occupations::Occupation::sequence::element_DateStart()
13267   {
13268       GenoPro::Occupations::Occupation::DateStart_p node_p = NULL;
13269     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
13270     if(fsm_p)
13271     {
13272       XsdFSM<DateStart_ptr> *unitFsm = dynamic_cast<XsdFSM<DateStart_ptr> *>(fsm_p);
13273       if(unitFsm && unitFsm->nodeList().size()>0) {
13274         assert(unitFsm->nodeList().size()==1);
13275         node_p = unitFsm->nodeList().at(0);
13276       }
13277     }
13278
13279     FSM::warnNullNode(node_p, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
13280     return node_p;
13281
13282   }
13283
13284
13285   void GenoPro::Occupations::Occupation::sequence::set_DateStart(DOMString val)
13286   {
13287
13288     mark_present_DateStart();
13289
13290     element_DateStart()->stringValue(val);
13291   }
13292
13293   DOMString GenoPro::Occupations::Occupation::sequence::get_DateStart_string()
13294   {
13295     return element_DateStart()->stringValue();
13296   }
13297
13298
13299
13300   void GenoPro::Occupations::Occupation::sequence::mark_present_DateStart()
13301   {
13302     DOMStringPtr nsUriPtr = new DOMString("libgno");
13303     XsdEvent event(nsUriPtr, NULL, DOMString("DateStart"), XsdEvent::ELEMENT_START, false);
13304     this->processEventThrow(event);
13305   }
13306
13307
13308
13309   GenoPro::Occupations::Occupation::DateEnd_p GenoPro::Occupations::Occupation::sequence::element_DateEnd()
13310   {
13311       GenoPro::Occupations::Occupation::DateEnd_p node_p = NULL;
13312     XsdFsmBase* fsm_p = this->allFSMs()[6].get();
13313     if(fsm_p)
13314     {
13315       XsdFSM<DateEnd_ptr> *unitFsm = dynamic_cast<XsdFSM<DateEnd_ptr> *>(fsm_p);
13316       if(unitFsm && unitFsm->nodeList().size()>0) {
13317         assert(unitFsm->nodeList().size()==1);
13318         node_p = unitFsm->nodeList().at(0);
13319       }
13320     }
13321
13322     FSM::warnNullNode(node_p, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
13323     return node_p;
13324
13325   }
13326
13327
13328   void GenoPro::Occupations::Occupation::sequence::set_DateEnd(DOMString val)
13329   {
13330
13331     mark_present_DateEnd();
13332
13333     element_DateEnd()->stringValue(val);
13334   }
13335
13336   DOMString GenoPro::Occupations::Occupation::sequence::get_DateEnd_string()
13337   {
13338     return element_DateEnd()->stringValue();
13339   }
13340
13341
13342
13343   void GenoPro::Occupations::Occupation::sequence::mark_present_DateEnd()
13344   {
13345     DOMStringPtr nsUriPtr = new DOMString("libgno");
13346     XsdEvent event(nsUriPtr, NULL, DOMString("DateEnd"), XsdEvent::ELEMENT_START, false);
13347     this->processEventThrow(event);
13348   }
13349
13350
13351
13352   GenoPro::Occupations::Occupation::WorkType_p GenoPro::Occupations::Occupation::sequence::element_WorkType()
13353   {
13354       GenoPro::Occupations::Occupation::WorkType_p node_p = NULL;
13355     XsdFsmBase* fsm_p = this->allFSMs()[7].get();
13356     if(fsm_p)
13357     {
13358       XsdFSM<WorkType_ptr> *unitFsm = dynamic_cast<XsdFSM<WorkType_ptr> *>(fsm_p);
13359       if(unitFsm && unitFsm->nodeList().size()>0) {
13360         assert(unitFsm->nodeList().size()==1);
13361         node_p = unitFsm->nodeList().at(0);
13362       }
13363     }
13364
13365     FSM::warnNullNode(node_p, "WorkType", "{http://www.w3.org/2001/XMLSchema}WorkType", 0);
13366     return node_p;
13367
13368   }
13369
13370
13371   void GenoPro::Occupations::Occupation::sequence::set_WorkType(DOMString val)
13372   {
13373
13374     mark_present_WorkType();
13375
13376     element_WorkType()->stringValue(val);
13377   }
13378
13379   DOMString GenoPro::Occupations::Occupation::sequence::get_WorkType_string()
13380   {
13381     return element_WorkType()->stringValue();
13382   }
13383
13384
13385
13386   void GenoPro::Occupations::Occupation::sequence::mark_present_WorkType()
13387   {
13388     DOMStringPtr nsUriPtr = new DOMString("libgno");
13389     XsdEvent event(nsUriPtr, NULL, DOMString("WorkType"), XsdEvent::ELEMENT_START, false);
13390     this->processEventThrow(event);
13391   }
13392
13393
13394
13395   //constructor
13396
13397   GenoPro::Contacts::Contacts(ElementCreateArgs args):
13398       XMLSchema::XmlElement<anyType>(args),
13399
13400     _fsmAttrs(NULL),
13401     _fsmElems(NULL)
13402
13403     , _sequence(new sequence(this) )
13404
13405   {
13406     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
13407     initFSM();
13408     if(args.ownerDoc && args.ownerDoc->buildTree())
13409     {
13410       if(args.ownerDoc->createSample()) {
13411         _fsm->fireSampleEvents();
13412       }
13413       else {
13414         _fsm->fireRequiredEvents();
13415       }
13416     }
13417   }
13418
13419   void GenoPro::Contacts::initFSM()
13420   {
13421     XsdFsmBasePtr fsmsAttrs[] = {
13422
13423       NULL
13424     };
13425
13426     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
13427
13428     _fsm->replaceContentFsm(_sequence);
13429
13430     _fsmAttrs = _fsm->attributeFsm();
13431     _fsmElems = _fsm->contentFsm();
13432
13433   }
13434
13435   /* element functions  */
13436
13437
13438   GenoPro::Contacts::Contact_ptr GenoPro::Contacts::create_Contact(FsmCbOptions& options)
13439   {
13440     static DOMStringPtr myName = new DOMString("Contact");
13441     static DOMStringPtr myNsUri = new DOMString("libgno");
13442
13443     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
13444     GenoPro::Contacts::Contact_p node = XSD::createElementTmpl<Contact, void*>(t);
13445
13446     _list_Contact.push_back(node);
13447
13448     return node;
13449   }
13450
13451
13452   GenoPro::Contacts::Contact_p GenoPro::Contacts::element_Contact_at(unsigned int idx)
13453   {
13454     if(idx > _list_Contact.size()-1) {
13455       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
13456     }
13457
13458     return _list_Contact.at(idx);
13459   }
13460
13461   List<GenoPro::Contacts::Contact_ptr> GenoPro::Contacts::elements_Contact()
13462   {
13463     return _list_Contact;
13464   }
13465
13466   GenoPro::Contacts::Contact_p GenoPro::Contacts::add_node_Contact()
13467   {
13468     return get_sequence()->add_node_Contact();
13469   }
13470
13471   List<GenoPro::Contacts::Contact_ptr> GenoPro::Contacts::set_count_Contact(unsigned int size)
13472   {
13473     return get_sequence()->set_count_Contact(size);
13474   }
13475
13476
13477
13478   /* attribute  functions  */
13479
13480   //constructor
13481   GenoPro::Contacts::sequence::sequence(Contacts* that):
13482     _that(that)
13483   {
13484     XsdFsmBasePtr fsmArray[] = {
13485     new XsdFSM<Contact_ptr>( Particle(new DOMString("libgno"), DOMString("Contact"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Contact_ptr, Contacts, FsmCbOptions>(_that, &Contacts::create_Contact)),
13486
13487       NULL
13488     } ;
13489
13490     XsdSequenceFsmOfFSMs::init(fsmArray);
13491   }
13492
13493
13494
13495   List<GenoPro::Contacts::Contact_ptr> GenoPro::Contacts::sequence::elements_Contact()
13496   {
13497
13498     List<Contact_ptr> nodeList;
13499     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
13500     if(fsm_p)
13501     {
13502       XsdFSM<Contact_ptr> *unitFsm = dynamic_cast<XsdFSM<Contact_ptr> *>(fsm_p);
13503       if(unitFsm) {
13504         //nodeList = unitFsm->nodeList().stl_list();
13505         nodeList = unitFsm->nodeList();
13506       }
13507     }
13508     return nodeList;
13509
13510   }
13511
13512
13513   GenoPro::Contacts::Contact_p GenoPro::Contacts::sequence::element_Contact_at(unsigned int idx)
13514   {
13515     return elements_Contact().at(idx);
13516   }
13517
13518
13519   GenoPro::Contacts::Contact_p GenoPro::Contacts::sequence::add_node_Contact()
13520   {
13521     DOMStringPtr nsUriPtr = new DOMString("libgno");
13522     XsdEvent event(nsUriPtr, NULL, DOMString("Contact"), XsdEvent::ELEMENT_START, false);
13523     this->processEventThrow(event);
13524     return elements_Contact().back();
13525   }
13526
13527   List<GenoPro::Contacts::Contact_ptr> GenoPro::Contacts::sequence::set_count_Contact(unsigned int size)
13528   {
13529     if( (size > -1) || (size < 1)) {
13530       ostringstream oss;
13531       oss << "set_count_Contact: size should be in range: [" << 1
13532         << "," << "unbounded" << "]";
13533       throw IndexOutOfBoundsException(oss.str());
13534     }
13535
13536     unsigned int prevSize = elements_Contact().size();
13537     if(size < prevSize) {
13538       //FIXME: allow later:
13539       throw XPlus::RuntimeException("resize lesser than current size not allowed");
13540     }
13541
13542     for(unsigned int j=prevSize; j<size; j++)
13543     {
13544       // pretend docBuilding to avoid computation of adding after first loop
13545       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Contact"), XsdEvent::ELEMENT_START, false);
13546       this->processEventThrow(event);
13547     }
13548
13549     return elements_Contact();
13550   }
13551
13552
13553
13554   //constructor
13555
13556   GenoPro::Contacts::Contact::Contact(ElementCreateArgs args):
13557       XMLSchema::XmlElement<anyType>(args),
13558
13559     _fsmAttrs(NULL),
13560     _fsmElems(NULL)
13561
13562     , _sequence(new sequence(this) )
13563
13564   {
13565     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
13566     initFSM();
13567     if(args.ownerDoc && args.ownerDoc->buildTree())
13568     {
13569       if(args.ownerDoc->createSample()) {
13570         _fsm->fireSampleEvents();
13571       }
13572       else {
13573         _fsm->fireRequiredEvents();
13574       }
13575     }
13576   }
13577
13578   void GenoPro::Contacts::Contact::initFSM()
13579   {
13580     XsdFsmBasePtr fsmsAttrs[] = {
13581   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Contact, FsmCbOptions>(this, &Contact::create_attr_ID)),
13582
13583       NULL
13584     };
13585
13586     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
13587
13588     _fsm->replaceContentFsm(_sequence);
13589
13590     _fsmAttrs = _fsm->attributeFsm();
13591     _fsmElems = _fsm->contentFsm();
13592
13593   }
13594
13595   /* element functions  */
13596
13597
13598   GenoPro::Contacts::Contact::Place_ptr GenoPro::Contacts::Contact::create_Place(FsmCbOptions& options)
13599   {
13600     static DOMStringPtr myName = new DOMString("Place");
13601     static DOMStringPtr myNsUri = new DOMString("libgno");
13602
13603     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
13604     GenoPro::Contacts::Contact::Place_p node = XSD::createElementTmpl<Place, XMLSchema::Types::bt_normalizedString*>(t);
13605
13606     if(options.isSampleCreate && (node->stringValue() == "") ) {
13607       node->stringValue(node->sampleValue());
13608     }
13609
13610     _Place = node;
13611
13612     return node;
13613   }
13614
13615
13616   GenoPro::Contacts::Contact::Place_p GenoPro::Contacts::Contact::element_Place()
13617   {
13618     FSM::warnNullNode(_Place, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
13619     return _Place;
13620   }
13621
13622   void GenoPro::Contacts::Contact::set_Place(DOMString val)
13623   {
13624     get_sequence()->set_Place(val);
13625   }
13626
13627   DOMString GenoPro::Contacts::Contact::get_Place_string()
13628   {
13629     return get_sequence()->get_Place_string();
13630   }
13631
13632
13633   void GenoPro::Contacts::Contact::mark_present_Place()
13634   {
13635     return get_sequence()->mark_present_Place();
13636   }
13637
13638
13639   GenoPro::Contacts::Contact::Source_ptr GenoPro::Contacts::Contact::create_Source(FsmCbOptions& options)
13640   {
13641     static DOMStringPtr myName = new DOMString("Source");
13642     static DOMStringPtr myNsUri = new DOMString("libgno");
13643
13644     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
13645     GenoPro::Contacts::Contact::Source_p node = XSD::createElementTmpl<Source, XMLSchema::Types::bt_normalizedString*>(t);
13646
13647     if(options.isSampleCreate && (node->stringValue() == "") ) {
13648       node->stringValue(node->sampleValue());
13649     }
13650
13651     _Source = node;
13652
13653     return node;
13654   }
13655
13656
13657   GenoPro::Contacts::Contact::Source_p GenoPro::Contacts::Contact::element_Source()
13658   {
13659     FSM::warnNullNode(_Source, "Source", "{http://www.w3.org/2001/XMLSchema}Source", 0);
13660     return _Source;
13661   }
13662
13663   void GenoPro::Contacts::Contact::set_Source(DOMString val)
13664   {
13665     get_sequence()->set_Source(val);
13666   }
13667
13668   DOMString GenoPro::Contacts::Contact::get_Source_string()
13669   {
13670     return get_sequence()->get_Source_string();
13671   }
13672
13673
13674   void GenoPro::Contacts::Contact::mark_present_Source()
13675   {
13676     return get_sequence()->mark_present_Source();
13677   }
13678
13679
13680   GenoPro::Contacts::Contact::Comment_ptr GenoPro::Contacts::Contact::create_Comment(FsmCbOptions& options)
13681   {
13682     static DOMStringPtr myName = new DOMString("Comment");
13683     static DOMStringPtr myNsUri = new DOMString("libgno");
13684
13685     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
13686     GenoPro::Contacts::Contact::Comment_p node = XSD::createElementTmpl<Comment, XMLSchema::Types::bt_string*>(t);
13687
13688     if(options.isSampleCreate && (node->stringValue() == "") ) {
13689       node->stringValue(node->sampleValue());
13690     }
13691
13692     _Comment = node;
13693
13694     return node;
13695   }
13696
13697
13698   GenoPro::Contacts::Contact::Comment_p GenoPro::Contacts::Contact::element_Comment()
13699   {
13700     FSM::warnNullNode(_Comment, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
13701     return _Comment;
13702   }
13703
13704   void GenoPro::Contacts::Contact::set_Comment(DOMString val)
13705   {
13706     get_sequence()->set_Comment(val);
13707   }
13708
13709   DOMString GenoPro::Contacts::Contact::get_Comment_string()
13710   {
13711     return get_sequence()->get_Comment_string();
13712   }
13713
13714
13715   void GenoPro::Contacts::Contact::mark_present_Comment()
13716   {
13717     return get_sequence()->mark_present_Comment();
13718   }
13719
13720
13721   GenoPro::Contacts::Contact::Type_ptr GenoPro::Contacts::Contact::create_Type(FsmCbOptions& options)
13722   {
13723     static DOMStringPtr myName = new DOMString("Type");
13724     static DOMStringPtr myNsUri = new DOMString("libgno");
13725
13726     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
13727     GenoPro::Contacts::Contact::Type_p node = XSD::createElementTmpl<Type, XMLSchema::Types::bt_normalizedString*>(t);
13728
13729     if(options.isSampleCreate && (node->stringValue() == "") ) {
13730       node->stringValue(node->sampleValue());
13731     }
13732
13733     _Type = node;
13734
13735     return node;
13736   }
13737
13738
13739   GenoPro::Contacts::Contact::Type_p GenoPro::Contacts::Contact::element_Type()
13740   {
13741     FSM::warnNullNode(_Type, "Type", "{http://www.w3.org/2001/XMLSchema}Type", 0);
13742     return _Type;
13743   }
13744
13745   void GenoPro::Contacts::Contact::set_Type(DOMString val)
13746   {
13747     get_sequence()->set_Type(val);
13748   }
13749
13750   DOMString GenoPro::Contacts::Contact::get_Type_string()
13751   {
13752     return get_sequence()->get_Type_string();
13753   }
13754
13755
13756   void GenoPro::Contacts::Contact::mark_present_Type()
13757   {
13758     return get_sequence()->mark_present_Type();
13759   }
13760
13761
13762   GenoPro::Contacts::Contact::DateStart_ptr GenoPro::Contacts::Contact::create_DateStart(FsmCbOptions& options)
13763   {
13764     static DOMStringPtr myName = new DOMString("DateStart");
13765     static DOMStringPtr myNsUri = new DOMString("libgno");
13766
13767     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
13768     GenoPro::Contacts::Contact::DateStart_p node = XSD::createElementTmpl<DateStart, XMLSchema::Types::bt_string*>(t);
13769
13770     if(options.isSampleCreate && (node->stringValue() == "") ) {
13771       node->stringValue(node->sampleValue());
13772     }
13773
13774     _DateStart = node;
13775
13776     return node;
13777   }
13778
13779
13780   GenoPro::Contacts::Contact::DateStart_p GenoPro::Contacts::Contact::element_DateStart()
13781   {
13782     FSM::warnNullNode(_DateStart, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
13783     return _DateStart;
13784   }
13785
13786   void GenoPro::Contacts::Contact::set_DateStart(DOMString val)
13787   {
13788     get_sequence()->set_DateStart(val);
13789   }
13790
13791   DOMString GenoPro::Contacts::Contact::get_DateStart_string()
13792   {
13793     return get_sequence()->get_DateStart_string();
13794   }
13795
13796
13797   void GenoPro::Contacts::Contact::mark_present_DateStart()
13798   {
13799     return get_sequence()->mark_present_DateStart();
13800   }
13801
13802
13803   GenoPro::Contacts::Contact::DateEnd_ptr GenoPro::Contacts::Contact::create_DateEnd(FsmCbOptions& options)
13804   {
13805     static DOMStringPtr myName = new DOMString("DateEnd");
13806     static DOMStringPtr myNsUri = new DOMString("libgno");
13807
13808     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
13809     GenoPro::Contacts::Contact::DateEnd_p node = XSD::createElementTmpl<DateEnd, XMLSchema::Types::bt_string*>(t);
13810
13811     if(options.isSampleCreate && (node->stringValue() == "") ) {
13812       node->stringValue(node->sampleValue());
13813     }
13814
13815     _DateEnd = node;
13816
13817     return node;
13818   }
13819
13820
13821   GenoPro::Contacts::Contact::DateEnd_p GenoPro::Contacts::Contact::element_DateEnd()
13822   {
13823     FSM::warnNullNode(_DateEnd, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
13824     return _DateEnd;
13825   }
13826
13827   void GenoPro::Contacts::Contact::set_DateEnd(DOMString val)
13828   {
13829     get_sequence()->set_DateEnd(val);
13830   }
13831
13832   DOMString GenoPro::Contacts::Contact::get_DateEnd_string()
13833   {
13834     return get_sequence()->get_DateEnd_string();
13835   }
13836
13837
13838   void GenoPro::Contacts::Contact::mark_present_DateEnd()
13839   {
13840     return get_sequence()->mark_present_DateEnd();
13841   }
13842
13843
13844   /* attribute  functions  */
13845
13846
13847   GenoPro::Contacts::Contact::attr_ID_ptr GenoPro::Contacts::Contact::create_attr_ID(FsmCbOptions& options)
13848   {
13849     static DOMStringPtr myName = new DOMString("ID");
13850     static DOMStringPtr myNsUri = NULL;
13851
13852     if(_attr_ID) {
13853       return _attr_ID;
13854     }
13855     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
13856     GenoPro::Contacts::Contact::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
13857
13858     if(options.isSampleCreate && (node->stringValue() == "") ) {
13859       node->stringValue(node->sampleValue());
13860     }
13861
13862     _attr_ID = node;
13863
13864     return node;
13865   }
13866
13867
13868     void GenoPro::Contacts::Contact::set_attr_ID(DOMString val)
13869     {
13870
13871       attribute_attr_ID()->stringValue(val);
13872     }
13873
13874     DOMString GenoPro::Contacts::Contact::get_attr_ID_string()
13875     {
13876
13877       return attribute_attr_ID()->stringValue();
13878     }
13879
13880
13881   GenoPro::Contacts::Contact::attr_ID_p GenoPro::Contacts::Contact::attribute_attr_ID()
13882   {
13883     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
13884     return _attr_ID;
13885   }
13886
13887   //constructor
13888   GenoPro::Contacts::Contact::sequence::sequence(Contact* that):
13889     _that(that)
13890   {
13891     XsdFsmBasePtr fsmArray[] = {
13892     new XsdFSM<Place_ptr>( Particle(new DOMString("libgno"), DOMString("Place"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Place_ptr, Contact, FsmCbOptions>(_that, &Contact::create_Place)),
13893       new XsdFSM<Source_ptr>( Particle(new DOMString("libgno"), DOMString("Source"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Source_ptr, Contact, FsmCbOptions>(_that, &Contact::create_Source)),
13894       new XsdFSM<Comment_ptr>( Particle(new DOMString("libgno"), DOMString("Comment"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Comment_ptr, Contact, FsmCbOptions>(_that, &Contact::create_Comment)),
13895       new XsdFSM<Type_ptr>( Particle(new DOMString("libgno"), DOMString("Type"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Type_ptr, Contact, FsmCbOptions>(_that, &Contact::create_Type)),
13896       new XsdFSM<DateStart_ptr>( Particle(new DOMString("libgno"), DOMString("DateStart"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateStart_ptr, Contact, FsmCbOptions>(_that, &Contact::create_DateStart)),
13897       new XsdFSM<DateEnd_ptr>( Particle(new DOMString("libgno"), DOMString("DateEnd"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<DateEnd_ptr, Contact, FsmCbOptions>(_that, &Contact::create_DateEnd)),
13898
13899       NULL
13900     } ;
13901
13902     XsdSequenceFsmOfFSMs::init(fsmArray);
13903   }
13904
13905
13906
13907   GenoPro::Contacts::Contact::Place_p GenoPro::Contacts::Contact::sequence::element_Place()
13908   {
13909       GenoPro::Contacts::Contact::Place_p node_p = NULL;
13910     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
13911     if(fsm_p)
13912     {
13913       XsdFSM<Place_ptr> *unitFsm = dynamic_cast<XsdFSM<Place_ptr> *>(fsm_p);
13914       if(unitFsm && unitFsm->nodeList().size()>0) {
13915         assert(unitFsm->nodeList().size()==1);
13916         node_p = unitFsm->nodeList().at(0);
13917       }
13918     }
13919
13920     FSM::warnNullNode(node_p, "Place", "{http://www.w3.org/2001/XMLSchema}Place", 0);
13921     return node_p;
13922
13923   }
13924
13925
13926   void GenoPro::Contacts::Contact::sequence::set_Place(DOMString val)
13927   {
13928
13929     mark_present_Place();
13930
13931     element_Place()->stringValue(val);
13932   }
13933
13934   DOMString GenoPro::Contacts::Contact::sequence::get_Place_string()
13935   {
13936     return element_Place()->stringValue();
13937   }
13938
13939
13940
13941   void GenoPro::Contacts::Contact::sequence::mark_present_Place()
13942   {
13943     DOMStringPtr nsUriPtr = new DOMString("libgno");
13944     XsdEvent event(nsUriPtr, NULL, DOMString("Place"), XsdEvent::ELEMENT_START, false);
13945     this->processEventThrow(event);
13946   }
13947
13948
13949
13950   GenoPro::Contacts::Contact::Source_p GenoPro::Contacts::Contact::sequence::element_Source()
13951   {
13952       GenoPro::Contacts::Contact::Source_p node_p = NULL;
13953     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
13954     if(fsm_p)
13955     {
13956       XsdFSM<Source_ptr> *unitFsm = dynamic_cast<XsdFSM<Source_ptr> *>(fsm_p);
13957       if(unitFsm && unitFsm->nodeList().size()>0) {
13958         assert(unitFsm->nodeList().size()==1);
13959         node_p = unitFsm->nodeList().at(0);
13960       }
13961     }
13962
13963     FSM::warnNullNode(node_p, "Source", "{http://www.w3.org/2001/XMLSchema}Source", 0);
13964     return node_p;
13965
13966   }
13967
13968
13969   void GenoPro::Contacts::Contact::sequence::set_Source(DOMString val)
13970   {
13971
13972     mark_present_Source();
13973
13974     element_Source()->stringValue(val);
13975   }
13976
13977   DOMString GenoPro::Contacts::Contact::sequence::get_Source_string()
13978   {
13979     return element_Source()->stringValue();
13980   }
13981
13982
13983
13984   void GenoPro::Contacts::Contact::sequence::mark_present_Source()
13985   {
13986     DOMStringPtr nsUriPtr = new DOMString("libgno");
13987     XsdEvent event(nsUriPtr, NULL, DOMString("Source"), XsdEvent::ELEMENT_START, false);
13988     this->processEventThrow(event);
13989   }
13990
13991
13992
13993   GenoPro::Contacts::Contact::Comment_p GenoPro::Contacts::Contact::sequence::element_Comment()
13994   {
13995       GenoPro::Contacts::Contact::Comment_p node_p = NULL;
13996     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
13997     if(fsm_p)
13998     {
13999       XsdFSM<Comment_ptr> *unitFsm = dynamic_cast<XsdFSM<Comment_ptr> *>(fsm_p);
14000       if(unitFsm && unitFsm->nodeList().size()>0) {
14001         assert(unitFsm->nodeList().size()==1);
14002         node_p = unitFsm->nodeList().at(0);
14003       }
14004     }
14005
14006     FSM::warnNullNode(node_p, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
14007     return node_p;
14008
14009   }
14010
14011
14012   void GenoPro::Contacts::Contact::sequence::set_Comment(DOMString val)
14013   {
14014
14015     mark_present_Comment();
14016
14017     element_Comment()->stringValue(val);
14018   }
14019
14020   DOMString GenoPro::Contacts::Contact::sequence::get_Comment_string()
14021   {
14022     return element_Comment()->stringValue();
14023   }
14024
14025
14026
14027   void GenoPro::Contacts::Contact::sequence::mark_present_Comment()
14028   {
14029     DOMStringPtr nsUriPtr = new DOMString("libgno");
14030     XsdEvent event(nsUriPtr, NULL, DOMString("Comment"), XsdEvent::ELEMENT_START, false);
14031     this->processEventThrow(event);
14032   }
14033
14034
14035
14036   GenoPro::Contacts::Contact::Type_p GenoPro::Contacts::Contact::sequence::element_Type()
14037   {
14038       GenoPro::Contacts::Contact::Type_p node_p = NULL;
14039     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
14040     if(fsm_p)
14041     {
14042       XsdFSM<Type_ptr> *unitFsm = dynamic_cast<XsdFSM<Type_ptr> *>(fsm_p);
14043       if(unitFsm && unitFsm->nodeList().size()>0) {
14044         assert(unitFsm->nodeList().size()==1);
14045         node_p = unitFsm->nodeList().at(0);
14046       }
14047     }
14048
14049     FSM::warnNullNode(node_p, "Type", "{http://www.w3.org/2001/XMLSchema}Type", 0);
14050     return node_p;
14051
14052   }
14053
14054
14055   void GenoPro::Contacts::Contact::sequence::set_Type(DOMString val)
14056   {
14057
14058     mark_present_Type();
14059
14060     element_Type()->stringValue(val);
14061   }
14062
14063   DOMString GenoPro::Contacts::Contact::sequence::get_Type_string()
14064   {
14065     return element_Type()->stringValue();
14066   }
14067
14068
14069
14070   void GenoPro::Contacts::Contact::sequence::mark_present_Type()
14071   {
14072     DOMStringPtr nsUriPtr = new DOMString("libgno");
14073     XsdEvent event(nsUriPtr, NULL, DOMString("Type"), XsdEvent::ELEMENT_START, false);
14074     this->processEventThrow(event);
14075   }
14076
14077
14078
14079   GenoPro::Contacts::Contact::DateStart_p GenoPro::Contacts::Contact::sequence::element_DateStart()
14080   {
14081       GenoPro::Contacts::Contact::DateStart_p node_p = NULL;
14082     XsdFsmBase* fsm_p = this->allFSMs()[4].get();
14083     if(fsm_p)
14084     {
14085       XsdFSM<DateStart_ptr> *unitFsm = dynamic_cast<XsdFSM<DateStart_ptr> *>(fsm_p);
14086       if(unitFsm && unitFsm->nodeList().size()>0) {
14087         assert(unitFsm->nodeList().size()==1);
14088         node_p = unitFsm->nodeList().at(0);
14089       }
14090     }
14091
14092     FSM::warnNullNode(node_p, "DateStart", "{http://www.w3.org/2001/XMLSchema}DateStart", 0);
14093     return node_p;
14094
14095   }
14096
14097
14098   void GenoPro::Contacts::Contact::sequence::set_DateStart(DOMString val)
14099   {
14100
14101     mark_present_DateStart();
14102
14103     element_DateStart()->stringValue(val);
14104   }
14105
14106   DOMString GenoPro::Contacts::Contact::sequence::get_DateStart_string()
14107   {
14108     return element_DateStart()->stringValue();
14109   }
14110
14111
14112
14113   void GenoPro::Contacts::Contact::sequence::mark_present_DateStart()
14114   {
14115     DOMStringPtr nsUriPtr = new DOMString("libgno");
14116     XsdEvent event(nsUriPtr, NULL, DOMString("DateStart"), XsdEvent::ELEMENT_START, false);
14117     this->processEventThrow(event);
14118   }
14119
14120
14121
14122   GenoPro::Contacts::Contact::DateEnd_p GenoPro::Contacts::Contact::sequence::element_DateEnd()
14123   {
14124       GenoPro::Contacts::Contact::DateEnd_p node_p = NULL;
14125     XsdFsmBase* fsm_p = this->allFSMs()[5].get();
14126     if(fsm_p)
14127     {
14128       XsdFSM<DateEnd_ptr> *unitFsm = dynamic_cast<XsdFSM<DateEnd_ptr> *>(fsm_p);
14129       if(unitFsm && unitFsm->nodeList().size()>0) {
14130         assert(unitFsm->nodeList().size()==1);
14131         node_p = unitFsm->nodeList().at(0);
14132       }
14133     }
14134
14135     FSM::warnNullNode(node_p, "DateEnd", "{http://www.w3.org/2001/XMLSchema}DateEnd", 0);
14136     return node_p;
14137
14138   }
14139
14140
14141   void GenoPro::Contacts::Contact::sequence::set_DateEnd(DOMString val)
14142   {
14143
14144     mark_present_DateEnd();
14145
14146     element_DateEnd()->stringValue(val);
14147   }
14148
14149   DOMString GenoPro::Contacts::Contact::sequence::get_DateEnd_string()
14150   {
14151     return element_DateEnd()->stringValue();
14152   }
14153
14154
14155
14156   void GenoPro::Contacts::Contact::sequence::mark_present_DateEnd()
14157   {
14158     DOMStringPtr nsUriPtr = new DOMString("libgno");
14159     XsdEvent event(nsUriPtr, NULL, DOMString("DateEnd"), XsdEvent::ELEMENT_START, false);
14160     this->processEventThrow(event);
14161   }
14162
14163
14164
14165   //constructor
14166
14167   GenoPro::SourcesAndCitations::SourcesAndCitations(ElementCreateArgs args):
14168       XMLSchema::XmlElement<anyType>(args),
14169
14170     _fsmAttrs(NULL),
14171     _fsmElems(NULL)
14172
14173     , _sequence(new sequence(this) )
14174
14175   {
14176     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
14177     initFSM();
14178     if(args.ownerDoc && args.ownerDoc->buildTree())
14179     {
14180       if(args.ownerDoc->createSample()) {
14181         _fsm->fireSampleEvents();
14182       }
14183       else {
14184         _fsm->fireRequiredEvents();
14185       }
14186     }
14187   }
14188
14189   void GenoPro::SourcesAndCitations::initFSM()
14190   {
14191     XsdFsmBasePtr fsmsAttrs[] = {
14192
14193       NULL
14194     };
14195
14196     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
14197
14198     _fsm->replaceContentFsm(_sequence);
14199
14200     _fsmAttrs = _fsm->attributeFsm();
14201     _fsmElems = _fsm->contentFsm();
14202
14203   }
14204
14205   /* element functions  */
14206
14207
14208   GenoPro::SourcesAndCitations::SourceCitation_ptr GenoPro::SourcesAndCitations::create_SourceCitation(FsmCbOptions& options)
14209   {
14210     static DOMStringPtr myName = new DOMString("SourceCitation");
14211     static DOMStringPtr myNsUri = new DOMString("libgno");
14212
14213     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
14214     GenoPro::SourcesAndCitations::SourceCitation_p node = XSD::createElementTmpl<SourceCitation, void*>(t);
14215
14216     _list_SourceCitation.push_back(node);
14217
14218     return node;
14219   }
14220
14221
14222   GenoPro::SourcesAndCitations::SourceCitation_p GenoPro::SourcesAndCitations::element_SourceCitation_at(unsigned int idx)
14223   {
14224     if(idx > _list_SourceCitation.size()-1) {
14225       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
14226     }
14227
14228     return _list_SourceCitation.at(idx);
14229   }
14230
14231   List<GenoPro::SourcesAndCitations::SourceCitation_ptr> GenoPro::SourcesAndCitations::elements_SourceCitation()
14232   {
14233     return _list_SourceCitation;
14234   }
14235
14236   GenoPro::SourcesAndCitations::SourceCitation_p GenoPro::SourcesAndCitations::add_node_SourceCitation()
14237   {
14238     return get_sequence()->add_node_SourceCitation();
14239   }
14240
14241   List<GenoPro::SourcesAndCitations::SourceCitation_ptr> GenoPro::SourcesAndCitations::set_count_SourceCitation(unsigned int size)
14242   {
14243     return get_sequence()->set_count_SourceCitation(size);
14244   }
14245
14246
14247
14248   /* attribute  functions  */
14249
14250   //constructor
14251   GenoPro::SourcesAndCitations::sequence::sequence(SourcesAndCitations* that):
14252     _that(that)
14253   {
14254     XsdFsmBasePtr fsmArray[] = {
14255     new XsdFSM<SourceCitation_ptr>( Particle(new DOMString("libgno"), DOMString("SourceCitation"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<SourceCitation_ptr, SourcesAndCitations, FsmCbOptions>(_that, &SourcesAndCitations::create_SourceCitation)),
14256
14257       NULL
14258     } ;
14259
14260     XsdSequenceFsmOfFSMs::init(fsmArray);
14261   }
14262
14263
14264
14265   List<GenoPro::SourcesAndCitations::SourceCitation_ptr> GenoPro::SourcesAndCitations::sequence::elements_SourceCitation()
14266   {
14267
14268     List<SourceCitation_ptr> nodeList;
14269     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
14270     if(fsm_p)
14271     {
14272       XsdFSM<SourceCitation_ptr> *unitFsm = dynamic_cast<XsdFSM<SourceCitation_ptr> *>(fsm_p);
14273       if(unitFsm) {
14274         //nodeList = unitFsm->nodeList().stl_list();
14275         nodeList = unitFsm->nodeList();
14276       }
14277     }
14278     return nodeList;
14279
14280   }
14281
14282
14283   GenoPro::SourcesAndCitations::SourceCitation_p GenoPro::SourcesAndCitations::sequence::element_SourceCitation_at(unsigned int idx)
14284   {
14285     return elements_SourceCitation().at(idx);
14286   }
14287
14288
14289   GenoPro::SourcesAndCitations::SourceCitation_p GenoPro::SourcesAndCitations::sequence::add_node_SourceCitation()
14290   {
14291     DOMStringPtr nsUriPtr = new DOMString("libgno");
14292     XsdEvent event(nsUriPtr, NULL, DOMString("SourceCitation"), XsdEvent::ELEMENT_START, false);
14293     this->processEventThrow(event);
14294     return elements_SourceCitation().back();
14295   }
14296
14297   List<GenoPro::SourcesAndCitations::SourceCitation_ptr> GenoPro::SourcesAndCitations::sequence::set_count_SourceCitation(unsigned int size)
14298   {
14299     if( (size > -1) || (size < 1)) {
14300       ostringstream oss;
14301       oss << "set_count_SourceCitation: size should be in range: [" << 1
14302         << "," << "unbounded" << "]";
14303       throw IndexOutOfBoundsException(oss.str());
14304     }
14305
14306     unsigned int prevSize = elements_SourceCitation().size();
14307     if(size < prevSize) {
14308       //FIXME: allow later:
14309       throw XPlus::RuntimeException("resize lesser than current size not allowed");
14310     }
14311
14312     for(unsigned int j=prevSize; j<size; j++)
14313     {
14314       // pretend docBuilding to avoid computation of adding after first loop
14315       XsdEvent event(new DOMString("libgno"), NULL, DOMString("SourceCitation"), XsdEvent::ELEMENT_START, false);
14316       this->processEventThrow(event);
14317     }
14318
14319     return elements_SourceCitation();
14320   }
14321
14322
14323
14324   //constructor
14325
14326   GenoPro::SourcesAndCitations::SourceCitation::SourceCitation(ElementCreateArgs args):
14327       XMLSchema::XmlElement<anyType>(args),
14328
14329     _fsmAttrs(NULL),
14330     _fsmElems(NULL)
14331
14332     , _sequence(new sequence(this) )
14333
14334   {
14335     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
14336     initFSM();
14337     if(args.ownerDoc && args.ownerDoc->buildTree())
14338     {
14339       if(args.ownerDoc->createSample()) {
14340         _fsm->fireSampleEvents();
14341       }
14342       else {
14343         _fsm->fireRequiredEvents();
14344       }
14345     }
14346   }
14347
14348   void GenoPro::SourcesAndCitations::SourceCitation::initFSM()
14349   {
14350     XsdFsmBasePtr fsmsAttrs[] = {
14351   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, SourceCitation, FsmCbOptions>(this, &SourceCitation::create_attr_ID)),
14352
14353       NULL
14354     };
14355
14356     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
14357
14358     _fsm->replaceContentFsm(_sequence);
14359
14360     _fsmAttrs = _fsm->attributeFsm();
14361     _fsmElems = _fsm->contentFsm();
14362
14363   }
14364
14365   /* element functions  */
14366
14367
14368   GenoPro::SourcesAndCitations::SourceCitation::Title_ptr GenoPro::SourcesAndCitations::SourceCitation::create_Title(FsmCbOptions& options)
14369   {
14370     static DOMStringPtr myName = new DOMString("Title");
14371     static DOMStringPtr myNsUri = new DOMString("libgno");
14372
14373     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
14374     GenoPro::SourcesAndCitations::SourceCitation::Title_p node = XSD::createElementTmpl<Title, XMLSchema::Types::bt_string*>(t);
14375
14376     if(options.isSampleCreate && (node->stringValue() == "") ) {
14377       node->stringValue(node->sampleValue());
14378     }
14379
14380     _Title = node;
14381
14382     return node;
14383   }
14384
14385
14386   GenoPro::SourcesAndCitations::SourceCitation::Title_p GenoPro::SourcesAndCitations::SourceCitation::element_Title()
14387   {
14388     FSM::warnNullNode(_Title, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
14389     return _Title;
14390   }
14391
14392   void GenoPro::SourcesAndCitations::SourceCitation::set_Title(DOMString val)
14393   {
14394     get_sequence()->set_Title(val);
14395   }
14396
14397   DOMString GenoPro::SourcesAndCitations::SourceCitation::get_Title_string()
14398   {
14399     return get_sequence()->get_Title_string();
14400   }
14401
14402
14403   void GenoPro::SourcesAndCitations::SourceCitation::mark_present_Title()
14404   {
14405     return get_sequence()->mark_present_Title();
14406   }
14407
14408
14409   GenoPro::SourcesAndCitations::SourceCitation::Subtitle_ptr GenoPro::SourcesAndCitations::SourceCitation::create_Subtitle(FsmCbOptions& options)
14410   {
14411     static DOMStringPtr myName = new DOMString("Subtitle");
14412     static DOMStringPtr myNsUri = new DOMString("libgno");
14413
14414     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
14415     GenoPro::SourcesAndCitations::SourceCitation::Subtitle_p node = XSD::createElementTmpl<Subtitle, XMLSchema::Types::bt_string*>(t);
14416
14417     if(options.isSampleCreate && (node->stringValue() == "") ) {
14418       node->stringValue(node->sampleValue());
14419     }
14420
14421     _Subtitle = node;
14422
14423     return node;
14424   }
14425
14426
14427   GenoPro::SourcesAndCitations::SourceCitation::Subtitle_p GenoPro::SourcesAndCitations::SourceCitation::element_Subtitle()
14428   {
14429     FSM::warnNullNode(_Subtitle, "Subtitle", "{http://www.w3.org/2001/XMLSchema}Subtitle", 0);
14430     return _Subtitle;
14431   }
14432
14433   void GenoPro::SourcesAndCitations::SourceCitation::set_Subtitle(DOMString val)
14434   {
14435     get_sequence()->set_Subtitle(val);
14436   }
14437
14438   DOMString GenoPro::SourcesAndCitations::SourceCitation::get_Subtitle_string()
14439   {
14440     return get_sequence()->get_Subtitle_string();
14441   }
14442
14443
14444   void GenoPro::SourcesAndCitations::SourceCitation::mark_present_Subtitle()
14445   {
14446     return get_sequence()->mark_present_Subtitle();
14447   }
14448
14449
14450   GenoPro::SourcesAndCitations::SourceCitation::MediaType_ptr GenoPro::SourcesAndCitations::SourceCitation::create_MediaType(FsmCbOptions& options)
14451   {
14452     static DOMStringPtr myName = new DOMString("MediaType");
14453     static DOMStringPtr myNsUri = new DOMString("libgno");
14454
14455     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
14456     GenoPro::SourcesAndCitations::SourceCitation::MediaType_p node = XSD::createElementTmpl<MediaType, XMLSchema::Types::bt_normalizedString*>(t);
14457
14458     if(options.isSampleCreate && (node->stringValue() == "") ) {
14459       node->stringValue(node->sampleValue());
14460     }
14461
14462     _MediaType = node;
14463
14464     return node;
14465   }
14466
14467
14468   GenoPro::SourcesAndCitations::SourceCitation::MediaType_p GenoPro::SourcesAndCitations::SourceCitation::element_MediaType()
14469   {
14470     FSM::warnNullNode(_MediaType, "MediaType", "{http://www.w3.org/2001/XMLSchema}MediaType", 0);
14471     return _MediaType;
14472   }
14473
14474   void GenoPro::SourcesAndCitations::SourceCitation::set_MediaType(DOMString val)
14475   {
14476     get_sequence()->set_MediaType(val);
14477   }
14478
14479   DOMString GenoPro::SourcesAndCitations::SourceCitation::get_MediaType_string()
14480   {
14481     return get_sequence()->get_MediaType_string();
14482   }
14483
14484
14485   void GenoPro::SourcesAndCitations::SourceCitation::mark_present_MediaType()
14486   {
14487     return get_sequence()->mark_present_MediaType();
14488   }
14489
14490
14491   GenoPro::SourcesAndCitations::SourceCitation::ConfidenceLevel_ptr GenoPro::SourcesAndCitations::SourceCitation::create_ConfidenceLevel(FsmCbOptions& options)
14492   {
14493     static DOMStringPtr myName = new DOMString("ConfidenceLevel");
14494     static DOMStringPtr myNsUri = new DOMString("libgno");
14495
14496     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
14497     GenoPro::SourcesAndCitations::SourceCitation::ConfidenceLevel_p node = XSD::createElementTmpl<ConfidenceLevel, XMLSchema::Types::bt_normalizedString*>(t);
14498
14499     if(options.isSampleCreate && (node->stringValue() == "") ) {
14500       node->stringValue(node->sampleValue());
14501     }
14502
14503     _ConfidenceLevel = node;
14504
14505     return node;
14506   }
14507
14508
14509   GenoPro::SourcesAndCitations::SourceCitation::ConfidenceLevel_p GenoPro::SourcesAndCitations::SourceCitation::element_ConfidenceLevel()
14510   {
14511     FSM::warnNullNode(_ConfidenceLevel, "ConfidenceLevel", "{http://www.w3.org/2001/XMLSchema}ConfidenceLevel", 0);
14512     return _ConfidenceLevel;
14513   }
14514
14515   void GenoPro::SourcesAndCitations::SourceCitation::set_ConfidenceLevel(DOMString val)
14516   {
14517     get_sequence()->set_ConfidenceLevel(val);
14518   }
14519
14520   DOMString GenoPro::SourcesAndCitations::SourceCitation::get_ConfidenceLevel_string()
14521   {
14522     return get_sequence()->get_ConfidenceLevel_string();
14523   }
14524
14525
14526   void GenoPro::SourcesAndCitations::SourceCitation::mark_present_ConfidenceLevel()
14527   {
14528     return get_sequence()->mark_present_ConfidenceLevel();
14529   }
14530
14531
14532   /* attribute  functions  */
14533
14534
14535   GenoPro::SourcesAndCitations::SourceCitation::attr_ID_ptr GenoPro::SourcesAndCitations::SourceCitation::create_attr_ID(FsmCbOptions& options)
14536   {
14537     static DOMStringPtr myName = new DOMString("ID");
14538     static DOMStringPtr myNsUri = NULL;
14539
14540     if(_attr_ID) {
14541       return _attr_ID;
14542     }
14543     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
14544     GenoPro::SourcesAndCitations::SourceCitation::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
14545
14546     if(options.isSampleCreate && (node->stringValue() == "") ) {
14547       node->stringValue(node->sampleValue());
14548     }
14549
14550     _attr_ID = node;
14551
14552     return node;
14553   }
14554
14555
14556     void GenoPro::SourcesAndCitations::SourceCitation::set_attr_ID(DOMString val)
14557     {
14558
14559       attribute_attr_ID()->stringValue(val);
14560     }
14561
14562     DOMString GenoPro::SourcesAndCitations::SourceCitation::get_attr_ID_string()
14563     {
14564
14565       return attribute_attr_ID()->stringValue();
14566     }
14567
14568
14569   GenoPro::SourcesAndCitations::SourceCitation::attr_ID_p GenoPro::SourcesAndCitations::SourceCitation::attribute_attr_ID()
14570   {
14571     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
14572     return _attr_ID;
14573   }
14574
14575   //constructor
14576   GenoPro::SourcesAndCitations::SourceCitation::sequence::sequence(SourceCitation* that):
14577     _that(that)
14578   {
14579     XsdFsmBasePtr fsmArray[] = {
14580     new XsdFSM<Title_ptr>( Particle(new DOMString("libgno"), DOMString("Title"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Title_ptr, SourceCitation, FsmCbOptions>(_that, &SourceCitation::create_Title)),
14581       new XsdFSM<Subtitle_ptr>( Particle(new DOMString("libgno"), DOMString("Subtitle"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Subtitle_ptr, SourceCitation, FsmCbOptions>(_that, &SourceCitation::create_Subtitle)),
14582       new XsdFSM<MediaType_ptr>( Particle(new DOMString("libgno"), DOMString("MediaType"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<MediaType_ptr, SourceCitation, FsmCbOptions>(_that, &SourceCitation::create_MediaType)),
14583       new XsdFSM<ConfidenceLevel_ptr>( Particle(new DOMString("libgno"), DOMString("ConfidenceLevel"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<ConfidenceLevel_ptr, SourceCitation, FsmCbOptions>(_that, &SourceCitation::create_ConfidenceLevel)),
14584
14585       NULL
14586     } ;
14587
14588     XsdSequenceFsmOfFSMs::init(fsmArray);
14589   }
14590
14591
14592
14593   GenoPro::SourcesAndCitations::SourceCitation::Title_p GenoPro::SourcesAndCitations::SourceCitation::sequence::element_Title()
14594   {
14595       GenoPro::SourcesAndCitations::SourceCitation::Title_p node_p = NULL;
14596     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
14597     if(fsm_p)
14598     {
14599       XsdFSM<Title_ptr> *unitFsm = dynamic_cast<XsdFSM<Title_ptr> *>(fsm_p);
14600       if(unitFsm && unitFsm->nodeList().size()>0) {
14601         assert(unitFsm->nodeList().size()==1);
14602         node_p = unitFsm->nodeList().at(0);
14603       }
14604     }
14605
14606     FSM::warnNullNode(node_p, "Title", "{http://www.w3.org/2001/XMLSchema}Title", 0);
14607     return node_p;
14608
14609   }
14610
14611
14612   void GenoPro::SourcesAndCitations::SourceCitation::sequence::set_Title(DOMString val)
14613   {
14614
14615     mark_present_Title();
14616
14617     element_Title()->stringValue(val);
14618   }
14619
14620   DOMString GenoPro::SourcesAndCitations::SourceCitation::sequence::get_Title_string()
14621   {
14622     return element_Title()->stringValue();
14623   }
14624
14625
14626
14627   void GenoPro::SourcesAndCitations::SourceCitation::sequence::mark_present_Title()
14628   {
14629     DOMStringPtr nsUriPtr = new DOMString("libgno");
14630     XsdEvent event(nsUriPtr, NULL, DOMString("Title"), XsdEvent::ELEMENT_START, false);
14631     this->processEventThrow(event);
14632   }
14633
14634
14635
14636   GenoPro::SourcesAndCitations::SourceCitation::Subtitle_p GenoPro::SourcesAndCitations::SourceCitation::sequence::element_Subtitle()
14637   {
14638       GenoPro::SourcesAndCitations::SourceCitation::Subtitle_p node_p = NULL;
14639     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
14640     if(fsm_p)
14641     {
14642       XsdFSM<Subtitle_ptr> *unitFsm = dynamic_cast<XsdFSM<Subtitle_ptr> *>(fsm_p);
14643       if(unitFsm && unitFsm->nodeList().size()>0) {
14644         assert(unitFsm->nodeList().size()==1);
14645         node_p = unitFsm->nodeList().at(0);
14646       }
14647     }
14648
14649     FSM::warnNullNode(node_p, "Subtitle", "{http://www.w3.org/2001/XMLSchema}Subtitle", 0);
14650     return node_p;
14651
14652   }
14653
14654
14655   void GenoPro::SourcesAndCitations::SourceCitation::sequence::set_Subtitle(DOMString val)
14656   {
14657
14658     mark_present_Subtitle();
14659
14660     element_Subtitle()->stringValue(val);
14661   }
14662
14663   DOMString GenoPro::SourcesAndCitations::SourceCitation::sequence::get_Subtitle_string()
14664   {
14665     return element_Subtitle()->stringValue();
14666   }
14667
14668
14669
14670   void GenoPro::SourcesAndCitations::SourceCitation::sequence::mark_present_Subtitle()
14671   {
14672     DOMStringPtr nsUriPtr = new DOMString("libgno");
14673     XsdEvent event(nsUriPtr, NULL, DOMString("Subtitle"), XsdEvent::ELEMENT_START, false);
14674     this->processEventThrow(event);
14675   }
14676
14677
14678
14679   GenoPro::SourcesAndCitations::SourceCitation::MediaType_p GenoPro::SourcesAndCitations::SourceCitation::sequence::element_MediaType()
14680   {
14681       GenoPro::SourcesAndCitations::SourceCitation::MediaType_p node_p = NULL;
14682     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
14683     if(fsm_p)
14684     {
14685       XsdFSM<MediaType_ptr> *unitFsm = dynamic_cast<XsdFSM<MediaType_ptr> *>(fsm_p);
14686       if(unitFsm && unitFsm->nodeList().size()>0) {
14687         assert(unitFsm->nodeList().size()==1);
14688         node_p = unitFsm->nodeList().at(0);
14689       }
14690     }
14691
14692     FSM::warnNullNode(node_p, "MediaType", "{http://www.w3.org/2001/XMLSchema}MediaType", 0);
14693     return node_p;
14694
14695   }
14696
14697
14698   void GenoPro::SourcesAndCitations::SourceCitation::sequence::set_MediaType(DOMString val)
14699   {
14700
14701     mark_present_MediaType();
14702
14703     element_MediaType()->stringValue(val);
14704   }
14705
14706   DOMString GenoPro::SourcesAndCitations::SourceCitation::sequence::get_MediaType_string()
14707   {
14708     return element_MediaType()->stringValue();
14709   }
14710
14711
14712
14713   void GenoPro::SourcesAndCitations::SourceCitation::sequence::mark_present_MediaType()
14714   {
14715     DOMStringPtr nsUriPtr = new DOMString("libgno");
14716     XsdEvent event(nsUriPtr, NULL, DOMString("MediaType"), XsdEvent::ELEMENT_START, false);
14717     this->processEventThrow(event);
14718   }
14719
14720
14721
14722   GenoPro::SourcesAndCitations::SourceCitation::ConfidenceLevel_p GenoPro::SourcesAndCitations::SourceCitation::sequence::element_ConfidenceLevel()
14723   {
14724       GenoPro::SourcesAndCitations::SourceCitation::ConfidenceLevel_p node_p = NULL;
14725     XsdFsmBase* fsm_p = this->allFSMs()[3].get();
14726     if(fsm_p)
14727     {
14728       XsdFSM<ConfidenceLevel_ptr> *unitFsm = dynamic_cast<XsdFSM<ConfidenceLevel_ptr> *>(fsm_p);
14729       if(unitFsm && unitFsm->nodeList().size()>0) {
14730         assert(unitFsm->nodeList().size()==1);
14731         node_p = unitFsm->nodeList().at(0);
14732       }
14733     }
14734
14735     FSM::warnNullNode(node_p, "ConfidenceLevel", "{http://www.w3.org/2001/XMLSchema}ConfidenceLevel", 0);
14736     return node_p;
14737
14738   }
14739
14740
14741   void GenoPro::SourcesAndCitations::SourceCitation::sequence::set_ConfidenceLevel(DOMString val)
14742   {
14743
14744     mark_present_ConfidenceLevel();
14745
14746     element_ConfidenceLevel()->stringValue(val);
14747   }
14748
14749   DOMString GenoPro::SourcesAndCitations::SourceCitation::sequence::get_ConfidenceLevel_string()
14750   {
14751     return element_ConfidenceLevel()->stringValue();
14752   }
14753
14754
14755
14756   void GenoPro::SourcesAndCitations::SourceCitation::sequence::mark_present_ConfidenceLevel()
14757   {
14758     DOMStringPtr nsUriPtr = new DOMString("libgno");
14759     XsdEvent event(nsUriPtr, NULL, DOMString("ConfidenceLevel"), XsdEvent::ELEMENT_START, false);
14760     this->processEventThrow(event);
14761   }
14762
14763
14764
14765   //constructor
14766
14767   GenoPro::Twins::Twins(ElementCreateArgs args):
14768       XMLSchema::XmlElement<anyType>(args),
14769
14770     _fsmAttrs(NULL),
14771     _fsmElems(NULL)
14772
14773     , _sequence(new sequence(this) )
14774
14775   {
14776     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
14777     initFSM();
14778     if(args.ownerDoc && args.ownerDoc->buildTree())
14779     {
14780       if(args.ownerDoc->createSample()) {
14781         _fsm->fireSampleEvents();
14782       }
14783       else {
14784         _fsm->fireRequiredEvents();
14785       }
14786     }
14787   }
14788
14789   void GenoPro::Twins::initFSM()
14790   {
14791     XsdFsmBasePtr fsmsAttrs[] = {
14792
14793       NULL
14794     };
14795
14796     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
14797
14798     _fsm->replaceContentFsm(_sequence);
14799
14800     _fsmAttrs = _fsm->attributeFsm();
14801     _fsmElems = _fsm->contentFsm();
14802
14803   }
14804
14805   /* element functions  */
14806
14807
14808   GenoPro::Twins::Twin_ptr GenoPro::Twins::create_Twin(FsmCbOptions& options)
14809   {
14810     static DOMStringPtr myName = new DOMString("Twin");
14811     static DOMStringPtr myNsUri = new DOMString("libgno");
14812
14813     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
14814     GenoPro::Twins::Twin_p node = XSD::createElementTmpl<Twin, void*>(t);
14815
14816     _list_Twin.push_back(node);
14817
14818     return node;
14819   }
14820
14821
14822   GenoPro::Twins::Twin_p GenoPro::Twins::element_Twin_at(unsigned int idx)
14823   {
14824     if(idx > _list_Twin.size()-1) {
14825       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
14826     }
14827
14828     return _list_Twin.at(idx);
14829   }
14830
14831   List<GenoPro::Twins::Twin_ptr> GenoPro::Twins::elements_Twin()
14832   {
14833     return _list_Twin;
14834   }
14835
14836   GenoPro::Twins::Twin_p GenoPro::Twins::add_node_Twin()
14837   {
14838     return get_sequence()->add_node_Twin();
14839   }
14840
14841   List<GenoPro::Twins::Twin_ptr> GenoPro::Twins::set_count_Twin(unsigned int size)
14842   {
14843     return get_sequence()->set_count_Twin(size);
14844   }
14845
14846
14847
14848   /* attribute  functions  */
14849
14850   //constructor
14851   GenoPro::Twins::sequence::sequence(Twins* that):
14852     _that(that)
14853   {
14854     XsdFsmBasePtr fsmArray[] = {
14855     new XsdFSM<Twin_ptr>( Particle(new DOMString("libgno"), DOMString("Twin"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Twin_ptr, Twins, FsmCbOptions>(_that, &Twins::create_Twin)),
14856
14857       NULL
14858     } ;
14859
14860     XsdSequenceFsmOfFSMs::init(fsmArray);
14861   }
14862
14863
14864
14865   List<GenoPro::Twins::Twin_ptr> GenoPro::Twins::sequence::elements_Twin()
14866   {
14867
14868     List<Twin_ptr> nodeList;
14869     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
14870     if(fsm_p)
14871     {
14872       XsdFSM<Twin_ptr> *unitFsm = dynamic_cast<XsdFSM<Twin_ptr> *>(fsm_p);
14873       if(unitFsm) {
14874         //nodeList = unitFsm->nodeList().stl_list();
14875         nodeList = unitFsm->nodeList();
14876       }
14877     }
14878     return nodeList;
14879
14880   }
14881
14882
14883   GenoPro::Twins::Twin_p GenoPro::Twins::sequence::element_Twin_at(unsigned int idx)
14884   {
14885     return elements_Twin().at(idx);
14886   }
14887
14888
14889   GenoPro::Twins::Twin_p GenoPro::Twins::sequence::add_node_Twin()
14890   {
14891     DOMStringPtr nsUriPtr = new DOMString("libgno");
14892     XsdEvent event(nsUriPtr, NULL, DOMString("Twin"), XsdEvent::ELEMENT_START, false);
14893     this->processEventThrow(event);
14894     return elements_Twin().back();
14895   }
14896
14897   List<GenoPro::Twins::Twin_ptr> GenoPro::Twins::sequence::set_count_Twin(unsigned int size)
14898   {
14899     if( (size > -1) || (size < 1)) {
14900       ostringstream oss;
14901       oss << "set_count_Twin: size should be in range: [" << 1
14902         << "," << "unbounded" << "]";
14903       throw IndexOutOfBoundsException(oss.str());
14904     }
14905
14906     unsigned int prevSize = elements_Twin().size();
14907     if(size < prevSize) {
14908       //FIXME: allow later:
14909       throw XPlus::RuntimeException("resize lesser than current size not allowed");
14910     }
14911
14912     for(unsigned int j=prevSize; j<size; j++)
14913     {
14914       // pretend docBuilding to avoid computation of adding after first loop
14915       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Twin"), XsdEvent::ELEMENT_START, false);
14916       this->processEventThrow(event);
14917     }
14918
14919     return elements_Twin();
14920   }
14921
14922
14923
14924   //constructor
14925
14926   GenoPro::Twins::Twin::Twin(ElementCreateArgs args):
14927       XMLSchema::XmlElement<anyType>(args),
14928
14929     _fsmAttrs(NULL),
14930     _fsmElems(NULL)
14931
14932     , _sequence(new sequence(this) )
14933
14934   {
14935     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
14936     initFSM();
14937     if(args.ownerDoc && args.ownerDoc->buildTree())
14938     {
14939       if(args.ownerDoc->createSample()) {
14940         _fsm->fireSampleEvents();
14941       }
14942       else {
14943         _fsm->fireRequiredEvents();
14944       }
14945     }
14946   }
14947
14948   void GenoPro::Twins::Twin::initFSM()
14949   {
14950     XsdFsmBasePtr fsmsAttrs[] = {
14951   new XsdFSM<attr_ID_ptr>( Particle(NULL, DOMString("ID"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_ID_ptr, Twin, FsmCbOptions>(this, &Twin::create_attr_ID)),
14952   new XsdFSM<attr_TwinLink_ptr>( Particle(NULL, DOMString("TwinLink"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_TwinLink_ptr, Twin, FsmCbOptions>(this, &Twin::create_attr_TwinLink)),
14953   new XsdFSM<attr_Family_ptr>( Particle(NULL, DOMString("Family"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Family_ptr, Twin, FsmCbOptions>(this, &Twin::create_attr_Family)),
14954
14955       NULL
14956     };
14957
14958     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
14959
14960     _fsm->replaceContentFsm(_sequence);
14961
14962     _fsmAttrs = _fsm->attributeFsm();
14963     _fsmElems = _fsm->contentFsm();
14964
14965   }
14966
14967   /* element functions  */
14968
14969
14970   GenoPro::Twins::Twin::Position_ptr GenoPro::Twins::Twin::create_Position(FsmCbOptions& options)
14971   {
14972     static DOMStringPtr myName = new DOMString("Position");
14973     static DOMStringPtr myNsUri = new DOMString("libgno");
14974
14975     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "int");
14976     GenoPro::Twins::Twin::Position_p node = XSD::createElementTmpl<Position, XMLSchema::Types::bt_int*>(t);
14977
14978     if(options.isSampleCreate && (node->stringValue() == "") ) {
14979       node->stringValue(node->sampleValue());
14980     }
14981
14982     _Position = node;
14983
14984     return node;
14985   }
14986
14987
14988   GenoPro::Twins::Twin::Position_p GenoPro::Twins::Twin::element_Position()
14989   {
14990     FSM::warnNullNode(_Position, "Position", "{http://www.w3.org/2001/XMLSchema}Position", 0);
14991     return _Position;
14992   }
14993
14994   void GenoPro::Twins::Twin::set_Position(DOMString val)
14995   {
14996     get_sequence()->set_Position(val);
14997   }
14998
14999   DOMString GenoPro::Twins::Twin::get_Position_string()
15000   {
15001     return get_sequence()->get_Position_string();
15002   }
15003
15004
15005   void GenoPro::Twins::Twin::set_Position(int val)
15006   {
15007     get_sequence()->set_Position(val);
15008   }
15009
15010   int GenoPro::Twins::Twin::get_Position()
15011   {
15012     return get_sequence()->get_Position();
15013   }
15014
15015
15016   void GenoPro::Twins::Twin::mark_present_Position()
15017   {
15018     return get_sequence()->mark_present_Position();
15019   }
15020
15021
15022   /* attribute  functions  */
15023
15024
15025   GenoPro::Twins::Twin::attr_ID_ptr GenoPro::Twins::Twin::create_attr_ID(FsmCbOptions& options)
15026   {
15027     static DOMStringPtr myName = new DOMString("ID");
15028     static DOMStringPtr myNsUri = NULL;
15029
15030     if(_attr_ID) {
15031       return _attr_ID;
15032     }
15033     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
15034     GenoPro::Twins::Twin::attr_ID_p node = XSD::createAttributeTmpl<attr_ID>(t);
15035
15036     if(options.isSampleCreate && (node->stringValue() == "") ) {
15037       node->stringValue(node->sampleValue());
15038     }
15039
15040     _attr_ID = node;
15041
15042     return node;
15043   }
15044
15045
15046     void GenoPro::Twins::Twin::set_attr_ID(DOMString val)
15047     {
15048
15049       attribute_attr_ID()->stringValue(val);
15050     }
15051
15052     DOMString GenoPro::Twins::Twin::get_attr_ID_string()
15053     {
15054
15055       return attribute_attr_ID()->stringValue();
15056     }
15057
15058
15059   GenoPro::Twins::Twin::attr_ID_p GenoPro::Twins::Twin::attribute_attr_ID()
15060   {
15061     FSM::warnNullNode(_attr_ID, "attr_ID", "{http://www.w3.org/2001/XMLSchema}ID", 1);
15062     return _attr_ID;
15063   }
15064
15065
15066   GenoPro::Twins::Twin::attr_TwinLink_ptr GenoPro::Twins::Twin::create_attr_TwinLink(FsmCbOptions& options)
15067   {
15068     static DOMStringPtr myName = new DOMString("TwinLink");
15069     static DOMStringPtr myNsUri = NULL;
15070
15071     if(_attr_TwinLink) {
15072       return _attr_TwinLink;
15073     }
15074     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
15075     GenoPro::Twins::Twin::attr_TwinLink_p node = XSD::createAttributeTmpl<attr_TwinLink>(t);
15076
15077     if(options.isSampleCreate && (node->stringValue() == "") ) {
15078       node->stringValue(node->sampleValue());
15079     }
15080
15081     _attr_TwinLink = node;
15082
15083     return node;
15084   }
15085
15086
15087     void GenoPro::Twins::Twin::set_attr_TwinLink(DOMString val)
15088     {
15089
15090       attribute_attr_TwinLink()->stringValue(val);
15091     }
15092
15093     DOMString GenoPro::Twins::Twin::get_attr_TwinLink_string()
15094     {
15095
15096       return attribute_attr_TwinLink()->stringValue();
15097     }
15098
15099
15100   GenoPro::Twins::Twin::attr_TwinLink_p GenoPro::Twins::Twin::attribute_attr_TwinLink()
15101   {
15102     FSM::warnNullNode(_attr_TwinLink, "attr_TwinLink", "{http://www.w3.org/2001/XMLSchema}TwinLink", 1);
15103     return _attr_TwinLink;
15104   }
15105
15106
15107   GenoPro::Twins::Twin::attr_Family_ptr GenoPro::Twins::Twin::create_attr_Family(FsmCbOptions& options)
15108   {
15109     static DOMStringPtr myName = new DOMString("Family");
15110     static DOMStringPtr myNsUri = NULL;
15111
15112     if(_attr_Family) {
15113       return _attr_Family;
15114     }
15115     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
15116     GenoPro::Twins::Twin::attr_Family_p node = XSD::createAttributeTmpl<attr_Family>(t);
15117
15118     if(options.isSampleCreate && (node->stringValue() == "") ) {
15119       node->stringValue(node->sampleValue());
15120     }
15121
15122     _attr_Family = node;
15123
15124     return node;
15125   }
15126
15127
15128     void GenoPro::Twins::Twin::set_attr_Family(DOMString val)
15129     {
15130
15131       attribute_attr_Family()->stringValue(val);
15132     }
15133
15134     DOMString GenoPro::Twins::Twin::get_attr_Family_string()
15135     {
15136
15137       return attribute_attr_Family()->stringValue();
15138     }
15139
15140
15141   GenoPro::Twins::Twin::attr_Family_p GenoPro::Twins::Twin::attribute_attr_Family()
15142   {
15143     FSM::warnNullNode(_attr_Family, "attr_Family", "{http://www.w3.org/2001/XMLSchema}Family", 1);
15144     return _attr_Family;
15145   }
15146
15147   //constructor
15148   GenoPro::Twins::Twin::sequence::sequence(Twin* that):
15149     _that(that)
15150   {
15151     XsdFsmBasePtr fsmArray[] = {
15152     new XsdFSM<Position_ptr>( Particle(new DOMString("libgno"), DOMString("Position"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Position_ptr, Twin, FsmCbOptions>(_that, &Twin::create_Position)),
15153
15154       NULL
15155     } ;
15156
15157     XsdSequenceFsmOfFSMs::init(fsmArray);
15158   }
15159
15160
15161
15162   GenoPro::Twins::Twin::Position_p GenoPro::Twins::Twin::sequence::element_Position()
15163   {
15164       GenoPro::Twins::Twin::Position_p node_p = NULL;
15165     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
15166     if(fsm_p)
15167     {
15168       XsdFSM<Position_ptr> *unitFsm = dynamic_cast<XsdFSM<Position_ptr> *>(fsm_p);
15169       if(unitFsm && unitFsm->nodeList().size()>0) {
15170         assert(unitFsm->nodeList().size()==1);
15171         node_p = unitFsm->nodeList().at(0);
15172       }
15173     }
15174
15175     FSM::warnNullNode(node_p, "Position", "{http://www.w3.org/2001/XMLSchema}Position", 0);
15176     return node_p;
15177
15178   }
15179
15180
15181   void GenoPro::Twins::Twin::sequence::set_Position(DOMString val)
15182   {
15183
15184     mark_present_Position();
15185
15186     element_Position()->stringValue(val);
15187   }
15188
15189   DOMString GenoPro::Twins::Twin::sequence::get_Position_string()
15190   {
15191     return element_Position()->stringValue();
15192   }
15193
15194
15195   void GenoPro::Twins::Twin::sequence::set_Position(int val)
15196   {
15197
15198     mark_present_Position();
15199
15200     element_Position()->value(val);
15201   }
15202
15203   int GenoPro::Twins::Twin::sequence::get_Position()
15204   {
15205     return element_Position()->value();
15206   }
15207
15208
15209
15210   void GenoPro::Twins::Twin::sequence::mark_present_Position()
15211   {
15212     DOMStringPtr nsUriPtr = new DOMString("libgno");
15213     XsdEvent event(nsUriPtr, NULL, DOMString("Position"), XsdEvent::ELEMENT_START, false);
15214     this->processEventThrow(event);
15215   }
15216
15217
15218
15219   //constructor
15220
15221   GenoPro::Shapes::Shapes(ElementCreateArgs args):
15222       XMLSchema::XmlElement<anyType>(args),
15223
15224     _fsmAttrs(NULL),
15225     _fsmElems(NULL)
15226
15227     , _sequence(new sequence(this) )
15228
15229   {
15230     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
15231     initFSM();
15232     if(args.ownerDoc && args.ownerDoc->buildTree())
15233     {
15234       if(args.ownerDoc->createSample()) {
15235         _fsm->fireSampleEvents();
15236       }
15237       else {
15238         _fsm->fireRequiredEvents();
15239       }
15240     }
15241   }
15242
15243   void GenoPro::Shapes::initFSM()
15244   {
15245     XsdFsmBasePtr fsmsAttrs[] = {
15246
15247       NULL
15248     };
15249
15250     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
15251
15252     _fsm->replaceContentFsm(_sequence);
15253
15254     _fsmAttrs = _fsm->attributeFsm();
15255     _fsmElems = _fsm->contentFsm();
15256
15257   }
15258
15259   /* element functions  */
15260
15261
15262   GenoPro::Shapes::Shape_ptr GenoPro::Shapes::create_Shape(FsmCbOptions& options)
15263   {
15264     static DOMStringPtr myName = new DOMString("Shape");
15265     static DOMStringPtr myNsUri = new DOMString("libgno");
15266
15267     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
15268     GenoPro::Shapes::Shape_p node = XSD::createElementTmpl<Shape, void*>(t);
15269
15270     _list_Shape.push_back(node);
15271
15272     return node;
15273   }
15274
15275
15276   GenoPro::Shapes::Shape_p GenoPro::Shapes::element_Shape_at(unsigned int idx)
15277   {
15278     if(idx > _list_Shape.size()-1) {
15279       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
15280     }
15281
15282     return _list_Shape.at(idx);
15283   }
15284
15285   List<GenoPro::Shapes::Shape_ptr> GenoPro::Shapes::elements_Shape()
15286   {
15287     return _list_Shape;
15288   }
15289
15290   GenoPro::Shapes::Shape_p GenoPro::Shapes::add_node_Shape()
15291   {
15292     return get_sequence()->add_node_Shape();
15293   }
15294
15295   List<GenoPro::Shapes::Shape_ptr> GenoPro::Shapes::set_count_Shape(unsigned int size)
15296   {
15297     return get_sequence()->set_count_Shape(size);
15298   }
15299
15300
15301
15302   /* attribute  functions  */
15303
15304   //constructor
15305   GenoPro::Shapes::sequence::sequence(Shapes* that):
15306     _that(that)
15307   {
15308     XsdFsmBasePtr fsmArray[] = {
15309     new XsdFSM<Shape_ptr>( Particle(new DOMString("libgno"), DOMString("Shape"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Shape_ptr, Shapes, FsmCbOptions>(_that, &Shapes::create_Shape)),
15310
15311       NULL
15312     } ;
15313
15314     XsdSequenceFsmOfFSMs::init(fsmArray);
15315   }
15316
15317
15318
15319   List<GenoPro::Shapes::Shape_ptr> GenoPro::Shapes::sequence::elements_Shape()
15320   {
15321
15322     List<Shape_ptr> nodeList;
15323     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
15324     if(fsm_p)
15325     {
15326       XsdFSM<Shape_ptr> *unitFsm = dynamic_cast<XsdFSM<Shape_ptr> *>(fsm_p);
15327       if(unitFsm) {
15328         //nodeList = unitFsm->nodeList().stl_list();
15329         nodeList = unitFsm->nodeList();
15330       }
15331     }
15332     return nodeList;
15333
15334   }
15335
15336
15337   GenoPro::Shapes::Shape_p GenoPro::Shapes::sequence::element_Shape_at(unsigned int idx)
15338   {
15339     return elements_Shape().at(idx);
15340   }
15341
15342
15343   GenoPro::Shapes::Shape_p GenoPro::Shapes::sequence::add_node_Shape()
15344   {
15345     DOMStringPtr nsUriPtr = new DOMString("libgno");
15346     XsdEvent event(nsUriPtr, NULL, DOMString("Shape"), XsdEvent::ELEMENT_START, false);
15347     this->processEventThrow(event);
15348     return elements_Shape().back();
15349   }
15350
15351   List<GenoPro::Shapes::Shape_ptr> GenoPro::Shapes::sequence::set_count_Shape(unsigned int size)
15352   {
15353     if( (size > -1) || (size < 1)) {
15354       ostringstream oss;
15355       oss << "set_count_Shape: size should be in range: [" << 1
15356         << "," << "unbounded" << "]";
15357       throw IndexOutOfBoundsException(oss.str());
15358     }
15359
15360     unsigned int prevSize = elements_Shape().size();
15361     if(size < prevSize) {
15362       //FIXME: allow later:
15363       throw XPlus::RuntimeException("resize lesser than current size not allowed");
15364     }
15365
15366     for(unsigned int j=prevSize; j<size; j++)
15367     {
15368       // pretend docBuilding to avoid computation of adding after first loop
15369       XsdEvent event(new DOMString("libgno"), NULL, DOMString("Shape"), XsdEvent::ELEMENT_START, false);
15370       this->processEventThrow(event);
15371     }
15372
15373     return elements_Shape();
15374   }
15375
15376
15377
15378   //constructor
15379
15380   GenoPro::Shapes::Shape::Shape(ElementCreateArgs args):
15381       XMLSchema::XmlElement<anyType>(args),
15382
15383     _fsmAttrs(NULL),
15384     _fsmElems(NULL)
15385
15386     , _sequence(new sequence(this) )
15387
15388   {
15389     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
15390     initFSM();
15391     if(args.ownerDoc && args.ownerDoc->buildTree())
15392     {
15393       if(args.ownerDoc->createSample()) {
15394         _fsm->fireSampleEvents();
15395       }
15396       else {
15397         _fsm->fireRequiredEvents();
15398       }
15399     }
15400   }
15401
15402   void GenoPro::Shapes::Shape::initFSM()
15403   {
15404     XsdFsmBasePtr fsmsAttrs[] = {
15405
15406       NULL
15407     };
15408
15409     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
15410
15411     _fsm->replaceContentFsm(_sequence);
15412
15413     _fsmAttrs = _fsm->attributeFsm();
15414     _fsmElems = _fsm->contentFsm();
15415
15416   }
15417
15418   /* element functions  */
15419
15420
15421   GenoPro::Shapes::Shape::Position_ptr GenoPro::Shapes::Shape::create_Position(FsmCbOptions& options)
15422   {
15423     static DOMStringPtr myName = new DOMString("Position");
15424     static DOMStringPtr myNsUri = new DOMString("libgno");
15425
15426     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
15427     GenoPro::Shapes::Shape::Position_p node = XSD::createElementTmpl<Position, void*>(t);
15428
15429     _Position = node;
15430
15431     return node;
15432   }
15433
15434
15435   GenoPro::Shapes::Shape::Position_p GenoPro::Shapes::Shape::element_Position()
15436   {
15437     FSM::warnNullNode(_Position, "Position", "{}Position", 0);
15438     return _Position;
15439   }
15440
15441   void GenoPro::Shapes::Shape::mark_present_Position()
15442   {
15443     return get_sequence()->mark_present_Position();
15444   }
15445
15446
15447   GenoPro::Shapes::Shape::Display_ptr GenoPro::Shapes::Shape::create_Display(FsmCbOptions& options)
15448   {
15449     static DOMStringPtr myName = new DOMString("Display");
15450     static DOMStringPtr myNsUri = new DOMString("libgno");
15451
15452     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
15453     GenoPro::Shapes::Shape::Display_p node = XSD::createElementTmpl<Display, void*>(t);
15454
15455     _Display = node;
15456
15457     return node;
15458   }
15459
15460
15461   GenoPro::Shapes::Shape::Display_p GenoPro::Shapes::Shape::element_Display()
15462   {
15463     FSM::warnNullNode(_Display, "Display", "{}Display", 0);
15464     return _Display;
15465   }
15466
15467   void GenoPro::Shapes::Shape::mark_present_Display()
15468   {
15469     return get_sequence()->mark_present_Display();
15470   }
15471
15472
15473   GenoPro::Shapes::Shape::Comment_ptr GenoPro::Shapes::Shape::create_Comment(FsmCbOptions& options)
15474   {
15475     static DOMStringPtr myName = new DOMString("Comment");
15476     static DOMStringPtr myNsUri = new DOMString("libgno");
15477
15478     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "string");
15479     GenoPro::Shapes::Shape::Comment_p node = XSD::createElementTmpl<Comment, XMLSchema::Types::bt_string*>(t);
15480
15481     if(options.isSampleCreate && (node->stringValue() == "") ) {
15482       node->stringValue(node->sampleValue());
15483     }
15484
15485     _Comment = node;
15486
15487     return node;
15488   }
15489
15490
15491   GenoPro::Shapes::Shape::Comment_p GenoPro::Shapes::Shape::element_Comment()
15492   {
15493     FSM::warnNullNode(_Comment, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
15494     return _Comment;
15495   }
15496
15497   void GenoPro::Shapes::Shape::set_Comment(DOMString val)
15498   {
15499     get_sequence()->set_Comment(val);
15500   }
15501
15502   DOMString GenoPro::Shapes::Shape::get_Comment_string()
15503   {
15504     return get_sequence()->get_Comment_string();
15505   }
15506
15507
15508   void GenoPro::Shapes::Shape::mark_present_Comment()
15509   {
15510     return get_sequence()->mark_present_Comment();
15511   }
15512
15513
15514   /* attribute  functions  */
15515
15516   //constructor
15517   GenoPro::Shapes::Shape::sequence::sequence(Shape* that):
15518     _that(that)
15519   {
15520     XsdFsmBasePtr fsmArray[] = {
15521     new XsdFSM<Position_ptr>( Particle(new DOMString("libgno"), DOMString("Position"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Position_ptr, Shape, FsmCbOptions>(_that, &Shape::create_Position)),
15522       new XsdFSM<Display_ptr>( Particle(new DOMString("libgno"), DOMString("Display"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Display_ptr, Shape, FsmCbOptions>(_that, &Shape::create_Display)),
15523       new XsdFSM<Comment_ptr>( Particle(new DOMString("libgno"), DOMString("Comment"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Comment_ptr, Shape, FsmCbOptions>(_that, &Shape::create_Comment)),
15524
15525       NULL
15526     } ;
15527
15528     XsdSequenceFsmOfFSMs::init(fsmArray);
15529   }
15530
15531
15532
15533   GenoPro::Shapes::Shape::Position_p GenoPro::Shapes::Shape::sequence::element_Position()
15534   {
15535       GenoPro::Shapes::Shape::Position_p node_p = NULL;
15536     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
15537     if(fsm_p)
15538     {
15539       XsdFSM<Position_ptr> *unitFsm = dynamic_cast<XsdFSM<Position_ptr> *>(fsm_p);
15540       if(unitFsm && unitFsm->nodeList().size()>0) {
15541         assert(unitFsm->nodeList().size()==1);
15542         node_p = unitFsm->nodeList().at(0);
15543       }
15544     }
15545
15546     FSM::warnNullNode(node_p, "Position", "{}Position", 0);
15547     return node_p;
15548
15549   }
15550
15551
15552
15553   void GenoPro::Shapes::Shape::sequence::mark_present_Position()
15554   {
15555     DOMStringPtr nsUriPtr = new DOMString("libgno");
15556     XsdEvent event(nsUriPtr, NULL, DOMString("Position"), XsdEvent::ELEMENT_START, false);
15557     this->processEventThrow(event);
15558   }
15559
15560
15561
15562   GenoPro::Shapes::Shape::Display_p GenoPro::Shapes::Shape::sequence::element_Display()
15563   {
15564       GenoPro::Shapes::Shape::Display_p node_p = NULL;
15565     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
15566     if(fsm_p)
15567     {
15568       XsdFSM<Display_ptr> *unitFsm = dynamic_cast<XsdFSM<Display_ptr> *>(fsm_p);
15569       if(unitFsm && unitFsm->nodeList().size()>0) {
15570         assert(unitFsm->nodeList().size()==1);
15571         node_p = unitFsm->nodeList().at(0);
15572       }
15573     }
15574
15575     FSM::warnNullNode(node_p, "Display", "{}Display", 0);
15576     return node_p;
15577
15578   }
15579
15580
15581
15582   void GenoPro::Shapes::Shape::sequence::mark_present_Display()
15583   {
15584     DOMStringPtr nsUriPtr = new DOMString("libgno");
15585     XsdEvent event(nsUriPtr, NULL, DOMString("Display"), XsdEvent::ELEMENT_START, false);
15586     this->processEventThrow(event);
15587   }
15588
15589
15590
15591   GenoPro::Shapes::Shape::Comment_p GenoPro::Shapes::Shape::sequence::element_Comment()
15592   {
15593       GenoPro::Shapes::Shape::Comment_p node_p = NULL;
15594     XsdFsmBase* fsm_p = this->allFSMs()[2].get();
15595     if(fsm_p)
15596     {
15597       XsdFSM<Comment_ptr> *unitFsm = dynamic_cast<XsdFSM<Comment_ptr> *>(fsm_p);
15598       if(unitFsm && unitFsm->nodeList().size()>0) {
15599         assert(unitFsm->nodeList().size()==1);
15600         node_p = unitFsm->nodeList().at(0);
15601       }
15602     }
15603
15604     FSM::warnNullNode(node_p, "Comment", "{http://www.w3.org/2001/XMLSchema}Comment", 0);
15605     return node_p;
15606
15607   }
15608
15609
15610   void GenoPro::Shapes::Shape::sequence::set_Comment(DOMString val)
15611   {
15612
15613     mark_present_Comment();
15614
15615     element_Comment()->stringValue(val);
15616   }
15617
15618   DOMString GenoPro::Shapes::Shape::sequence::get_Comment_string()
15619   {
15620     return element_Comment()->stringValue();
15621   }
15622
15623
15624
15625   void GenoPro::Shapes::Shape::sequence::mark_present_Comment()
15626   {
15627     DOMStringPtr nsUriPtr = new DOMString("libgno");
15628     XsdEvent event(nsUriPtr, NULL, DOMString("Comment"), XsdEvent::ELEMENT_START, false);
15629     this->processEventThrow(event);
15630   }
15631
15632
15633
15634   //constructor
15635
15636   GenoPro::Shapes::Shape::Position::Position(ElementCreateArgs args):
15637       XMLSchema::XmlElement<anyType>(args),
15638
15639     _fsmAttrs(NULL),
15640     _fsmElems(NULL)
15641
15642     , _sequence(new sequence(this) )
15643
15644   {
15645     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
15646     initFSM();
15647     if(args.ownerDoc && args.ownerDoc->buildTree())
15648     {
15649       if(args.ownerDoc->createSample()) {
15650         _fsm->fireSampleEvents();
15651       }
15652       else {
15653         _fsm->fireRequiredEvents();
15654       }
15655     }
15656   }
15657
15658   void GenoPro::Shapes::Shape::Position::initFSM()
15659   {
15660     XsdFsmBasePtr fsmsAttrs[] = {
15661   new XsdFSM<attr_Size_ptr>( Particle(NULL, DOMString("Size"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Size_ptr, Position, FsmCbOptions>(this, &Position::create_attr_Size)),
15662   new XsdFSM<attr_GenoMap_ptr>( Particle(NULL, DOMString("GenoMap"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_GenoMap_ptr, Position, FsmCbOptions>(this, &Position::create_attr_GenoMap)),
15663
15664       NULL
15665     };
15666
15667     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
15668
15669     _fsm->replaceContentFsm(_sequence);
15670
15671     _fsmAttrs = _fsm->attributeFsm();
15672     _fsmElems = _fsm->contentFsm();
15673
15674   }
15675
15676   /* element functions  */
15677
15678
15679   GenoPro::Shapes::Shape::Position::Points_ptr GenoPro::Shapes::Shape::Position::create_Points(FsmCbOptions& options)
15680   {
15681     static DOMStringPtr myName = new DOMString("Points");
15682     static DOMStringPtr myNsUri = new DOMString("libgno");
15683
15684     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false, "http://www.w3.org/2001/XMLSchema", "normalizedString");
15685     GenoPro::Shapes::Shape::Position::Points_p node = XSD::createElementTmpl<Points, XMLSchema::Types::bt_normalizedString*>(t);
15686
15687     if(options.isSampleCreate && (node->stringValue() == "") ) {
15688       node->stringValue(node->sampleValue());
15689     }
15690
15691     _Points = node;
15692
15693     return node;
15694   }
15695
15696
15697   GenoPro::Shapes::Shape::Position::Points_p GenoPro::Shapes::Shape::Position::element_Points()
15698   {
15699     FSM::warnNullNode(_Points, "Points", "{http://www.w3.org/2001/XMLSchema}Points", 0);
15700     return _Points;
15701   }
15702
15703   void GenoPro::Shapes::Shape::Position::set_Points(DOMString val)
15704   {
15705     get_sequence()->set_Points(val);
15706   }
15707
15708   DOMString GenoPro::Shapes::Shape::Position::get_Points_string()
15709   {
15710     return get_sequence()->get_Points_string();
15711   }
15712
15713
15714   void GenoPro::Shapes::Shape::Position::mark_present_Points()
15715   {
15716     return get_sequence()->mark_present_Points();
15717   }
15718
15719
15720   /* attribute  functions  */
15721
15722
15723   GenoPro::Shapes::Shape::Position::attr_Size_ptr GenoPro::Shapes::Shape::Position::create_attr_Size(FsmCbOptions& options)
15724   {
15725     static DOMStringPtr myName = new DOMString("Size");
15726     static DOMStringPtr myNsUri = NULL;
15727
15728     if(_attr_Size) {
15729       return _attr_Size;
15730     }
15731     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
15732     GenoPro::Shapes::Shape::Position::attr_Size_p node = XSD::createAttributeTmpl<attr_Size>(t);
15733
15734     if(options.isSampleCreate && (node->stringValue() == "") ) {
15735       node->stringValue(node->sampleValue());
15736     }
15737
15738     _attr_Size = node;
15739
15740     return node;
15741   }
15742
15743
15744     void GenoPro::Shapes::Shape::Position::set_attr_Size(DOMString val)
15745     {
15746
15747       attribute_attr_Size()->stringValue(val);
15748     }
15749
15750     DOMString GenoPro::Shapes::Shape::Position::get_attr_Size_string()
15751     {
15752
15753       return attribute_attr_Size()->stringValue();
15754     }
15755
15756
15757   GenoPro::Shapes::Shape::Position::attr_Size_p GenoPro::Shapes::Shape::Position::attribute_attr_Size()
15758   {
15759     FSM::warnNullNode(_attr_Size, "attr_Size", "{http://www.w3.org/2001/XMLSchema}Size", 1);
15760     return _attr_Size;
15761   }
15762
15763
15764   GenoPro::Shapes::Shape::Position::attr_GenoMap_ptr GenoPro::Shapes::Shape::Position::create_attr_GenoMap(FsmCbOptions& options)
15765   {
15766     static DOMStringPtr myName = new DOMString("GenoMap");
15767     static DOMStringPtr myNsUri = NULL;
15768
15769     if(_attr_GenoMap) {
15770       return _attr_GenoMap;
15771     }
15772     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
15773     GenoPro::Shapes::Shape::Position::attr_GenoMap_p node = XSD::createAttributeTmpl<attr_GenoMap>(t);
15774
15775     if(options.isSampleCreate && (node->stringValue() == "") ) {
15776       node->stringValue(node->sampleValue());
15777     }
15778
15779     _attr_GenoMap = node;
15780
15781     return node;
15782   }
15783
15784
15785     void GenoPro::Shapes::Shape::Position::set_attr_GenoMap(DOMString val)
15786     {
15787
15788       attribute_attr_GenoMap()->stringValue(val);
15789     }
15790
15791     DOMString GenoPro::Shapes::Shape::Position::get_attr_GenoMap_string()
15792     {
15793
15794       return attribute_attr_GenoMap()->stringValue();
15795     }
15796
15797
15798   GenoPro::Shapes::Shape::Position::attr_GenoMap_p GenoPro::Shapes::Shape::Position::attribute_attr_GenoMap()
15799   {
15800     FSM::warnNullNode(_attr_GenoMap, "attr_GenoMap", "{http://www.w3.org/2001/XMLSchema}GenoMap", 1);
15801     return _attr_GenoMap;
15802   }
15803
15804   //constructor
15805   GenoPro::Shapes::Shape::Position::sequence::sequence(Position* that):
15806     _that(that)
15807   {
15808     XsdFsmBasePtr fsmArray[] = {
15809     new XsdFSM<Points_ptr>( Particle(new DOMString("libgno"), DOMString("Points"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Points_ptr, Position, FsmCbOptions>(_that, &Position::create_Points)),
15810
15811       NULL
15812     } ;
15813
15814     XsdSequenceFsmOfFSMs::init(fsmArray);
15815   }
15816
15817
15818
15819   GenoPro::Shapes::Shape::Position::Points_p GenoPro::Shapes::Shape::Position::sequence::element_Points()
15820   {
15821       GenoPro::Shapes::Shape::Position::Points_p node_p = NULL;
15822     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
15823     if(fsm_p)
15824     {
15825       XsdFSM<Points_ptr> *unitFsm = dynamic_cast<XsdFSM<Points_ptr> *>(fsm_p);
15826       if(unitFsm && unitFsm->nodeList().size()>0) {
15827         assert(unitFsm->nodeList().size()==1);
15828         node_p = unitFsm->nodeList().at(0);
15829       }
15830     }
15831
15832     FSM::warnNullNode(node_p, "Points", "{http://www.w3.org/2001/XMLSchema}Points", 0);
15833     return node_p;
15834
15835   }
15836
15837
15838   void GenoPro::Shapes::Shape::Position::sequence::set_Points(DOMString val)
15839   {
15840
15841     mark_present_Points();
15842
15843     element_Points()->stringValue(val);
15844   }
15845
15846   DOMString GenoPro::Shapes::Shape::Position::sequence::get_Points_string()
15847   {
15848     return element_Points()->stringValue();
15849   }
15850
15851
15852
15853   void GenoPro::Shapes::Shape::Position::sequence::mark_present_Points()
15854   {
15855     DOMStringPtr nsUriPtr = new DOMString("libgno");
15856     XsdEvent event(nsUriPtr, NULL, DOMString("Points"), XsdEvent::ELEMENT_START, false);
15857     this->processEventThrow(event);
15858   }
15859
15860
15861
15862   //constructor
15863
15864   GenoPro::Shapes::Shape::Display::Display(ElementCreateArgs args):
15865       XMLSchema::XmlElement<anyType>(args),
15866
15867     _fsmAttrs(NULL),
15868     _fsmElems(NULL)
15869
15870     , _sequence(new sequence(this) )
15871
15872   {
15873     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
15874     initFSM();
15875     if(args.ownerDoc && args.ownerDoc->buildTree())
15876     {
15877       if(args.ownerDoc->createSample()) {
15878         _fsm->fireSampleEvents();
15879       }
15880       else {
15881         _fsm->fireRequiredEvents();
15882       }
15883     }
15884   }
15885
15886   void GenoPro::Shapes::Shape::Display::initFSM()
15887   {
15888     XsdFsmBasePtr fsmsAttrs[] = {
15889
15890       NULL
15891     };
15892
15893     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
15894
15895     _fsm->replaceContentFsm(_sequence);
15896
15897     _fsmAttrs = _fsm->attributeFsm();
15898     _fsmElems = _fsm->contentFsm();
15899
15900   }
15901
15902   /* element functions  */
15903
15904
15905   GenoPro::Shapes::Shape::Display::Color_ptr GenoPro::Shapes::Shape::Display::create_Color(FsmCbOptions& options)
15906   {
15907     static DOMStringPtr myName = new DOMString("Color");
15908     static DOMStringPtr myNsUri = new DOMString("libgno");
15909
15910     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
15911     GenoPro::Shapes::Shape::Display::Color_p node = XSD::createElementTmpl<Color, void*>(t);
15912
15913     if(options.isSampleCreate && (node->stringValue() == "") ) {
15914       node->stringValue(node->sampleValue());
15915     }
15916
15917     _Color = node;
15918
15919     return node;
15920   }
15921
15922
15923   GenoPro::Shapes::Shape::Display::Color_p GenoPro::Shapes::Shape::Display::element_Color()
15924   {
15925     FSM::warnNullNode(_Color, "Color", "{}Color", 0);
15926     return _Color;
15927   }
15928
15929   void GenoPro::Shapes::Shape::Display::mark_present_Color()
15930   {
15931     return get_sequence()->mark_present_Color();
15932   }
15933
15934
15935   /* attribute  functions  */
15936
15937   //constructor
15938   GenoPro::Shapes::Shape::Display::sequence::sequence(Display* that):
15939     _that(that)
15940   {
15941     XsdFsmBasePtr fsmArray[] = {
15942     new XsdFSM<Color_ptr>( Particle(new DOMString("libgno"), DOMString("Color"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Color_ptr, Display, FsmCbOptions>(_that, &Display::create_Color)),
15943
15944       NULL
15945     } ;
15946
15947     XsdSequenceFsmOfFSMs::init(fsmArray);
15948   }
15949
15950
15951
15952   GenoPro::Shapes::Shape::Display::Color_p GenoPro::Shapes::Shape::Display::sequence::element_Color()
15953   {
15954       GenoPro::Shapes::Shape::Display::Color_p node_p = NULL;
15955     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
15956     if(fsm_p)
15957     {
15958       XsdFSM<Color_ptr> *unitFsm = dynamic_cast<XsdFSM<Color_ptr> *>(fsm_p);
15959       if(unitFsm && unitFsm->nodeList().size()>0) {
15960         assert(unitFsm->nodeList().size()==1);
15961         node_p = unitFsm->nodeList().at(0);
15962       }
15963     }
15964
15965     FSM::warnNullNode(node_p, "Color", "{}Color", 0);
15966     return node_p;
15967
15968   }
15969
15970
15971
15972   void GenoPro::Shapes::Shape::Display::sequence::mark_present_Color()
15973   {
15974     DOMStringPtr nsUriPtr = new DOMString("libgno");
15975     XsdEvent event(nsUriPtr, NULL, DOMString("Color"), XsdEvent::ELEMENT_START, false);
15976     this->processEventThrow(event);
15977   }
15978
15979
15980   //constructor
15981
15982   GenoPro::Shapes::Shape::Display::Color::Color(ElementCreateArgs args):
15983       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
15984
15985     _fsmAttrs(NULL),
15986     _fsmElems(NULL)
15987   {
15988
15989
15990     initFSM();
15991
15992
15993     if(args.ownerDoc && args.ownerDoc->buildTree())
15994
15995     {
15996       if(args.ownerDoc->createSample()) {
15997         _fsm->fireSampleEvents();
15998       }
15999       else {
16000         _fsm->fireRequiredEvents();
16001       }
16002     }
16003   }
16004
16005   void GenoPro::Shapes::Shape::Display::Color::initFSM()
16006   {
16007     XsdFsmBasePtr fsmsAttrs[] = {
16008     new XsdFSM<attr_Line_ptr>( Particle(NULL, DOMString("Line"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Line_ptr, Color, FsmCbOptions>(this, &Color::create_attr_Line)),
16009     new XsdFSM<attr_Fill_ptr>( Particle(NULL, DOMString("Fill"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Fill_ptr, Color, FsmCbOptions>(this, &Color::create_attr_Fill)),
16010
16011       NULL
16012     };
16013
16014     _fsm->appendAttributeFsms(fsmsAttrs);
16015     _fsmAttrs = _fsm->attributeFsm();
16016     _fsmElems = _fsm->contentFsm();
16017
16018    }
16019
16020   /* element functions  */
16021
16022
16023   /* attribute  functions  */
16024
16025
16026   GenoPro::Shapes::Shape::Display::Color::attr_Line_ptr GenoPro::Shapes::Shape::Display::Color::create_attr_Line(FsmCbOptions& options)
16027   {
16028     static DOMStringPtr myName = new DOMString("Line");
16029     static DOMStringPtr myNsUri = NULL;
16030
16031     if(_attr_Line) {
16032       return _attr_Line;
16033     }
16034     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16035     GenoPro::Shapes::Shape::Display::Color::attr_Line_p node = XSD::createAttributeTmpl<attr_Line>(t);
16036
16037     if(options.isSampleCreate && (node->stringValue() == "") ) {
16038       node->stringValue(node->sampleValue());
16039     }
16040
16041     _attr_Line = node;
16042
16043     return node;
16044   }
16045
16046
16047     void GenoPro::Shapes::Shape::Display::Color::set_attr_Line(DOMString val)
16048     {
16049
16050       attribute_attr_Line()->stringValue(val);
16051     }
16052
16053     DOMString GenoPro::Shapes::Shape::Display::Color::get_attr_Line_string()
16054     {
16055
16056       return attribute_attr_Line()->stringValue();
16057     }
16058
16059
16060   GenoPro::Shapes::Shape::Display::Color::attr_Line_p GenoPro::Shapes::Shape::Display::Color::attribute_attr_Line()
16061   {
16062     FSM::warnNullNode(_attr_Line, "attr_Line", "{http://www.w3.org/2001/XMLSchema}Line", 1);
16063     return _attr_Line;
16064   }
16065
16066
16067   GenoPro::Shapes::Shape::Display::Color::attr_Fill_ptr GenoPro::Shapes::Shape::Display::Color::create_attr_Fill(FsmCbOptions& options)
16068   {
16069     static DOMStringPtr myName = new DOMString("Fill");
16070     static DOMStringPtr myNsUri = NULL;
16071
16072     if(_attr_Fill) {
16073       return _attr_Fill;
16074     }
16075     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16076     GenoPro::Shapes::Shape::Display::Color::attr_Fill_p node = XSD::createAttributeTmpl<attr_Fill>(t);
16077
16078     if(options.isSampleCreate && (node->stringValue() == "") ) {
16079       node->stringValue(node->sampleValue());
16080     }
16081
16082     _attr_Fill = node;
16083
16084     return node;
16085   }
16086
16087
16088     void GenoPro::Shapes::Shape::Display::Color::set_attr_Fill(DOMString val)
16089     {
16090
16091       attribute_attr_Fill()->stringValue(val);
16092     }
16093
16094     DOMString GenoPro::Shapes::Shape::Display::Color::get_attr_Fill_string()
16095     {
16096
16097       return attribute_attr_Fill()->stringValue();
16098     }
16099
16100
16101   GenoPro::Shapes::Shape::Display::Color::attr_Fill_p GenoPro::Shapes::Shape::Display::Color::attribute_attr_Fill()
16102   {
16103     FSM::warnNullNode(_attr_Fill, "attr_Fill", "{http://www.w3.org/2001/XMLSchema}Fill", 1);
16104     return _attr_Fill;
16105   }
16106
16107
16108   //constructor
16109
16110   GenoPro::SocialRelationships::SocialRelationships(ElementCreateArgs args):
16111       XMLSchema::XmlElement<anyType>(args),
16112
16113     _fsmAttrs(NULL),
16114     _fsmElems(NULL)
16115
16116     , _sequence(new sequence(this) )
16117
16118   {
16119     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
16120     initFSM();
16121     if(args.ownerDoc && args.ownerDoc->buildTree())
16122     {
16123       if(args.ownerDoc->createSample()) {
16124         _fsm->fireSampleEvents();
16125       }
16126       else {
16127         _fsm->fireRequiredEvents();
16128       }
16129     }
16130   }
16131
16132   void GenoPro::SocialRelationships::initFSM()
16133   {
16134     XsdFsmBasePtr fsmsAttrs[] = {
16135
16136       NULL
16137     };
16138
16139     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
16140
16141     _fsm->replaceContentFsm(_sequence);
16142
16143     _fsmAttrs = _fsm->attributeFsm();
16144     _fsmElems = _fsm->contentFsm();
16145
16146   }
16147
16148   /* element functions  */
16149
16150
16151   GenoPro::SocialRelationships::SocialRelationship_ptr GenoPro::SocialRelationships::create_SocialRelationship(FsmCbOptions& options)
16152   {
16153     static DOMStringPtr myName = new DOMString("SocialRelationship");
16154     static DOMStringPtr myNsUri = new DOMString("libgno");
16155
16156     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
16157     GenoPro::SocialRelationships::SocialRelationship_p node = XSD::createElementTmpl<SocialRelationship, void*>(t);
16158
16159     _list_SocialRelationship.push_back(node);
16160
16161     return node;
16162   }
16163
16164
16165   GenoPro::SocialRelationships::SocialRelationship_p GenoPro::SocialRelationships::element_SocialRelationship_at(unsigned int idx)
16166   {
16167     if(idx > _list_SocialRelationship.size()-1) {
16168       throw IndexOutOfBoundsException("IndexOutOfBoundsException");
16169     }
16170
16171     return _list_SocialRelationship.at(idx);
16172   }
16173
16174   List<GenoPro::SocialRelationships::SocialRelationship_ptr> GenoPro::SocialRelationships::elements_SocialRelationship()
16175   {
16176     return _list_SocialRelationship;
16177   }
16178
16179   GenoPro::SocialRelationships::SocialRelationship_p GenoPro::SocialRelationships::add_node_SocialRelationship()
16180   {
16181     return get_sequence()->add_node_SocialRelationship();
16182   }
16183
16184   List<GenoPro::SocialRelationships::SocialRelationship_ptr> GenoPro::SocialRelationships::set_count_SocialRelationship(unsigned int size)
16185   {
16186     return get_sequence()->set_count_SocialRelationship(size);
16187   }
16188
16189
16190
16191   /* attribute  functions  */
16192
16193   //constructor
16194   GenoPro::SocialRelationships::sequence::sequence(SocialRelationships* that):
16195     _that(that)
16196   {
16197     XsdFsmBasePtr fsmArray[] = {
16198     new XsdFSM<SocialRelationship_ptr>( Particle(new DOMString("libgno"), DOMString("SocialRelationship"), 1, -1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<SocialRelationship_ptr, SocialRelationships, FsmCbOptions>(_that, &SocialRelationships::create_SocialRelationship)),
16199
16200       NULL
16201     } ;
16202
16203     XsdSequenceFsmOfFSMs::init(fsmArray);
16204   }
16205
16206
16207
16208   List<GenoPro::SocialRelationships::SocialRelationship_ptr> GenoPro::SocialRelationships::sequence::elements_SocialRelationship()
16209   {
16210
16211     List<SocialRelationship_ptr> nodeList;
16212     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
16213     if(fsm_p)
16214     {
16215       XsdFSM<SocialRelationship_ptr> *unitFsm = dynamic_cast<XsdFSM<SocialRelationship_ptr> *>(fsm_p);
16216       if(unitFsm) {
16217         //nodeList = unitFsm->nodeList().stl_list();
16218         nodeList = unitFsm->nodeList();
16219       }
16220     }
16221     return nodeList;
16222
16223   }
16224
16225
16226   GenoPro::SocialRelationships::SocialRelationship_p GenoPro::SocialRelationships::sequence::element_SocialRelationship_at(unsigned int idx)
16227   {
16228     return elements_SocialRelationship().at(idx);
16229   }
16230
16231
16232   GenoPro::SocialRelationships::SocialRelationship_p GenoPro::SocialRelationships::sequence::add_node_SocialRelationship()
16233   {
16234     DOMStringPtr nsUriPtr = new DOMString("libgno");
16235     XsdEvent event(nsUriPtr, NULL, DOMString("SocialRelationship"), XsdEvent::ELEMENT_START, false);
16236     this->processEventThrow(event);
16237     return elements_SocialRelationship().back();
16238   }
16239
16240   List<GenoPro::SocialRelationships::SocialRelationship_ptr> GenoPro::SocialRelationships::sequence::set_count_SocialRelationship(unsigned int size)
16241   {
16242     if( (size > -1) || (size < 1)) {
16243       ostringstream oss;
16244       oss << "set_count_SocialRelationship: size should be in range: [" << 1
16245         << "," << "unbounded" << "]";
16246       throw IndexOutOfBoundsException(oss.str());
16247     }
16248
16249     unsigned int prevSize = elements_SocialRelationship().size();
16250     if(size < prevSize) {
16251       //FIXME: allow later:
16252       throw XPlus::RuntimeException("resize lesser than current size not allowed");
16253     }
16254
16255     for(unsigned int j=prevSize; j<size; j++)
16256     {
16257       // pretend docBuilding to avoid computation of adding after first loop
16258       XsdEvent event(new DOMString("libgno"), NULL, DOMString("SocialRelationship"), XsdEvent::ELEMENT_START, false);
16259       this->processEventThrow(event);
16260     }
16261
16262     return elements_SocialRelationship();
16263   }
16264
16265
16266
16267   //constructor
16268
16269   GenoPro::SocialRelationships::SocialRelationship::SocialRelationship(ElementCreateArgs args):
16270       XMLSchema::XmlElement<anyType>(args),
16271
16272     _fsmAttrs(NULL),
16273     _fsmElems(NULL)
16274
16275     , _sequence(new sequence(this) )
16276
16277   {
16278     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
16279     initFSM();
16280     if(args.ownerDoc && args.ownerDoc->buildTree())
16281     {
16282       if(args.ownerDoc->createSample()) {
16283         _fsm->fireSampleEvents();
16284       }
16285       else {
16286         _fsm->fireRequiredEvents();
16287       }
16288     }
16289   }
16290
16291   void GenoPro::SocialRelationships::SocialRelationship::initFSM()
16292   {
16293     XsdFsmBasePtr fsmsAttrs[] = {
16294   new XsdFSM<attr_Connection_ptr>( Particle(NULL, DOMString("Connection"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Connection_ptr, SocialRelationship, FsmCbOptions>(this, &SocialRelationship::create_attr_Connection)),
16295   new XsdFSM<attr_Entity1_ptr>( Particle(NULL, DOMString("Entity1"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Entity1_ptr, SocialRelationship, FsmCbOptions>(this, &SocialRelationship::create_attr_Entity1)),
16296   new XsdFSM<attr_Entity2_ptr>( Particle(NULL, DOMString("Entity2"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Entity2_ptr, SocialRelationship, FsmCbOptions>(this, &SocialRelationship::create_attr_Entity2)),
16297
16298       NULL
16299     };
16300
16301     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
16302
16303     _fsm->replaceContentFsm(_sequence);
16304
16305     _fsmAttrs = _fsm->attributeFsm();
16306     _fsmElems = _fsm->contentFsm();
16307
16308   }
16309
16310   /* element functions  */
16311
16312
16313   GenoPro::SocialRelationships::SocialRelationship::Display_ptr GenoPro::SocialRelationships::SocialRelationship::create_Display(FsmCbOptions& options)
16314   {
16315     static DOMStringPtr myName = new DOMString("Display");
16316     static DOMStringPtr myNsUri = new DOMString("libgno");
16317
16318     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
16319     GenoPro::SocialRelationships::SocialRelationship::Display_p node = XSD::createElementTmpl<Display, void*>(t);
16320
16321     _Display = node;
16322
16323     return node;
16324   }
16325
16326
16327   GenoPro::SocialRelationships::SocialRelationship::Display_p GenoPro::SocialRelationships::SocialRelationship::element_Display()
16328   {
16329     FSM::warnNullNode(_Display, "Display", "{}Display", 0);
16330     return _Display;
16331   }
16332
16333   void GenoPro::SocialRelationships::SocialRelationship::mark_present_Display()
16334   {
16335     return get_sequence()->mark_present_Display();
16336   }
16337
16338
16339   /* attribute  functions  */
16340
16341
16342   GenoPro::SocialRelationships::SocialRelationship::attr_Connection_ptr GenoPro::SocialRelationships::SocialRelationship::create_attr_Connection(FsmCbOptions& options)
16343   {
16344     static DOMStringPtr myName = new DOMString("Connection");
16345     static DOMStringPtr myNsUri = NULL;
16346
16347     if(_attr_Connection) {
16348       return _attr_Connection;
16349     }
16350     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16351     GenoPro::SocialRelationships::SocialRelationship::attr_Connection_p node = XSD::createAttributeTmpl<attr_Connection>(t);
16352
16353     if(options.isSampleCreate && (node->stringValue() == "") ) {
16354       node->stringValue(node->sampleValue());
16355     }
16356
16357     _attr_Connection = node;
16358
16359     return node;
16360   }
16361
16362
16363     void GenoPro::SocialRelationships::SocialRelationship::set_attr_Connection(DOMString val)
16364     {
16365
16366       attribute_attr_Connection()->stringValue(val);
16367     }
16368
16369     DOMString GenoPro::SocialRelationships::SocialRelationship::get_attr_Connection_string()
16370     {
16371
16372       return attribute_attr_Connection()->stringValue();
16373     }
16374
16375
16376   GenoPro::SocialRelationships::SocialRelationship::attr_Connection_p GenoPro::SocialRelationships::SocialRelationship::attribute_attr_Connection()
16377   {
16378     FSM::warnNullNode(_attr_Connection, "attr_Connection", "{http://www.w3.org/2001/XMLSchema}Connection", 1);
16379     return _attr_Connection;
16380   }
16381
16382
16383   GenoPro::SocialRelationships::SocialRelationship::attr_Entity1_ptr GenoPro::SocialRelationships::SocialRelationship::create_attr_Entity1(FsmCbOptions& options)
16384   {
16385     static DOMStringPtr myName = new DOMString("Entity1");
16386     static DOMStringPtr myNsUri = NULL;
16387
16388     if(_attr_Entity1) {
16389       return _attr_Entity1;
16390     }
16391     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16392     GenoPro::SocialRelationships::SocialRelationship::attr_Entity1_p node = XSD::createAttributeTmpl<attr_Entity1>(t);
16393
16394     if(options.isSampleCreate && (node->stringValue() == "") ) {
16395       node->stringValue(node->sampleValue());
16396     }
16397
16398     _attr_Entity1 = node;
16399
16400     return node;
16401   }
16402
16403
16404     void GenoPro::SocialRelationships::SocialRelationship::set_attr_Entity1(DOMString val)
16405     {
16406
16407       attribute_attr_Entity1()->stringValue(val);
16408     }
16409
16410     DOMString GenoPro::SocialRelationships::SocialRelationship::get_attr_Entity1_string()
16411     {
16412
16413       return attribute_attr_Entity1()->stringValue();
16414     }
16415
16416
16417   GenoPro::SocialRelationships::SocialRelationship::attr_Entity1_p GenoPro::SocialRelationships::SocialRelationship::attribute_attr_Entity1()
16418   {
16419     FSM::warnNullNode(_attr_Entity1, "attr_Entity1", "{http://www.w3.org/2001/XMLSchema}Entity1", 1);
16420     return _attr_Entity1;
16421   }
16422
16423
16424   GenoPro::SocialRelationships::SocialRelationship::attr_Entity2_ptr GenoPro::SocialRelationships::SocialRelationship::create_attr_Entity2(FsmCbOptions& options)
16425   {
16426     static DOMStringPtr myName = new DOMString("Entity2");
16427     static DOMStringPtr myNsUri = NULL;
16428
16429     if(_attr_Entity2) {
16430       return _attr_Entity2;
16431     }
16432     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16433     GenoPro::SocialRelationships::SocialRelationship::attr_Entity2_p node = XSD::createAttributeTmpl<attr_Entity2>(t);
16434
16435     if(options.isSampleCreate && (node->stringValue() == "") ) {
16436       node->stringValue(node->sampleValue());
16437     }
16438
16439     _attr_Entity2 = node;
16440
16441     return node;
16442   }
16443
16444
16445     void GenoPro::SocialRelationships::SocialRelationship::set_attr_Entity2(DOMString val)
16446     {
16447
16448       attribute_attr_Entity2()->stringValue(val);
16449     }
16450
16451     DOMString GenoPro::SocialRelationships::SocialRelationship::get_attr_Entity2_string()
16452     {
16453
16454       return attribute_attr_Entity2()->stringValue();
16455     }
16456
16457
16458   GenoPro::SocialRelationships::SocialRelationship::attr_Entity2_p GenoPro::SocialRelationships::SocialRelationship::attribute_attr_Entity2()
16459   {
16460     FSM::warnNullNode(_attr_Entity2, "attr_Entity2", "{http://www.w3.org/2001/XMLSchema}Entity2", 1);
16461     return _attr_Entity2;
16462   }
16463
16464   //constructor
16465   GenoPro::SocialRelationships::SocialRelationship::sequence::sequence(SocialRelationship* that):
16466     _that(that)
16467   {
16468     XsdFsmBasePtr fsmArray[] = {
16469     new XsdFSM<Display_ptr>( Particle(new DOMString("libgno"), DOMString("Display"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Display_ptr, SocialRelationship, FsmCbOptions>(_that, &SocialRelationship::create_Display)),
16470
16471       NULL
16472     } ;
16473
16474     XsdSequenceFsmOfFSMs::init(fsmArray);
16475   }
16476
16477
16478
16479   GenoPro::SocialRelationships::SocialRelationship::Display_p GenoPro::SocialRelationships::SocialRelationship::sequence::element_Display()
16480   {
16481       GenoPro::SocialRelationships::SocialRelationship::Display_p node_p = NULL;
16482     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
16483     if(fsm_p)
16484     {
16485       XsdFSM<Display_ptr> *unitFsm = dynamic_cast<XsdFSM<Display_ptr> *>(fsm_p);
16486       if(unitFsm && unitFsm->nodeList().size()>0) {
16487         assert(unitFsm->nodeList().size()==1);
16488         node_p = unitFsm->nodeList().at(0);
16489       }
16490     }
16491
16492     FSM::warnNullNode(node_p, "Display", "{}Display", 0);
16493     return node_p;
16494
16495   }
16496
16497
16498
16499   void GenoPro::SocialRelationships::SocialRelationship::sequence::mark_present_Display()
16500   {
16501     DOMStringPtr nsUriPtr = new DOMString("libgno");
16502     XsdEvent event(nsUriPtr, NULL, DOMString("Display"), XsdEvent::ELEMENT_START, false);
16503     this->processEventThrow(event);
16504   }
16505
16506
16507
16508   //constructor
16509
16510   GenoPro::SocialRelationships::SocialRelationship::Display::Display(ElementCreateArgs args):
16511       XMLSchema::XmlElement<anyType>(args),
16512
16513     _fsmAttrs(NULL),
16514     _fsmElems(NULL)
16515
16516     , _sequence(new sequence(this) )
16517
16518   {
16519     this->contentTypeVariety(CONTENT_TYPE_VARIETY_MIXED);
16520     initFSM();
16521     if(args.ownerDoc && args.ownerDoc->buildTree())
16522     {
16523       if(args.ownerDoc->createSample()) {
16524         _fsm->fireSampleEvents();
16525       }
16526       else {
16527         _fsm->fireRequiredEvents();
16528       }
16529     }
16530   }
16531
16532   void GenoPro::SocialRelationships::SocialRelationship::Display::initFSM()
16533   {
16534     XsdFsmBasePtr fsmsAttrs[] = {
16535
16536       NULL
16537     };
16538
16539     _fsm->replaceOrAppendUniqueAttributeFsms(fsmsAttrs);
16540
16541     _fsm->replaceContentFsm(_sequence);
16542
16543     _fsmAttrs = _fsm->attributeFsm();
16544     _fsmElems = _fsm->contentFsm();
16545
16546   }
16547
16548   /* element functions  */
16549
16550
16551   GenoPro::SocialRelationships::SocialRelationship::Display::Color_ptr GenoPro::SocialRelationships::SocialRelationship::Display::create_Color(FsmCbOptions& options)
16552   {
16553     static DOMStringPtr myName = new DOMString("Color");
16554     static DOMStringPtr myNsUri = new DOMString("libgno");
16555
16556     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
16557     GenoPro::SocialRelationships::SocialRelationship::Display::Color_p node = XSD::createElementTmpl<Color, void*>(t);
16558
16559     if(options.isSampleCreate && (node->stringValue() == "") ) {
16560       node->stringValue(node->sampleValue());
16561     }
16562
16563     _Color = node;
16564
16565     return node;
16566   }
16567
16568
16569   GenoPro::SocialRelationships::SocialRelationship::Display::Color_p GenoPro::SocialRelationships::SocialRelationship::Display::element_Color()
16570   {
16571     FSM::warnNullNode(_Color, "Color", "{}Color", 0);
16572     return _Color;
16573   }
16574
16575   void GenoPro::SocialRelationships::SocialRelationship::Display::mark_present_Color()
16576   {
16577     return get_sequence()->mark_present_Color();
16578   }
16579
16580
16581   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow_ptr GenoPro::SocialRelationships::SocialRelationship::Display::create_Arrow(FsmCbOptions& options)
16582   {
16583     static DOMStringPtr myName = new DOMString("Arrow");
16584     static DOMStringPtr myNsUri = new DOMString("libgno");
16585
16586     XSD::StructCreateElementThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options, false, false, false);
16587     GenoPro::SocialRelationships::SocialRelationship::Display::Arrow_p node = XSD::createElementTmpl<Arrow, void*>(t);
16588
16589     if(options.isSampleCreate && (node->stringValue() == "") ) {
16590       node->stringValue(node->sampleValue());
16591     }
16592
16593     _Arrow = node;
16594
16595     return node;
16596   }
16597
16598
16599   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow_p GenoPro::SocialRelationships::SocialRelationship::Display::element_Arrow()
16600   {
16601     FSM::warnNullNode(_Arrow, "Arrow", "{}Arrow", 0);
16602     return _Arrow;
16603   }
16604
16605   void GenoPro::SocialRelationships::SocialRelationship::Display::mark_present_Arrow()
16606   {
16607     return get_sequence()->mark_present_Arrow();
16608   }
16609
16610
16611   /* attribute  functions  */
16612
16613   //constructor
16614   GenoPro::SocialRelationships::SocialRelationship::Display::sequence::sequence(Display* that):
16615     _that(that)
16616   {
16617     XsdFsmBasePtr fsmArray[] = {
16618     new XsdFSM<Color_ptr>( Particle(new DOMString("libgno"), DOMString("Color"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Color_ptr, Display, FsmCbOptions>(_that, &Display::create_Color)),
16619       new XsdFSM<Arrow_ptr>( Particle(new DOMString("libgno"), DOMString("Arrow"), 0, 1), XsdEvent::ELEMENT_START, new object_unary_mem_fun_t<Arrow_ptr, Display, FsmCbOptions>(_that, &Display::create_Arrow)),
16620
16621       NULL
16622     } ;
16623
16624     XsdSequenceFsmOfFSMs::init(fsmArray);
16625   }
16626
16627
16628
16629   GenoPro::SocialRelationships::SocialRelationship::Display::Color_p GenoPro::SocialRelationships::SocialRelationship::Display::sequence::element_Color()
16630   {
16631       GenoPro::SocialRelationships::SocialRelationship::Display::Color_p node_p = NULL;
16632     XsdFsmBase* fsm_p = this->allFSMs()[0].get();
16633     if(fsm_p)
16634     {
16635       XsdFSM<Color_ptr> *unitFsm = dynamic_cast<XsdFSM<Color_ptr> *>(fsm_p);
16636       if(unitFsm && unitFsm->nodeList().size()>0) {
16637         assert(unitFsm->nodeList().size()==1);
16638         node_p = unitFsm->nodeList().at(0);
16639       }
16640     }
16641
16642     FSM::warnNullNode(node_p, "Color", "{}Color", 0);
16643     return node_p;
16644
16645   }
16646
16647
16648
16649   void GenoPro::SocialRelationships::SocialRelationship::Display::sequence::mark_present_Color()
16650   {
16651     DOMStringPtr nsUriPtr = new DOMString("libgno");
16652     XsdEvent event(nsUriPtr, NULL, DOMString("Color"), XsdEvent::ELEMENT_START, false);
16653     this->processEventThrow(event);
16654   }
16655
16656
16657
16658   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow_p GenoPro::SocialRelationships::SocialRelationship::Display::sequence::element_Arrow()
16659   {
16660       GenoPro::SocialRelationships::SocialRelationship::Display::Arrow_p node_p = NULL;
16661     XsdFsmBase* fsm_p = this->allFSMs()[1].get();
16662     if(fsm_p)
16663     {
16664       XsdFSM<Arrow_ptr> *unitFsm = dynamic_cast<XsdFSM<Arrow_ptr> *>(fsm_p);
16665       if(unitFsm && unitFsm->nodeList().size()>0) {
16666         assert(unitFsm->nodeList().size()==1);
16667         node_p = unitFsm->nodeList().at(0);
16668       }
16669     }
16670
16671     FSM::warnNullNode(node_p, "Arrow", "{}Arrow", 0);
16672     return node_p;
16673
16674   }
16675
16676
16677
16678   void GenoPro::SocialRelationships::SocialRelationship::Display::sequence::mark_present_Arrow()
16679   {
16680     DOMStringPtr nsUriPtr = new DOMString("libgno");
16681     XsdEvent event(nsUriPtr, NULL, DOMString("Arrow"), XsdEvent::ELEMENT_START, false);
16682     this->processEventThrow(event);
16683   }
16684
16685
16686   //constructor
16687
16688   GenoPro::SocialRelationships::SocialRelationship::Display::Color::Color(ElementCreateArgs args):
16689       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
16690
16691     _fsmAttrs(NULL),
16692     _fsmElems(NULL)
16693   {
16694
16695
16696     initFSM();
16697
16698
16699     if(args.ownerDoc && args.ownerDoc->buildTree())
16700
16701     {
16702       if(args.ownerDoc->createSample()) {
16703         _fsm->fireSampleEvents();
16704       }
16705       else {
16706         _fsm->fireRequiredEvents();
16707       }
16708     }
16709   }
16710
16711   void GenoPro::SocialRelationships::SocialRelationship::Display::Color::initFSM()
16712   {
16713     XsdFsmBasePtr fsmsAttrs[] = {
16714     new XsdFSM<attr_Line_ptr>( Particle(NULL, DOMString("Line"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_Line_ptr, Color, FsmCbOptions>(this, &Color::create_attr_Line)),
16715
16716       NULL
16717     };
16718
16719     _fsm->appendAttributeFsms(fsmsAttrs);
16720     _fsmAttrs = _fsm->attributeFsm();
16721     _fsmElems = _fsm->contentFsm();
16722
16723    }
16724
16725   /* element functions  */
16726
16727
16728   /* attribute  functions  */
16729
16730
16731   GenoPro::SocialRelationships::SocialRelationship::Display::Color::attr_Line_ptr GenoPro::SocialRelationships::SocialRelationship::Display::Color::create_attr_Line(FsmCbOptions& options)
16732   {
16733     static DOMStringPtr myName = new DOMString("Line");
16734     static DOMStringPtr myNsUri = NULL;
16735
16736     if(_attr_Line) {
16737       return _attr_Line;
16738     }
16739     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16740     GenoPro::SocialRelationships::SocialRelationship::Display::Color::attr_Line_p node = XSD::createAttributeTmpl<attr_Line>(t);
16741
16742     if(options.isSampleCreate && (node->stringValue() == "") ) {
16743       node->stringValue(node->sampleValue());
16744     }
16745
16746     _attr_Line = node;
16747
16748     return node;
16749   }
16750
16751
16752     void GenoPro::SocialRelationships::SocialRelationship::Display::Color::set_attr_Line(DOMString val)
16753     {
16754
16755       attribute_attr_Line()->stringValue(val);
16756     }
16757
16758     DOMString GenoPro::SocialRelationships::SocialRelationship::Display::Color::get_attr_Line_string()
16759     {
16760
16761       return attribute_attr_Line()->stringValue();
16762     }
16763
16764
16765   GenoPro::SocialRelationships::SocialRelationship::Display::Color::attr_Line_p GenoPro::SocialRelationships::SocialRelationship::Display::Color::attribute_attr_Line()
16766   {
16767     FSM::warnNullNode(_attr_Line, "attr_Line", "{http://www.w3.org/2001/XMLSchema}Line", 1);
16768     return _attr_Line;
16769   }
16770
16771   //constructor
16772
16773   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::Arrow(ElementCreateArgs args):
16774       XMLSchema::XmlElement<XMLSchema::Types::bt_string>(args),
16775
16776     _fsmAttrs(NULL),
16777     _fsmElems(NULL)
16778   {
16779
16780
16781     initFSM();
16782
16783
16784     if(args.ownerDoc && args.ownerDoc->buildTree())
16785
16786     {
16787       if(args.ownerDoc->createSample()) {
16788         _fsm->fireSampleEvents();
16789       }
16790       else {
16791         _fsm->fireRequiredEvents();
16792       }
16793     }
16794   }
16795
16796   void GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::initFSM()
16797   {
16798     XsdFsmBasePtr fsmsAttrs[] = {
16799     new XsdFSM<attr_End_ptr>( Particle(NULL, DOMString("End"), 1, 1), XsdEvent::ATTRIBUTE, new object_unary_mem_fun_t<attr_End_ptr, Arrow, FsmCbOptions>(this, &Arrow::create_attr_End)),
16800
16801       NULL
16802     };
16803
16804     _fsm->appendAttributeFsms(fsmsAttrs);
16805     _fsmAttrs = _fsm->attributeFsm();
16806     _fsmElems = _fsm->contentFsm();
16807
16808    }
16809
16810   /* element functions  */
16811
16812
16813   /* attribute  functions  */
16814
16815
16816   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::attr_End_ptr GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::create_attr_End(FsmCbOptions& options)
16817   {
16818     static DOMStringPtr myName = new DOMString("End");
16819     static DOMStringPtr myNsUri = NULL;
16820
16821     if(_attr_End) {
16822       return _attr_End;
16823     }
16824     XSD::StructCreateAttrThroughFsm t( myName, myNsUri, NULL, this->ownerElement(), this->ownerDocument(), _fsm, options);
16825     GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::attr_End_p node = XSD::createAttributeTmpl<attr_End>(t);
16826
16827     if(options.isSampleCreate && (node->stringValue() == "") ) {
16828       node->stringValue(node->sampleValue());
16829     }
16830
16831     _attr_End = node;
16832
16833     return node;
16834   }
16835
16836
16837     void GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::set_attr_End(DOMString val)
16838     {
16839
16840       attribute_attr_End()->stringValue(val);
16841     }
16842
16843     DOMString GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::get_attr_End_string()
16844     {
16845
16846       return attribute_attr_End()->stringValue();
16847     }
16848
16849
16850   GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::attr_End_p GenoPro::SocialRelationships::SocialRelationship::Display::Arrow::attribute_attr_End()
16851   {
16852     FSM::warnNullNode(_attr_End, "attr_End", "{http://www.w3.org/2001/XMLSchema}End", 1);
16853     return _attr_End;
16854   }
16855
16856 } // end namespace libgno