NovaDatabase.cpp
Go to the documentation of this file.
1 // Copyright (c) 2005-2014 Code Synthesis Tools CC
2 //
3 // This program was generated by CodeSynthesis XSD, an XML Schema to
4 // C++ data binding compiler.
5 //
6 // This program is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License version 2 as
8 // published by the Free Software Foundation.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 //
19 // In addition, as a special exception, Code Synthesis Tools CC gives
20 // permission to link this program with the Xerces-C++ library (or with
21 // modified versions of Xerces-C++ that use the same license as Xerces-C++),
22 // and distribute linked combinations including the two. You must obey
23 // the GNU General Public License version 2 in all respects for all of
24 // the code used other than Xerces-C++. If you modify this copy of the
25 // program, you may extend this exception to your version of the program,
26 // but you are not obligated to do so. If you do not wish to do so, delete
27 // this exception statement from your version.
28 //
29 // Furthermore, Code Synthesis Tools CC makes a special exception for
30 // the Free/Libre and Open Source Software (FLOSS) which is described
31 // in the accompanying FLOSSE file.
32 //
33 
34 // Begin prologue.
35 //
36 //
37 // End prologue.
38 
39 #include <xsd/cxx/pre.hxx>
40 
41 #include <NovaDatabase/NovaDatabase.h>
42 
43 namespace nova
44 {
45  namespace database
46  {
47  template <class X>
48  struct copyTraits
49  {
50  static void copyNeededFields(X const& source, X& target) {}
51  template <class Y>
52  static void copyNeededFields(X const& source, Y& target) {}
53  };
54 
55  template <>
57  {
58  static void copyNeededFields(Tolerance_t const& source, Tolerance_t& target) {
59  target.copyNeededFields(source);
60  }
61  template <class Y>
62  static void copyNeededFields(Tolerance_t const& source, Y& target) {
63  target->copyNeededFields(source);
64  }
65  };
66 
67  template <>
69  {
70  static void copyNeededFields(dBCheck_t const& source, dBCheck_t& target) {
71  target.copyNeededFields(source);
72  }
73  template <class Y>
74  static void copyNeededFields(dBCheck_t const& source, Y& target) {
75  target->copyNeededFields(source);
76  }
77  };
78 
79  template <>
81  {
82  static void copyNeededFields(dBColumn_t const& source, dBColumn_t& target) {
83  target.copyNeededFields(source);
84  }
85  template <class Y>
86  static void copyNeededFields(dBColumn_t const& source, Y& target) {
87  target->copyNeededFields(source);
88  }
89  };
90 
91  template <>
93  {
94  static void copyNeededFields(dBRow_t const& source, dBRow_t& target) {
95  target.copyNeededFields(source);
96  }
97  template <class Y>
98  static void copyNeededFields(dBRow_t const& source, Y& target) {
99  target->copyNeededFields(source);
100  }
101  };
102 
103  template <>
105  {
106  static void copyNeededFields(dBTable const& source, dBTable& target) {
107  target.copyNeededFields(source);
108  }
109  template <class Y>
110  static void copyNeededFields(dBTable const& source, Y& target) {
111  target->copyNeededFields(source);
112  }
113  };
114 
115  // Tolerance_t
116  //
117 
119  tolValue () const
120  {
121  return this->tolValue_.get ();
122  }
123 
126  {
127  return this->tolValue_.get ();
128  }
129 
131  getTolValue () const
132  {
133  return this->tolValue_.get ();
134  }
135 
136  bool Tolerance_t::
137  hasTolValue () const
138  {
139  return this->tolValue_.present ();
140  }
141 
142  void Tolerance_t::
144  {
145  this->tolValue_.set (x);
146  }
147 
148  void Tolerance_t::
150  {
151  this->tolValue_.set (x);
152  }
153 
155  tolType () const
156  {
157  return this->tolType_.get ();
158  }
159 
162  {
163  return this->tolType_.get ();
164  }
165 
167  getTolType () const
168  {
169  return this->tolType_.get ();
170  }
171 
172  bool Tolerance_t::
173  hasTolType () const
174  {
175  return this->tolType_.present ();
176  }
177 
178  void Tolerance_t::
180  {
181  this->tolType_.set (x);
182  }
183 
184  void Tolerance_t::
186  {
187  this->tolType_.set (x);
188  }
189 
190  void Tolerance_t::
191  tolType (::std::unique_ptr< tolType_type > x)
192  {
193  this->tolType_.set (std::move (x));
194  }
195 
196 
197  // dBColumn_t
198  //
199 
201  tolerance () const
202  {
203  return this->tolerance_;
204  }
205 
208  {
209  return this->tolerance_;
210  }
211 
214  {
215  return this->tolerance_.get ();
216  }
217 
218  bool dBColumn_t::
220  {
221  return this->tolerance_.present ();
222  }
223 
224  void dBColumn_t::
226  {
227  this->tolerance_.set (x);
228  }
229 
230  void dBColumn_t::
232  {
233  this->tolerance_.set (x);
234  }
235 
236  void dBColumn_t::
238  {
239  this->tolerance_ = x;
240  }
241 
242  void dBColumn_t::
243  tolerance (::std::unique_ptr< tolerance_type > x)
244  {
245  this->tolerance_.set (std::move (x));
246  }
247 
249  name () const
250  {
251  return this->name_.get ();
252  }
253 
256  {
257  return this->name_.get ();
258  }
259 
261  getName () const
262  {
263  return this->name_.get ();
264  }
265 
266  bool dBColumn_t::
267  hasName () const
268  {
269  return this->name_.present ();
270  }
271 
272  void dBColumn_t::
273  name (const name_type& x)
274  {
275  this->name_.set (x);
276  }
277 
278  void dBColumn_t::
280  {
281  this->name_.set (x);
282  }
283 
284  void dBColumn_t::
285  name (::std::unique_ptr< name_type > x)
286  {
287  this->name_.set (std::move (x));
288  }
289 
291  colType () const
292  {
293  return this->colType_;
294  }
295 
298  {
299  return this->colType_;
300  }
301 
303  getColType () const
304  {
305  return this->colType_.get ();
306  }
307 
308  bool dBColumn_t::
309  hasColType () const
310  {
311  return this->colType_.present ();
312  }
313 
314  void dBColumn_t::
316  {
317  this->colType_.set (x);
318  }
319 
320  void dBColumn_t::
322  {
323  this->colType_.set (x);
324  }
325 
326  void dBColumn_t::
328  {
329  this->colType_ = x;
330  }
331 
332  void dBColumn_t::
333  colType (::std::unique_ptr< colType_type > x)
334  {
335  this->colType_.set (std::move (x));
336  }
337 
339  value () const
340  {
341  return this->value_;
342  }
343 
346  {
347  return this->value_;
348  }
349 
351  getValue () const
352  {
353  return this->value_.get ();
354  }
355 
356  bool dBColumn_t::
357  hasValue () const
358  {
359  return this->value_.present ();
360  }
361 
362  void dBColumn_t::
364  {
365  this->value_.set (x);
366  }
367 
368  void dBColumn_t::
370  {
371  this->value_.set (x);
372  }
373 
374  void dBColumn_t::
376  {
377  this->value_ = x;
378  }
379 
380  void dBColumn_t::
381  value (::std::unique_ptr< value_type > x)
382  {
383  this->value_.set (std::move (x));
384  }
385 
387  null () const
388  {
389  return this->null_;
390  }
391 
394  {
395  return this->null_;
396  }
397 
399  getNull () const
400  {
401  return this->null_.get ();
402  }
403 
404  bool dBColumn_t::
405  hasNull () const
406  {
407  return this->null_.present ();
408  }
409 
410  void dBColumn_t::
411  null (const null_type& x)
412  {
413  this->null_.set (x);
414  }
415 
416  void dBColumn_t::
418  {
419  this->null_.set (x);
420  }
421 
422  void dBColumn_t::
424  {
425  this->null_ = x;
426  }
427 
429  fKeyTable () const
430  {
431  return this->fKeyTable_;
432  }
433 
436  {
437  return this->fKeyTable_;
438  }
439 
442  {
443  return this->fKeyTable_.get ();
444  }
445 
446  bool dBColumn_t::
448  {
449  return this->fKeyTable_.present ();
450  }
451 
452  void dBColumn_t::
454  {
455  this->fKeyTable_.set (x);
456  }
457 
458  void dBColumn_t::
460  {
461  this->fKeyTable_.set (x);
462  }
463 
464  void dBColumn_t::
466  {
467  this->fKeyTable_ = x;
468  }
469 
470  void dBColumn_t::
471  fKeyTable (::std::unique_ptr< fKeyTable_type > x)
472  {
473  this->fKeyTable_.set (std::move (x));
474  }
475 
477  fKeyColumn () const
478  {
479  return this->fKeyColumn_;
480  }
481 
484  {
485  return this->fKeyColumn_;
486  }
487 
490  {
491  return this->fKeyColumn_.get ();
492  }
493 
494  bool dBColumn_t::
496  {
497  return this->fKeyColumn_.present ();
498  }
499 
500  void dBColumn_t::
502  {
503  this->fKeyColumn_.set (x);
504  }
505 
506  void dBColumn_t::
508  {
509  this->fKeyColumn_.set (x);
510  }
511 
512  void dBColumn_t::
514  {
515  this->fKeyColumn_ = x;
516  }
517 
518  void dBColumn_t::
519  fKeyColumn (::std::unique_ptr< fKeyColumn_type > x)
520  {
521  this->fKeyColumn_.set (std::move (x));
522  }
523 
524 
525  // dBCheck_t
526  //
527 
529  constraint () const
530  {
531  return this->constraint_.get ();
532  }
533 
536  {
537  return this->constraint_.get ();
538  }
539 
542  {
543  return this->constraint_.get ();
544  }
545 
546  bool dBCheck_t::
548  {
549  return this->constraint_.present ();
550  }
551 
552  void dBCheck_t::
554  {
555  this->constraint_.set (x);
556  }
557 
558  void dBCheck_t::
560  {
561  this->constraint_.set (x);
562  }
563 
564  void dBCheck_t::
565  constraint (::std::unique_ptr< constraint_type > x)
566  {
567  this->constraint_.set (std::move (x));
568  }
569 
570 
571  // dBRow_t
572  //
573 
575  dBCol () const
576  {
577  return this->dBCol_;
578  }
579 
582  {
583  return this->dBCol_;
584  }
585 
588  {
589  return this->dBCol_.size ();
590  }
591 
593  getDBCol (int index) const
594  {
595  return this->dBCol_[index];
596  }
597 
600  {
601  return this->dBCol_[index];
602  }
603 
604  bool dBRow_t::
605  hasDBCol () const
606  {
607  return ! (this->dBCol_.empty ());
608  }
609 
610  void dBRow_t::
612  {
613  this->dBCol_.clear ();
614  }
615 
616  void dBRow_t::
618  {
619  this->dBCol_ = s;
620  }
621 
622  void dBRow_t::
624  {
625  this->dBCol_.push_back (newDBCol);
626  }
627 
628 
629  // dBTable
630  //
631 
633  dBColumn () const
634  {
635  return this->dBColumn_;
636  }
637 
640  {
641  return this->dBColumn_;
642  }
643 
646  {
647  return this->dBColumn_.size ();
648  }
649 
651  getDBColumn (int index) const
652  {
653  return this->dBColumn_[index];
654  }
655 
658  {
659  return this->dBColumn_[index];
660  }
661 
662  bool dBTable::
663  hasDBColumn () const
664  {
665  return ! (this->dBColumn_.empty ());
666  }
667 
668  void dBTable::
670  {
671  this->dBColumn_.clear ();
672  }
673 
674  void dBTable::
676  {
677  this->dBColumn_ = s;
678  }
679 
680  void dBTable::
682  {
683  this->dBColumn_.push_back (newDBColumn);
684  }
685 
687  dBPKey () const
688  {
689  return this->dBPKey_;
690  }
691 
694  {
695  return this->dBPKey_;
696  }
697 
699  getDBPKey () const
700  {
701  return this->dBPKey_.get ();
702  }
703 
704  bool dBTable::
705  hasDBPKey () const
706  {
707  return this->dBPKey_.present ();
708  }
709 
710  void dBTable::
712  {
713  this->dBPKey_.set (x);
714  }
715 
716  void dBTable::
718  {
719  this->dBPKey_.set (x);
720  }
721 
722  void dBTable::
724  {
725  this->dBPKey_ = x;
726  }
727 
728  void dBTable::
729  dBPKey (::std::unique_ptr< dBPKey_type > x)
730  {
731  this->dBPKey_.set (std::move (x));
732  }
733 
735  dBUnique () const
736  {
737  return this->dBUnique_;
738  }
739 
742  {
743  return this->dBUnique_;
744  }
745 
748  {
749  return this->dBUnique_.size ();
750  }
751 
753  getDBUnique (int index) const
754  {
755  return this->dBUnique_[index];
756  }
757 
760  {
761  return this->dBUnique_[index];
762  }
763 
764  bool dBTable::
765  hasDBUnique () const
766  {
767  return ! (this->dBUnique_.empty ());
768  }
769 
770  void dBTable::
772  {
773  this->dBUnique_.clear ();
774  }
775 
776  void dBTable::
778  {
779  this->dBUnique_ = s;
780  }
781 
782  void dBTable::
784  {
785  this->dBUnique_.push_back (newDBUnique);
786  }
787 
789  dBCheck () const
790  {
791  return this->dBCheck_;
792  }
793 
796  {
797  return this->dBCheck_;
798  }
799 
802  {
803  return this->dBCheck_.size ();
804  }
805 
807  getDBCheck (int index) const
808  {
809  return this->dBCheck_[index];
810  }
811 
814  {
815  return this->dBCheck_[index];
816  }
817 
818  bool dBTable::
819  hasDBCheck () const
820  {
821  return ! (this->dBCheck_.empty ());
822  }
823 
824  void dBTable::
826  {
827  this->dBCheck_.clear ();
828  }
829 
830  void dBTable::
832  {
833  this->dBCheck_ = s;
834  }
835 
836  void dBTable::
838  {
839  this->dBCheck_.push_back (newDBCheck);
840  }
841 
843  dBRow () const
844  {
845  return this->dBRow_;
846  }
847 
850  {
851  return this->dBRow_;
852  }
853 
856  {
857  return this->dBRow_.size ();
858  }
859 
861  getDBRow (int index) const
862  {
863  return this->dBRow_[index];
864  }
865 
868  {
869  return this->dBRow_[index];
870  }
871 
872  bool dBTable::
873  hasDBRow () const
874  {
875  return ! (this->dBRow_.empty ());
876  }
877 
878  void dBTable::
880  {
881  this->dBRow_.clear ();
882  }
883 
884  void dBTable::
886  {
887  this->dBRow_ = s;
888  }
889 
890  void dBTable::
892  {
893  this->dBRow_.push_back (newDBRow);
894  }
895 
897  tableName () const
898  {
899  return this->tableName_.get ();
900  }
901 
904  {
905  return this->tableName_.get ();
906  }
907 
910  {
911  return this->tableName_.get ();
912  }
913 
914  bool dBTable::
916  {
917  return this->tableName_.present ();
918  }
919 
920  void dBTable::
922  {
923  this->tableName_.set (x);
924  }
925 
926  void dBTable::
928  {
929  this->tableName_.set (x);
930  }
931 
932  void dBTable::
933  tableName (::std::unique_ptr< tableName_type > x)
934  {
935  this->tableName_.set (std::move (x));
936  }
937 
939  dbHost () const
940  {
941  return this->dbHost_.get ();
942  }
943 
946  {
947  return this->dbHost_.get ();
948  }
949 
951  getDbHost () const
952  {
953  return this->dbHost_.get ();
954  }
955 
956  bool dBTable::
957  hasDbHost () const
958  {
959  return this->dbHost_.present ();
960  }
961 
962  void dBTable::
964  {
965  this->dbHost_.set (x);
966  }
967 
968  void dBTable::
970  {
971  this->dbHost_.set (x);
972  }
973 
974  void dBTable::
975  dbHost (::std::unique_ptr< dbHost_type > x)
976  {
977  this->dbHost_.set (std::move (x));
978  }
979 
981  dbName () const
982  {
983  return this->dbName_.get ();
984  }
985 
988  {
989  return this->dbName_.get ();
990  }
991 
993  getDbName () const
994  {
995  return this->dbName_.get ();
996  }
997 
998  bool dBTable::
999  hasDbName () const
1000  {
1001  return this->dbName_.present ();
1002  }
1003 
1004  void dBTable::
1006  {
1007  this->dbName_.set (x);
1008  }
1009 
1010  void dBTable::
1012  {
1013  this->dbName_.set (x);
1014  }
1015 
1016  void dBTable::
1017  dbName (::std::unique_ptr< dbName_type > x)
1018  {
1019  this->dbName_.set (std::move (x));
1020  }
1021 
1023  dbType () const
1024  {
1025  return this->dbType_;
1026  }
1027 
1030  {
1031  return this->dbType_;
1032  }
1033 
1035  getDbType () const
1036  {
1037  return this->dbType_.get ();
1038  }
1039 
1040  bool dBTable::
1041  hasDbType () const
1042  {
1043  return this->dbType_.present ();
1044  }
1045 
1046  void dBTable::
1048  {
1049  this->dbType_.set (x);
1050  }
1051 
1052  void dBTable::
1054  {
1055  this->dbType_.set (x);
1056  }
1057 
1058  void dBTable::
1060  {
1061  this->dbType_ = x;
1062  }
1063 
1064  void dBTable::
1065  dbType (::std::unique_ptr< dbType_type > x)
1066  {
1067  this->dbType_.set (std::move (x));
1068  }
1069 
1071  dbPort () const
1072  {
1073  return this->dbPort_;
1074  }
1075 
1078  {
1079  return this->dbPort_;
1080  }
1081 
1083  getDbPort () const
1084  {
1085  return this->dbPort_.get ();
1086  }
1087 
1088  bool dBTable::
1089  hasDbPort () const
1090  {
1091  return this->dbPort_.present ();
1092  }
1093 
1094  void dBTable::
1096  {
1097  this->dbPort_.set (x);
1098  }
1099 
1100  void dBTable::
1102  {
1103  this->dbPort_.set (x);
1104  }
1105 
1106  void dBTable::
1108  {
1109  this->dbPort_ = x;
1110  }
1111 
1112  void dBTable::
1113  dbPort (::std::unique_ptr< dbPort_type > x)
1114  {
1115  this->dbPort_.set (std::move (x));
1116  }
1117 
1119  tableType () const
1120  {
1121  return this->tableType_;
1122  }
1123 
1126  {
1127  return this->tableType_;
1128  }
1129 
1132  {
1133  return this->tableType_.get ();
1134  }
1135 
1136  bool dBTable::
1138  {
1139  return this->tableType_.present ();
1140  }
1141 
1142  void dBTable::
1144  {
1145  this->tableType_.set (x);
1146  }
1147 
1148  void dBTable::
1150  {
1151  this->tableType_.set (x);
1152  }
1153 
1154  void dBTable::
1156  {
1157  this->tableType_ = x;
1158  }
1159 
1160  void dBTable::
1161  tableType (::std::unique_ptr< tableType_type > x)
1162  {
1163  this->tableType_.set (std::move (x));
1164  }
1165 
1168  {
1169  return this->creationDate_;
1170  }
1171 
1174  {
1175  return this->creationDate_;
1176  }
1177 
1180  {
1181  return this->creationDate_.get ();
1182  }
1183 
1184  bool dBTable::
1186  {
1187  return this->creationDate_.present ();
1188  }
1189 
1190  void dBTable::
1192  {
1193  this->creationDate_.set (x);
1194  }
1195 
1196  void dBTable::
1198  {
1199  this->creationDate_.set (x);
1200  }
1201 
1202  void dBTable::
1204  {
1205  this->creationDate_ = x;
1206  }
1207 
1208  void dBTable::
1209  creationDate (::std::unique_ptr< creationDate_type > x)
1210  {
1211  this->creationDate_.set (std::move (x));
1212  }
1213 
1215  maintainer () const
1216  {
1217  return this->maintainer_;
1218  }
1219 
1222  {
1223  return this->maintainer_;
1224  }
1225 
1228  {
1229  return this->maintainer_.get ();
1230  }
1231 
1232  bool dBTable::
1234  {
1235  return this->maintainer_.present ();
1236  }
1237 
1238  void dBTable::
1240  {
1241  this->maintainer_.set (x);
1242  }
1243 
1244  void dBTable::
1246  {
1247  this->maintainer_.set (x);
1248  }
1249 
1250  void dBTable::
1252  {
1253  this->maintainer_ = x;
1254  }
1255 
1256  void dBTable::
1257  maintainer (::std::unique_ptr< maintainer_type > x)
1258  {
1259  this->maintainer_.set (std::move (x));
1260  }
1261 
1263  xmlOverDB () const
1264  {
1265  return this->xmlOverDB_;
1266  }
1267 
1270  {
1271  return this->xmlOverDB_;
1272  }
1273 
1276  {
1277  return this->xmlOverDB_.get ();
1278  }
1279 
1280  bool dBTable::
1282  {
1283  return this->xmlOverDB_.present ();
1284  }
1285 
1286  void dBTable::
1288  {
1289  this->xmlOverDB_.set (x);
1290  }
1291 
1292  void dBTable::
1294  {
1295  this->xmlOverDB_.set (x);
1296  }
1297 
1298  void dBTable::
1300  {
1301  this->xmlOverDB_ = x;
1302  }
1303 
1305  ignoreDB () const
1306  {
1307  return this->ignoreDB_;
1308  }
1309 
1312  {
1313  return this->ignoreDB_;
1314  }
1315 
1318  {
1319  return this->ignoreDB_.get ();
1320  }
1321 
1322  bool dBTable::
1324  {
1325  return this->ignoreDB_.present ();
1326  }
1327 
1328  void dBTable::
1330  {
1331  this->ignoreDB_.set (x);
1332  }
1333 
1334  void dBTable::
1336  {
1337  this->ignoreDB_.set (x);
1338  }
1339 
1340  void dBTable::
1342  {
1343  this->ignoreDB_ = x;
1344  }
1345 
1348  {
1349  return this->addInsertTime_;
1350  }
1351 
1354  {
1355  return this->addInsertTime_;
1356  }
1357 
1360  {
1361  return this->addInsertTime_.get ();
1362  }
1363 
1364  bool dBTable::
1366  {
1367  return this->addInsertTime_.present ();
1368  }
1369 
1370  void dBTable::
1372  {
1373  this->addInsertTime_.set (x);
1374  }
1375 
1376  void dBTable::
1378  {
1379  this->addInsertTime_.set (x);
1380  }
1381 
1382  void dBTable::
1384  {
1385  this->addInsertTime_ = x;
1386  }
1387 
1390  {
1391  return this->addInsertUser_;
1392  }
1393 
1396  {
1397  return this->addInsertUser_;
1398  }
1399 
1402  {
1403  return this->addInsertUser_.get ();
1404  }
1405 
1406  bool dBTable::
1408  {
1409  return this->addInsertUser_.present ();
1410  }
1411 
1412  void dBTable::
1414  {
1415  this->addInsertUser_.set (x);
1416  }
1417 
1418  void dBTable::
1420  {
1421  this->addInsertUser_.set (x);
1422  }
1423 
1424  void dBTable::
1426  {
1427  this->addInsertUser_ = x;
1428  }
1429 
1432  {
1433  return this->addUpdateTime_;
1434  }
1435 
1438  {
1439  return this->addUpdateTime_;
1440  }
1441 
1444  {
1445  return this->addUpdateTime_.get ();
1446  }
1447 
1448  bool dBTable::
1450  {
1451  return this->addUpdateTime_.present ();
1452  }
1453 
1454  void dBTable::
1456  {
1457  this->addUpdateTime_.set (x);
1458  }
1459 
1460  void dBTable::
1462  {
1463  this->addUpdateTime_.set (x);
1464  }
1465 
1466  void dBTable::
1468  {
1469  this->addUpdateTime_ = x;
1470  }
1471 
1474  {
1475  return this->addUpdateUser_;
1476  }
1477 
1480  {
1481  return this->addUpdateUser_;
1482  }
1483 
1486  {
1487  return this->addUpdateUser_.get ();
1488  }
1489 
1490  bool dBTable::
1492  {
1493  return this->addUpdateUser_.present ();
1494  }
1495 
1496  void dBTable::
1498  {
1499  this->addUpdateUser_.set (x);
1500  }
1501 
1502  void dBTable::
1504  {
1505  this->addUpdateUser_.set (x);
1506  }
1507 
1508  void dBTable::
1510  {
1511  this->addUpdateUser_ = x;
1512  }
1513 
1515  schema () const
1516  {
1517  return this->schema_;
1518  }
1519 
1522  {
1523  return this->schema_;
1524  }
1525 
1527  getSchema () const
1528  {
1529  return this->schema_.get ();
1530  }
1531 
1532  bool dBTable::
1533  hasSchema () const
1534  {
1535  return this->schema_.present ();
1536  }
1537 
1538  void dBTable::
1540  {
1541  this->schema_.set (x);
1542  }
1543 
1544  void dBTable::
1546  {
1547  this->schema_.set (x);
1548  }
1549 
1550  void dBTable::
1552  {
1553  this->schema_ = x;
1554  }
1555 
1556  void dBTable::
1557  schema (::std::unique_ptr< schema_type > x)
1558  {
1559  this->schema_.set (std::move (x));
1560  }
1561  }
1562 }
1563 
1564 #include <xsd/cxx/xml/dom/parsing-source.hxx>
1565 #include <xsd/cxx/xml/sax/std-input-source.hxx>
1566 #include <xsd/cxx/tree/error-handler.hxx>
1567 
1568 namespace nova
1569 {
1570  namespace database
1571  {
1572  // Tolerance_t
1573  //
1574 
1577  : ::xml_schema::type (),
1578  tolValue_ (this),
1579  tolType_ (this)
1580  {
1581  }
1582 
1585  const tolType_type& tolType)
1586  : ::xml_schema::type (),
1587  tolValue_ (tolValue, this),
1588  tolType_ (tolType, this)
1589  {
1590  }
1591 
1594  ::xml_schema::flags f,
1596  : ::xml_schema::type (x, f, c),
1597  tolValue_ (x.tolValue_, f, this),
1598  tolType_ (x.tolType_, f, this)
1599  {
1600  }
1601 
1603  Tolerance_t (const ::xercesc::DOMElement& e,
1604  ::xml_schema::flags f,
1606  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1607  tolValue_ (this),
1608  tolType_ (this)
1609  {
1610  if ((f & ::xml_schema::flags::base) == 0)
1611  {
1612  ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true);
1613  this->parse (p, f);
1614  }
1615  }
1616 
1617  void Tolerance_t::
1618  parse (::xsd::cxx::xml::dom::parser< char >& p,
1619  ::xml_schema::flags f)
1620  {
1621  while (p.more_attributes ())
1622  {
1623  const ::xercesc::DOMAttr& i (p.next_attribute ());
1624  const ::xsd::cxx::xml::qualified_name< char > n (
1625  ::xsd::cxx::xml::dom::name< char > (i));
1626 
1627  if (n.name () == "tolValue" && n.namespace_ ().empty ())
1628  {
1629  this->tolValue_.set (tolValue_traits::create (i, f, this));
1630  continue;
1631  }
1632 
1633  if (n.name () == "tolType" && n.namespace_ ().empty ())
1634  {
1635  this->tolType_.set (tolType_traits::create (i, f, this));
1636  continue;
1637  }
1638  }
1639 
1640  if (!tolValue_.present ())
1641  {
1643  {
1644  std::cerr << "ERROR: expected attribute (Tolerance_t::tolValue) not found!" << std::endl;
1645  throw ::xsd::cxx::tree::expected_attribute< char > (
1646  "tolValue",
1647  "");
1648  }
1649  }
1650 
1651  if (!tolType_.present ())
1652  {
1654  {
1655  std::cerr << "ERROR: expected attribute (Tolerance_t::tolType) not found!" << std::endl;
1656  throw ::xsd::cxx::tree::expected_attribute< char > (
1657  "tolType",
1658  "");
1659  }
1660  }
1661  }
1662 
1665  ::xml_schema::container* c) const
1666  {
1667  return new class Tolerance_t (*this, f, c);
1668  }
1669 
1672  {
1673  if (this != &x)
1674  {
1675  static_cast< ::xml_schema::type& > (*this) = x;
1676  this->tolValue_ = x.tolValue_;
1677  this->tolType_ = x.tolType_;
1678  }
1679 
1680  return *this;
1681  }
1682 
1685  {
1686  }
1687 
1688  void Tolerance_t::
1690  {
1691  if (x.hasTolType()) {
1692  if (! this->hasTolType()) {
1693  this->setTolType(x.getTolType());
1694  }
1695  else {
1697  }
1698  }
1699  if (x.hasTolValue()) {
1700  if (! this->hasTolValue()) {
1701  this->setTolValue(x.getTolValue());
1702  }
1703  else {
1705  }
1706  }
1707  }
1708 
1709  // dBColumn_t
1710  //
1711 
1712  dBColumn_t::
1714  : ::xml_schema::type (),
1715  tolerance_ (this),
1716  name_ (this),
1717  colType_ (this),
1718  value_ (this),
1719  null_ (this),
1720  fKeyTable_ (this),
1721  fKeyColumn_ (this)
1722  {
1723  }
1724 
1725  dBColumn_t::
1727  : ::xml_schema::type (),
1728  tolerance_ (this),
1729  name_ (name, this),
1730  colType_ (this),
1731  value_ (this),
1732  null_ (this),
1733  fKeyTable_ (this),
1734  fKeyColumn_ (this)
1735  {
1736  }
1737 
1738  dBColumn_t::
1740  ::xml_schema::flags f,
1742  : ::xml_schema::type (x, f, c),
1743  tolerance_ (x.tolerance_, f, this),
1744  name_ (x.name_, f, this),
1745  colType_ (x.colType_, f, this),
1746  value_ (x.value_, f, this),
1747  null_ (x.null_, f, this),
1748  fKeyTable_ (x.fKeyTable_, f, this),
1749  fKeyColumn_ (x.fKeyColumn_, f, this)
1750  {
1751  }
1752 
1753  dBColumn_t::
1754  dBColumn_t (const ::xercesc::DOMElement& e,
1755  ::xml_schema::flags f,
1757  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1758  tolerance_ (this),
1759  name_ (this),
1760  colType_ (this),
1761  value_ (this),
1762  null_ (this),
1763  fKeyTable_ (this),
1764  fKeyColumn_ (this)
1765  {
1766  if ((f & ::xml_schema::flags::base) == 0)
1767  {
1768  ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
1769  this->parse (p, f);
1770  }
1771  }
1772 
1773  void dBColumn_t::
1774  parse (::xsd::cxx::xml::dom::parser< char >& p,
1775  ::xml_schema::flags f)
1776  {
1777  for (; p.more_content (); p.next_content (false))
1778  {
1779  const ::xercesc::DOMElement& i (p.cur_element ());
1780  const ::xsd::cxx::xml::qualified_name< char > n (
1781  ::xsd::cxx::xml::dom::name< char > (i));
1782 
1783  // tolerance
1784  //
1785  if (n.name () == "tolerance" && n.namespace_ ().empty ())
1786  {
1787  ::std::unique_ptr< tolerance_type > r (
1788  tolerance_traits::create (i, f, this));
1789 
1790  if (!this->tolerance_)
1791  {
1792  this->tolerance_.set (::std::move (r));
1793  continue;
1794  }
1795  }
1796 
1797  break;
1798  }
1799 
1800  while (p.more_attributes ())
1801  {
1802  const ::xercesc::DOMAttr& i (p.next_attribute ());
1803  const ::xsd::cxx::xml::qualified_name< char > n (
1804  ::xsd::cxx::xml::dom::name< char > (i));
1805 
1806  if (n.name () == "name" && n.namespace_ ().empty ())
1807  {
1808  this->name_.set (name_traits::create (i, f, this));
1809  continue;
1810  }
1811 
1812  if (n.name () == "colType" && n.namespace_ ().empty ())
1813  {
1814  this->colType_.set (colType_traits::create (i, f, this));
1815  continue;
1816  }
1817 
1818  if (n.name () == "value" && n.namespace_ ().empty ())
1819  {
1820  this->value_.set (value_traits::create (i, f, this));
1821  continue;
1822  }
1823 
1824  if (n.name () == "null" && n.namespace_ ().empty ())
1825  {
1826  this->null_.set (null_traits::create (i, f, this));
1827  continue;
1828  }
1829 
1830  if (n.name () == "fKeyTable" && n.namespace_ ().empty ())
1831  {
1832  this->fKeyTable_.set (fKeyTable_traits::create (i, f, this));
1833  continue;
1834  }
1835 
1836  if (n.name () == "fKeyColumn" && n.namespace_ ().empty ())
1837  {
1838  this->fKeyColumn_.set (fKeyColumn_traits::create (i, f, this));
1839  continue;
1840  }
1841  }
1842 
1843  if (!name_.present ())
1844  {
1846  {
1847  std::cerr << "ERROR: expected attribute (dBColumn_t::name) not found!" << std::endl;
1848  throw ::xsd::cxx::tree::expected_attribute< char > (
1849  "name",
1850  "");
1851  }
1852  }
1853  }
1854 
1857  ::xml_schema::container* c) const
1858  {
1859  return new class dBColumn_t (*this, f, c);
1860  }
1861 
1864  {
1865  if (this != &x)
1866  {
1867  static_cast< ::xml_schema::type& > (*this) = x;
1868  this->tolerance_ = x.tolerance_;
1869  this->name_ = x.name_;
1870  this->colType_ = x.colType_;
1871  this->value_ = x.value_;
1872  this->null_ = x.null_;
1873  this->fKeyTable_ = x.fKeyTable_;
1874  this->fKeyColumn_ = x.fKeyColumn_;
1875  }
1876 
1877  return *this;
1878  }
1879 
1880  dBColumn_t::
1882  {
1883  }
1884 
1885  void dBColumn_t::
1887  {
1888  if (x.hasName()) {
1889  if (! this->hasName()) {
1890  this->setName(x.getName());
1891  }
1892  else {
1894  }
1895  }
1896  if (x.hasTolerance()) {
1897  if (! this->hasTolerance()) {
1898  this->setTolerance(x.getTolerance());
1899  }
1900  else {
1902  }
1903  }
1904  }
1905 
1906  // dBCheck_t
1907  //
1908 
1909  dBCheck_t::
1911  : ::xml_schema::type (),
1912  constraint_ (this)
1913  {
1914  }
1915 
1916  dBCheck_t::
1918  : ::xml_schema::type (),
1919  constraint_ (constraint, this)
1920  {
1921  }
1922 
1923  dBCheck_t::
1925  ::xml_schema::flags f,
1927  : ::xml_schema::type (x, f, c),
1928  constraint_ (x.constraint_, f, this)
1929  {
1930  }
1931 
1932  dBCheck_t::
1933  dBCheck_t (const ::xercesc::DOMElement& e,
1934  ::xml_schema::flags f,
1936  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
1937  constraint_ (this)
1938  {
1939  if ((f & ::xml_schema::flags::base) == 0)
1940  {
1941  ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true);
1942  this->parse (p, f);
1943  }
1944  }
1945 
1946  void dBCheck_t::
1947  parse (::xsd::cxx::xml::dom::parser< char >& p,
1948  ::xml_schema::flags f)
1949  {
1950  while (p.more_attributes ())
1951  {
1952  const ::xercesc::DOMAttr& i (p.next_attribute ());
1953  const ::xsd::cxx::xml::qualified_name< char > n (
1954  ::xsd::cxx::xml::dom::name< char > (i));
1955 
1956  if (n.name () == "constraint" && n.namespace_ ().empty ())
1957  {
1958  this->constraint_.set (constraint_traits::create (i, f, this));
1959  continue;
1960  }
1961  }
1962 
1963  if (!constraint_.present ())
1964  {
1966  {
1967  std::cerr << "ERROR: expected attribute (dBCheck_t::constraint) not found!" << std::endl;
1968  throw ::xsd::cxx::tree::expected_attribute< char > (
1969  "constraint",
1970  "");
1971  }
1972  }
1973  }
1974 
1977  ::xml_schema::container* c) const
1978  {
1979  return new class dBCheck_t (*this, f, c);
1980  }
1981 
1984  {
1985  if (this != &x)
1986  {
1987  static_cast< ::xml_schema::type& > (*this) = x;
1988  this->constraint_ = x.constraint_;
1989  }
1990 
1991  return *this;
1992  }
1993 
1994  dBCheck_t::
1996  {
1997  }
1998 
1999  void dBCheck_t::
2001  {
2002  if (x.hasConstraint()) {
2003  if (! this->hasConstraint()) {
2004  this->setConstraint(x.getConstraint());
2005  }
2006  else {
2008  }
2009  }
2010  }
2011 
2012  // dBRow_t
2013  //
2014 
2015  dBRow_t::
2017  : ::xml_schema::type (),
2018  dBCol_ (this)
2019  {
2020  }
2021 
2022  dBRow_t::
2024  ::xml_schema::flags f,
2026  : ::xml_schema::type (x, f, c),
2027  dBCol_ (x.dBCol_, f, this)
2028  {
2029  }
2030 
2031  dBRow_t::
2032  dBRow_t (const ::xercesc::DOMElement& e,
2033  ::xml_schema::flags f,
2035  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2036  dBCol_ (this)
2037  {
2038  if ((f & ::xml_schema::flags::base) == 0)
2039  {
2040  ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
2041  this->parse (p, f);
2042  }
2043  }
2044 
2045  void dBRow_t::
2046  parse (::xsd::cxx::xml::dom::parser< char >& p,
2047  ::xml_schema::flags f)
2048  {
2049  for (; p.more_content (); p.next_content (false))
2050  {
2051  const ::xercesc::DOMElement& i (p.cur_element ());
2052  const ::xsd::cxx::xml::qualified_name< char > n (
2053  ::xsd::cxx::xml::dom::name< char > (i));
2054 
2055  // dBCol
2056  //
2057  if (n.name () == "dBCol" && n.namespace_ ().empty ())
2058  {
2059  ::std::unique_ptr< dBCol_type > r (
2060  dBCol_traits::create (i, f, this));
2061 
2062  this->dBCol_.push_back (::std::move (r));
2063  continue;
2064  }
2065 
2066  break;
2067  }
2068  }
2069 
2072  ::xml_schema::container* c) const
2073  {
2074  return new class dBRow_t (*this, f, c);
2075  }
2076 
2079  {
2080  if (this != &x)
2081  {
2082  static_cast< ::xml_schema::type& > (*this) = x;
2083  this->dBCol_ = x.dBCol_;
2084  }
2085 
2086  return *this;
2087  }
2088 
2089  dBRow_t::
2091  {
2092  }
2093 
2094  void dBRow_t::
2096  {
2097  if (x.hasDBCol() && x.getDBColCount() > 0) {
2098  if (! this->hasDBCol() || this->getDBColCount() == 0) {
2099  for (::xml_schema::integer idx = 0; idx < x.getDBColCount(); ++idx) {
2100  this->addDBCol(x.getDBCol(idx));
2101  }
2102  }
2103  //else {
2104  // copyTraits<dBCol_type>::copyNeededFields(x.getDBCol(), this->dBCol());
2105  //}
2106  }
2107  }
2108 
2109  // dBTable
2110  //
2111 
2112  dBTable::
2114  : ::xml_schema::type (),
2115  dBColumn_ (this),
2116  dBPKey_ (this),
2117  dBUnique_ (this),
2118  dBCheck_ (this),
2119  dBRow_ (this),
2120  tableName_ (this),
2121  dbHost_ (this),
2122  dbName_ (this),
2123  dbType_ (this),
2124  dbPort_ (this),
2125  tableType_ (this),
2126  creationDate_ (this),
2127  maintainer_ (this),
2128  xmlOverDB_ (this),
2129  ignoreDB_ (this),
2130  addInsertTime_ (this),
2131  addInsertUser_ (this),
2132  addUpdateTime_ (this),
2133  addUpdateUser_ (this),
2134  schema_ (this)
2135  {
2136  }
2137 
2138  dBTable::
2140  const dbHost_type& dbHost,
2141  const dbName_type& dbName)
2142  : ::xml_schema::type (),
2143  dBColumn_ (this),
2144  dBPKey_ (this),
2145  dBUnique_ (this),
2146  dBCheck_ (this),
2147  dBRow_ (this),
2148  tableName_ (tableName, this),
2149  dbHost_ (dbHost, this),
2150  dbName_ (dbName, this),
2151  dbType_ (this),
2152  dbPort_ (this),
2153  tableType_ (this),
2154  creationDate_ (this),
2155  maintainer_ (this),
2156  xmlOverDB_ (this),
2157  ignoreDB_ (this),
2158  addInsertTime_ (this),
2159  addInsertUser_ (this),
2160  addUpdateTime_ (this),
2161  addUpdateUser_ (this),
2162  schema_ (this)
2163  {
2164  }
2165 
2166  dBTable::
2168  ::xml_schema::flags f,
2170  : ::xml_schema::type (x, f, c),
2171  dBColumn_ (x.dBColumn_, f, this),
2172  dBPKey_ (x.dBPKey_, f, this),
2173  dBUnique_ (x.dBUnique_, f, this),
2174  dBCheck_ (x.dBCheck_, f, this),
2175  dBRow_ (x.dBRow_, f, this),
2176  tableName_ (x.tableName_, f, this),
2177  dbHost_ (x.dbHost_, f, this),
2178  dbName_ (x.dbName_, f, this),
2179  dbType_ (x.dbType_, f, this),
2180  dbPort_ (x.dbPort_, f, this),
2181  tableType_ (x.tableType_, f, this),
2182  creationDate_ (x.creationDate_, f, this),
2183  maintainer_ (x.maintainer_, f, this),
2184  xmlOverDB_ (x.xmlOverDB_, f, this),
2185  ignoreDB_ (x.ignoreDB_, f, this),
2186  addInsertTime_ (x.addInsertTime_, f, this),
2187  addInsertUser_ (x.addInsertUser_, f, this),
2188  addUpdateTime_ (x.addUpdateTime_, f, this),
2189  addUpdateUser_ (x.addUpdateUser_, f, this),
2190  schema_ (x.schema_, f, this)
2191  {
2192  }
2193 
2194  dBTable::
2195  dBTable (const ::xercesc::DOMElement& e,
2196  ::xml_schema::flags f,
2198  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
2199  dBColumn_ (this),
2200  dBPKey_ (this),
2201  dBUnique_ (this),
2202  dBCheck_ (this),
2203  dBRow_ (this),
2204  tableName_ (this),
2205  dbHost_ (this),
2206  dbName_ (this),
2207  dbType_ (this),
2208  dbPort_ (this),
2209  tableType_ (this),
2210  creationDate_ (this),
2211  maintainer_ (this),
2212  xmlOverDB_ (this),
2213  ignoreDB_ (this),
2214  addInsertTime_ (this),
2215  addInsertUser_ (this),
2216  addUpdateTime_ (this),
2217  addUpdateUser_ (this),
2218  schema_ (this)
2219  {
2220  if ((f & ::xml_schema::flags::base) == 0)
2221  {
2222  ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
2223  this->parse (p, f);
2224  }
2225  }
2226 
2227  void dBTable::
2228  parse (::xsd::cxx::xml::dom::parser< char >& p,
2229  ::xml_schema::flags f)
2230  {
2231  for (; p.more_content (); p.next_content (false))
2232  {
2233  const ::xercesc::DOMElement& i (p.cur_element ());
2234  const ::xsd::cxx::xml::qualified_name< char > n (
2235  ::xsd::cxx::xml::dom::name< char > (i));
2236 
2237  // dBColumn
2238  //
2239  if (n.name () == "dBColumn" && n.namespace_ ().empty ())
2240  {
2241  ::std::unique_ptr< dBColumn_type > r (
2242  dBColumn_traits::create (i, f, this));
2243 
2244  this->dBColumn_.push_back (::std::move (r));
2245  continue;
2246  }
2247 
2248  // dBPKey
2249  //
2250  if (n.name () == "dBPKey" && n.namespace_ ().empty ())
2251  {
2252  ::std::unique_ptr< dBPKey_type > r (
2253  dBPKey_traits::create (i, f, this));
2254 
2255  if (!this->dBPKey_)
2256  {
2257  this->dBPKey_.set (::std::move (r));
2258  continue;
2259  }
2260  }
2261 
2262  // dBUnique
2263  //
2264  if (n.name () == "dBUnique" && n.namespace_ ().empty ())
2265  {
2266  ::std::unique_ptr< dBUnique_type > r (
2267  dBUnique_traits::create (i, f, this));
2268 
2269  this->dBUnique_.push_back (::std::move (r));
2270  continue;
2271  }
2272 
2273  // dBCheck
2274  //
2275  if (n.name () == "dBCheck" && n.namespace_ ().empty ())
2276  {
2277  ::std::unique_ptr< dBCheck_type > r (
2278  dBCheck_traits::create (i, f, this));
2279 
2280  this->dBCheck_.push_back (::std::move (r));
2281  continue;
2282  }
2283 
2284  // dBRow
2285  //
2286  if (n.name () == "dBRow" && n.namespace_ ().empty ())
2287  {
2288  ::std::unique_ptr< dBRow_type > r (
2289  dBRow_traits::create (i, f, this));
2290 
2291  this->dBRow_.push_back (::std::move (r));
2292  continue;
2293  }
2294 
2295  break;
2296  }
2297 
2298  while (p.more_attributes ())
2299  {
2300  const ::xercesc::DOMAttr& i (p.next_attribute ());
2301  const ::xsd::cxx::xml::qualified_name< char > n (
2302  ::xsd::cxx::xml::dom::name< char > (i));
2303 
2304  if (n.name () == "tableName" && n.namespace_ ().empty ())
2305  {
2306  this->tableName_.set (tableName_traits::create (i, f, this));
2307  continue;
2308  }
2309 
2310  if (n.name () == "dbHost" && n.namespace_ ().empty ())
2311  {
2312  this->dbHost_.set (dbHost_traits::create (i, f, this));
2313  continue;
2314  }
2315 
2316  if (n.name () == "dbName" && n.namespace_ ().empty ())
2317  {
2318  this->dbName_.set (dbName_traits::create (i, f, this));
2319  continue;
2320  }
2321 
2322  if (n.name () == "dbType" && n.namespace_ ().empty ())
2323  {
2324  this->dbType_.set (dbType_traits::create (i, f, this));
2325  continue;
2326  }
2327 
2328  if (n.name () == "dbPort" && n.namespace_ ().empty ())
2329  {
2330  this->dbPort_.set (dbPort_traits::create (i, f, this));
2331  continue;
2332  }
2333 
2334  if (n.name () == "tableType" && n.namespace_ ().empty ())
2335  {
2336  this->tableType_.set (tableType_traits::create (i, f, this));
2337  continue;
2338  }
2339 
2340  if (n.name () == "creationDate" && n.namespace_ ().empty ())
2341  {
2342  this->creationDate_.set (creationDate_traits::create (i, f, this));
2343  continue;
2344  }
2345 
2346  if (n.name () == "maintainer" && n.namespace_ ().empty ())
2347  {
2348  this->maintainer_.set (maintainer_traits::create (i, f, this));
2349  continue;
2350  }
2351 
2352  if (n.name () == "xmlOverDB" && n.namespace_ ().empty ())
2353  {
2354  this->xmlOverDB_.set (xmlOverDB_traits::create (i, f, this));
2355  continue;
2356  }
2357 
2358  if (n.name () == "ignoreDB" && n.namespace_ ().empty ())
2359  {
2360  this->ignoreDB_.set (ignoreDB_traits::create (i, f, this));
2361  continue;
2362  }
2363 
2364  if (n.name () == "addInsertTime" && n.namespace_ ().empty ())
2365  {
2366  this->addInsertTime_.set (addInsertTime_traits::create (i, f, this));
2367  continue;
2368  }
2369 
2370  if (n.name () == "addInsertUser" && n.namespace_ ().empty ())
2371  {
2372  this->addInsertUser_.set (addInsertUser_traits::create (i, f, this));
2373  continue;
2374  }
2375 
2376  if (n.name () == "addUpdateTime" && n.namespace_ ().empty ())
2377  {
2378  this->addUpdateTime_.set (addUpdateTime_traits::create (i, f, this));
2379  continue;
2380  }
2381 
2382  if (n.name () == "addUpdateUser" && n.namespace_ ().empty ())
2383  {
2384  this->addUpdateUser_.set (addUpdateUser_traits::create (i, f, this));
2385  continue;
2386  }
2387 
2388  if (n.name () == "schema" && n.namespace_ ().empty ())
2389  {
2390  this->schema_.set (schema_traits::create (i, f, this));
2391  continue;
2392  }
2393  }
2394 
2395  if (!tableName_.present ())
2396  {
2398  {
2399  std::cerr << "ERROR: expected attribute (dBTable::tableName) not found!" << std::endl;
2400  throw ::xsd::cxx::tree::expected_attribute< char > (
2401  "tableName",
2402  "");
2403  }
2404  }
2405 
2406  if (!dbHost_.present ())
2407  {
2409  {
2410  std::cerr << "ERROR: expected attribute (dBTable::dbHost) not found!" << std::endl;
2411  throw ::xsd::cxx::tree::expected_attribute< char > (
2412  "dbHost",
2413  "");
2414  }
2415  }
2416 
2417  if (!dbName_.present ())
2418  {
2420  {
2421  std::cerr << "ERROR: expected attribute (dBTable::dbName) not found!" << std::endl;
2422  throw ::xsd::cxx::tree::expected_attribute< char > (
2423  "dbName",
2424  "");
2425  }
2426  }
2427  }
2428 
2431  ::xml_schema::container* c) const
2432  {
2433  return new class dBTable (*this, f, c);
2434  }
2435 
2438  {
2439  if (this != &x)
2440  {
2441  static_cast< ::xml_schema::type& > (*this) = x;
2442  this->dBColumn_ = x.dBColumn_;
2443  this->dBPKey_ = x.dBPKey_;
2444  this->dBUnique_ = x.dBUnique_;
2445  this->dBCheck_ = x.dBCheck_;
2446  this->dBRow_ = x.dBRow_;
2447  this->tableName_ = x.tableName_;
2448  this->dbHost_ = x.dbHost_;
2449  this->dbName_ = x.dbName_;
2450  this->dbType_ = x.dbType_;
2451  this->dbPort_ = x.dbPort_;
2452  this->tableType_ = x.tableType_;
2453  this->creationDate_ = x.creationDate_;
2454  this->maintainer_ = x.maintainer_;
2455  this->xmlOverDB_ = x.xmlOverDB_;
2456  this->ignoreDB_ = x.ignoreDB_;
2457  this->addInsertTime_ = x.addInsertTime_;
2458  this->addInsertUser_ = x.addInsertUser_;
2459  this->addUpdateTime_ = x.addUpdateTime_;
2460  this->addUpdateUser_ = x.addUpdateUser_;
2461  this->schema_ = x.schema_;
2462  }
2463 
2464  return *this;
2465  }
2466 
2467  dBTable::
2469  {
2470  }
2471 
2473  serialize () const
2474  {
2475  // To avoid problems with multi-threaded access to
2476  // CST XSD ser/deserialization code and underlying
2477  // Xerces-C++ code, we prevent concurrent access
2478  // to any serialization code by any class that
2479  // inherits from XMLSerializable via the use of a
2480  // static mutex in XMLSerializable.
2481  boost::mutex::scoped_lock lock(_serializationMutex);
2482 
2483  ::std::ostringstream oss;
2484  dBTable_ (oss, *this);
2485  return oss.str();
2486  }
2487 
2488  void dBTable::
2490  {
2491  // To avoid problems with multi-threaded access to
2492  // CST XSD ser/deserialization code and underlying
2493  // Xerces-C++ code, we prevent concurrent access
2494  // to any deserialization code by any class that
2495  // inherits from XMLSerializable via the use of a
2496  // static mutex in XMLSerializable.
2497  boost::mutex::scoped_lock lock(_serializationMutex);
2498 
2499  // initialization for XSD
2500  ::xml_schema::flags flags = ::xml_schema::flags::dont_validate;
2501  ::xsd::cxx::xml::auto_initializer autoInit
2502  ((flags & ::xml_schema::flags::dont_initialize) == 0,
2503  (flags & ::xml_schema::flags::keep_dom) == 0);
2504  ::xsd::cxx::tree::error_handler< char > errorHandler;
2506 
2507  // wrap the string in an input stream
2508  ::std::istringstream iss (serializedData);
2509  ::xsd::cxx::xml::sax::std_input_source isrc (iss);
2510 
2511  // create a DOM from the input stream
2512  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > doc (
2513  ::xsd::cxx::xml::dom::parse< char > (isrc, errorHandler, props, flags));
2514  errorHandler.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
2515 
2516  // do the deserialization
2517  ::xsd::cxx::xml::dom::parser< char > parser (*(doc->getDocumentElement()), true, false, true);
2518  this->parse (parser, flags);
2519  }
2520 
2523  {
2524  return "nova::database::dBTable";
2525  }
2526 
2527  ::boost::shared_ptr< ::novadaq::XMLSerializable > dBTable::
2528  clone () const
2529  {
2530  dBTable *copy = this->_clone ();
2531  boost::shared_ptr<novadaq::XMLSerializable> copyPtr (copy);
2532  return copyPtr;
2533  }
2534 
2535  void dBTable::
2537  {
2538  boost::shared_ptr<novadaq::XMLSerializable> msgPtr;
2541  msgPtr.reset(new dBTable());
2542  deserRegistry.registerClass(msgPtr->getClassName(), msgPtr);
2543  }
2544 
2545  void dBTable::
2547  {
2548  if (x.hasDBPKey()) {
2549  if (! this->hasDBPKey()) {
2550  this->setDBPKey(x.getDBPKey());
2551  }
2552  else {
2554  }
2555  }
2556  if (x.hasDbHost()) {
2557  if (! this->hasDbHost()) {
2558  this->setDbHost(x.getDbHost());
2559  }
2560  else {
2562  }
2563  }
2564  if (x.hasDbName()) {
2565  if (! this->hasDbName()) {
2566  this->setDbName(x.getDbName());
2567  }
2568  else {
2570  }
2571  }
2572  if (x.hasTableName()) {
2573  if (! this->hasTableName()) {
2574  this->setTableName(x.getTableName());
2575  }
2576  else {
2578  }
2579  }
2580  if (x.hasDBCheck() && x.getDBCheckCount() > 0) {
2581  if (! this->hasDBCheck() || this->getDBCheckCount() == 0) {
2582  for (::xml_schema::integer idx = 0; idx < x.getDBCheckCount(); ++idx) {
2583  this->addDBCheck(x.getDBCheck(idx));
2584  }
2585  }
2586  //else {
2587  // copyTraits<dBCheck_type>::copyNeededFields(x.getDBCheck(), this->dBCheck());
2588  //}
2589  }
2590  if (x.hasDBColumn() && x.getDBColumnCount() > 0) {
2591  if (! this->hasDBColumn() || this->getDBColumnCount() == 0) {
2592  for (::xml_schema::integer idx = 0; idx < x.getDBColumnCount(); ++idx) {
2593  this->addDBColumn(x.getDBColumn(idx));
2594  }
2595  }
2596  //else {
2597  // copyTraits<dBColumn_type>::copyNeededFields(x.getDBColumn(), this->dBColumn());
2598  //}
2599  }
2600  if (x.hasDBRow() && x.getDBRowCount() > 0) {
2601  if (! this->hasDBRow() || this->getDBRowCount() == 0) {
2602  for (::xml_schema::integer idx = 0; idx < x.getDBRowCount(); ++idx) {
2603  this->addDBRow(x.getDBRow(idx));
2604  }
2605  }
2606  //else {
2607  // copyTraits<dBRow_type>::copyNeededFields(x.getDBRow(), this->dBRow());
2608  //}
2609  }
2610  if (x.hasDBUnique() && x.getDBUniqueCount() > 0) {
2611  if (! this->hasDBUnique() || this->getDBUniqueCount() == 0) {
2612  for (::xml_schema::integer idx = 0; idx < x.getDBUniqueCount(); ++idx) {
2613  this->addDBUnique(x.getDBUnique(idx));
2614  }
2615  }
2616  //else {
2617  // copyTraits<dBUnique_type>::copyNeededFields(x.getDBUnique(), this->dBUnique());
2618  //}
2619  }
2620  }
2621  }
2622 }
2623 
2624 #include <istream>
2625 #include <xsd/cxx/xml/sax/std-input-source.hxx>
2626 #include <xsd/cxx/tree/error-handler.hxx>
2627 
2628 namespace nova
2629 {
2630  namespace database
2631  {
2632  ::std::unique_ptr< ::nova::database::dBTable >
2634  ::xml_schema::flags f,
2636  {
2637  ::xsd::cxx::xml::auto_initializer i (
2638  (f & ::xml_schema::flags::dont_initialize) == 0,
2639  (f & ::xml_schema::flags::keep_dom) == 0);
2640 
2641  ::xsd::cxx::tree::error_handler< char > h;
2642 
2643  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2644  ::xsd::cxx::xml::dom::parse< char > (
2645  u, h, p, f));
2646 
2647  h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
2648 
2649  return ::std::unique_ptr< ::nova::database::dBTable > (
2651  std::move (d), f | ::xml_schema::flags::own_dom, p));
2652  }
2653 
2654  ::std::unique_ptr< ::nova::database::dBTable >
2657  ::xml_schema::flags f,
2659  {
2660  ::xsd::cxx::xml::auto_initializer i (
2661  (f & ::xml_schema::flags::dont_initialize) == 0,
2662  (f & ::xml_schema::flags::keep_dom) == 0);
2663 
2664  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2665  ::xsd::cxx::xml::dom::parse< char > (
2666  u, h, p, f));
2667 
2668  if (!d.get ())
2669  throw ::xsd::cxx::tree::parsing< char > ();
2670 
2671  return ::std::unique_ptr< ::nova::database::dBTable > (
2673  std::move (d), f | ::xml_schema::flags::own_dom, p));
2674  }
2675 
2676  ::std::unique_ptr< ::nova::database::dBTable >
2678  ::xercesc::DOMErrorHandler& h,
2679  ::xml_schema::flags f,
2681  {
2682  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2683  ::xsd::cxx::xml::dom::parse< char > (
2684  u, h, p, f));
2685 
2686  if (!d.get ())
2687  throw ::xsd::cxx::tree::parsing< char > ();
2688 
2689  return ::std::unique_ptr< ::nova::database::dBTable > (
2691  std::move (d), f | ::xml_schema::flags::own_dom, p));
2692  }
2693 
2694  ::std::unique_ptr< ::nova::database::dBTable >
2695  dBTable_ (::std::istream& is,
2696  ::xml_schema::flags f,
2698  {
2699  ::xsd::cxx::xml::auto_initializer i (
2700  (f & ::xml_schema::flags::dont_initialize) == 0,
2701  (f & ::xml_schema::flags::keep_dom) == 0);
2702 
2703  ::xsd::cxx::xml::sax::std_input_source isrc (is);
2704  return ::nova::database::dBTable_ (isrc, f, p);
2705  }
2706 
2707  ::std::unique_ptr< ::nova::database::dBTable >
2708  dBTable_ (::std::istream& is,
2710  ::xml_schema::flags f,
2712  {
2713  ::xsd::cxx::xml::auto_initializer i (
2714  (f & ::xml_schema::flags::dont_initialize) == 0,
2715  (f & ::xml_schema::flags::keep_dom) == 0);
2716 
2717  ::xsd::cxx::xml::sax::std_input_source isrc (is);
2718  return ::nova::database::dBTable_ (isrc, h, f, p);
2719  }
2720 
2721  ::std::unique_ptr< ::nova::database::dBTable >
2722  dBTable_ (::std::istream& is,
2723  ::xercesc::DOMErrorHandler& h,
2724  ::xml_schema::flags f,
2726  {
2727  ::xsd::cxx::xml::sax::std_input_source isrc (is);
2728  return ::nova::database::dBTable_ (isrc, h, f, p);
2729  }
2730 
2731  ::std::unique_ptr< ::nova::database::dBTable >
2732  dBTable_ (::std::istream& is,
2733  const ::std::string& sid,
2734  ::xml_schema::flags f,
2736  {
2737  ::xsd::cxx::xml::auto_initializer i (
2738  (f & ::xml_schema::flags::dont_initialize) == 0,
2739  (f & ::xml_schema::flags::keep_dom) == 0);
2740 
2741  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
2742  return ::nova::database::dBTable_ (isrc, f, p);
2743  }
2744 
2745  ::std::unique_ptr< ::nova::database::dBTable >
2746  dBTable_ (::std::istream& is,
2747  const ::std::string& sid,
2749  ::xml_schema::flags f,
2751  {
2752  ::xsd::cxx::xml::auto_initializer i (
2753  (f & ::xml_schema::flags::dont_initialize) == 0,
2754  (f & ::xml_schema::flags::keep_dom) == 0);
2755 
2756  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
2757  return ::nova::database::dBTable_ (isrc, h, f, p);
2758  }
2759 
2760  ::std::unique_ptr< ::nova::database::dBTable >
2761  dBTable_ (::std::istream& is,
2762  const ::std::string& sid,
2763  ::xercesc::DOMErrorHandler& h,
2764  ::xml_schema::flags f,
2766  {
2767  ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
2768  return ::nova::database::dBTable_ (isrc, h, f, p);
2769  }
2770 
2771  ::std::unique_ptr< ::nova::database::dBTable >
2772  dBTable_ (::xercesc::InputSource& i,
2773  ::xml_schema::flags f,
2775  {
2776  ::xsd::cxx::tree::error_handler< char > h;
2777 
2778  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2779  ::xsd::cxx::xml::dom::parse< char > (
2780  i, h, p, f));
2781 
2782  h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
2783 
2784  return ::std::unique_ptr< ::nova::database::dBTable > (
2786  std::move (d), f | ::xml_schema::flags::own_dom, p));
2787  }
2788 
2789  ::std::unique_ptr< ::nova::database::dBTable >
2790  dBTable_ (::xercesc::InputSource& i,
2792  ::xml_schema::flags f,
2794  {
2795  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2796  ::xsd::cxx::xml::dom::parse< char > (
2797  i, h, p, f));
2798 
2799  if (!d.get ())
2800  throw ::xsd::cxx::tree::parsing< char > ();
2801 
2802  return ::std::unique_ptr< ::nova::database::dBTable > (
2804  std::move (d), f | ::xml_schema::flags::own_dom, p));
2805  }
2806 
2807  ::std::unique_ptr< ::nova::database::dBTable >
2808  dBTable_ (::xercesc::InputSource& i,
2809  ::xercesc::DOMErrorHandler& h,
2810  ::xml_schema::flags f,
2812  {
2813  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2814  ::xsd::cxx::xml::dom::parse< char > (
2815  i, h, p, f));
2816 
2817  if (!d.get ())
2818  throw ::xsd::cxx::tree::parsing< char > ();
2819 
2820  return ::std::unique_ptr< ::nova::database::dBTable > (
2822  std::move (d), f | ::xml_schema::flags::own_dom, p));
2823  }
2824 
2825  ::std::unique_ptr< ::nova::database::dBTable >
2826  dBTable_ (const ::xercesc::DOMDocument& doc,
2827  ::xml_schema::flags f,
2829  {
2830  if (f & ::xml_schema::flags::keep_dom)
2831  {
2832  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2833  static_cast< ::xercesc::DOMDocument* > (doc.cloneNode (true)));
2834 
2835  return ::std::unique_ptr< ::nova::database::dBTable > (
2837  std::move (d), f | ::xml_schema::flags::own_dom, p));
2838  }
2839 
2840  const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
2841  const ::xsd::cxx::xml::qualified_name< char > n (
2842  ::xsd::cxx::xml::dom::name< char > (e));
2843 
2844  if (n.name () == "dBTable" &&
2845  n.namespace_ () == "")
2846  {
2847  ::std::unique_ptr< ::nova::database::dBTable > r (
2848  ::xsd::cxx::tree::traits< ::nova::database::dBTable, char >::create (
2849  e, f, 0));
2850  return r;
2851  }
2852 
2853  throw ::xsd::cxx::tree::unexpected_element < char > (
2854  n.name (),
2855  n.namespace_ (),
2856  "dBTable",
2857  "");
2858  }
2859 
2860  ::std::unique_ptr< ::nova::database::dBTable >
2861  dBTable_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
2862  ::xml_schema::flags f,
2864  {
2865  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > c (
2866  ((f & ::xml_schema::flags::keep_dom) &&
2867  !(f & ::xml_schema::flags::own_dom))
2868  ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
2869  : 0);
2870 
2871  ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
2872  const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
2873 
2874  const ::xsd::cxx::xml::qualified_name< char > n (
2875  ::xsd::cxx::xml::dom::name< char > (e));
2876 
2877  if (f & ::xml_schema::flags::keep_dom)
2878  doc.setUserData (::xml_schema::dom::tree_node_key,
2879  (c.get () ? &c : &d),
2880  0);
2881 
2882  if (n.name () == "dBTable" &&
2883  n.namespace_ () == "")
2884  {
2885  ::std::unique_ptr< ::nova::database::dBTable > r (
2886  ::xsd::cxx::tree::traits< ::nova::database::dBTable, char >::create (
2887  e, f, 0));
2888  return r;
2889  }
2890 
2891  throw ::xsd::cxx::tree::unexpected_element < char > (
2892  n.name (),
2893  n.namespace_ (),
2894  "dBTable",
2895  "");
2896  }
2897  }
2898 }
2899 
2900 #include <ostream>
2901 #include <xsd/cxx/tree/error-handler.hxx>
2902 #include <xsd/cxx/xml/dom/serialization-source.hxx>
2903 
2904 namespace nova
2905 {
2906  namespace database
2907  {
2908  void
2909  dBTable_ (::std::ostream& o,
2910  const ::nova::database::dBTable& s,
2913  ::xml_schema::flags f)
2914  {
2915  ::xsd::cxx::xml::auto_initializer i (
2916  (f & ::xml_schema::flags::dont_initialize) == 0);
2917 
2918  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2919  ::nova::database::dBTable_ (s, m, f));
2920 
2921  ::xsd::cxx::tree::error_handler< char > h;
2922 
2923  ::xsd::cxx::xml::dom::ostream_format_target t (o);
2924  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
2925  {
2926  h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
2927  }
2928  }
2929 
2930  void
2931  dBTable_ (::std::ostream& o,
2932  const ::nova::database::dBTable& s,
2936  ::xml_schema::flags f)
2937  {
2938  ::xsd::cxx::xml::auto_initializer i (
2939  (f & ::xml_schema::flags::dont_initialize) == 0);
2940 
2941  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2942  ::nova::database::dBTable_ (s, m, f));
2943  ::xsd::cxx::xml::dom::ostream_format_target t (o);
2944  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
2945  {
2946  throw ::xsd::cxx::tree::serialization< char > ();
2947  }
2948  }
2949 
2950  void
2951  dBTable_ (::std::ostream& o,
2952  const ::nova::database::dBTable& s,
2953  ::xercesc::DOMErrorHandler& h,
2956  ::xml_schema::flags f)
2957  {
2958  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2959  ::nova::database::dBTable_ (s, m, f));
2960  ::xsd::cxx::xml::dom::ostream_format_target t (o);
2961  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
2962  {
2963  throw ::xsd::cxx::tree::serialization< char > ();
2964  }
2965  }
2966 
2967  void
2968  dBTable_ (::xercesc::XMLFormatTarget& t,
2969  const ::nova::database::dBTable& s,
2972  ::xml_schema::flags f)
2973  {
2974  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2975  ::nova::database::dBTable_ (s, m, f));
2976 
2977  ::xsd::cxx::tree::error_handler< char > h;
2978 
2979  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
2980  {
2981  h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
2982  }
2983  }
2984 
2985  void
2986  dBTable_ (::xercesc::XMLFormatTarget& t,
2987  const ::nova::database::dBTable& s,
2991  ::xml_schema::flags f)
2992  {
2993  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
2994  ::nova::database::dBTable_ (s, m, f));
2995  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
2996  {
2997  throw ::xsd::cxx::tree::serialization< char > ();
2998  }
2999  }
3000 
3001  void
3002  dBTable_ (::xercesc::XMLFormatTarget& t,
3003  const ::nova::database::dBTable& s,
3004  ::xercesc::DOMErrorHandler& h,
3007  ::xml_schema::flags f)
3008  {
3009  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
3010  ::nova::database::dBTable_ (s, m, f));
3011  if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
3012  {
3013  throw ::xsd::cxx::tree::serialization< char > ();
3014  }
3015  }
3016 
3017  void
3018  dBTable_ (::xercesc::DOMDocument& d,
3019  const ::nova::database::dBTable& s,
3021  {
3022  ::xercesc::DOMElement& e (*d.getDocumentElement ());
3023  const ::xsd::cxx::xml::qualified_name< char > n (
3024  ::xsd::cxx::xml::dom::name< char > (e));
3025 
3026  if (n.name () == "dBTable" &&
3027  n.namespace_ () == "")
3028  {
3029  e << s;
3030  }
3031  else
3032  {
3033  throw ::xsd::cxx::tree::unexpected_element < char > (
3034  n.name (),
3035  n.namespace_ (),
3036  "dBTable",
3037  "");
3038  }
3039  }
3040 
3041  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
3042  dBTable_ (const ::nova::database::dBTable& s,
3044  ::xml_schema::flags f)
3045  {
3046  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
3047  ::xsd::cxx::xml::dom::serialize< char > (
3048  "dBTable",
3049  "",
3050  m, f));
3051 
3052  ::nova::database::dBTable_ (*d, s, f);
3053  return d;
3054  }
3055 
3056  void
3057  operator<< (::xercesc::DOMElement& e, const Tolerance_t& i)
3058  {
3059  e << static_cast< const ::xml_schema::type& > (i);
3060 
3061  // tolValue
3062  //
3063  {
3064  ::xercesc::DOMAttr& a (
3065  ::xsd::cxx::xml::dom::create_attribute (
3066  "tolValue",
3067  e));
3068 
3069  if (! i.hasTolValue ()) {
3070  std::cerr << "WARNING: attempting to serialize a Tolerance_t with an empty tolValue field!" << std::endl;
3071  }
3072  a << i.tolValue ();
3073  }
3074 
3075  // tolType
3076  //
3077  {
3078  ::xercesc::DOMAttr& a (
3079  ::xsd::cxx::xml::dom::create_attribute (
3080  "tolType",
3081  e));
3082 
3083  if (! i.hasTolType ()) {
3084  std::cerr << "WARNING: attempting to serialize a Tolerance_t with an empty tolType field!" << std::endl;
3085  }
3086  a << i.tolType ();
3087  }
3088  }
3089 
3090  void
3091  operator<< (::xercesc::DOMElement& e, const dBColumn_t& i)
3092  {
3093  e << static_cast< const ::xml_schema::type& > (i);
3094 
3095  // tolerance
3096  //
3097  if (i.tolerance ())
3098  {
3099  ::xercesc::DOMElement& s (
3100  ::xsd::cxx::xml::dom::create_element (
3101  "tolerance",
3102  e));
3103 
3104  s << *i.tolerance ();
3105  }
3106 
3107  // name
3108  //
3109  {
3110  ::xercesc::DOMAttr& a (
3111  ::xsd::cxx::xml::dom::create_attribute (
3112  "name",
3113  e));
3114 
3115  if (! i.hasName ()) {
3116  std::cerr << "WARNING: attempting to serialize a dBColumn_t with an empty name field!" << std::endl;
3117  }
3118  a << i.name ();
3119  }
3120 
3121  // colType
3122  //
3123  if (i.colType ())
3124  {
3125  ::xercesc::DOMAttr& a (
3126  ::xsd::cxx::xml::dom::create_attribute (
3127  "colType",
3128  e));
3129 
3130  a << *i.colType ();
3131  }
3132 
3133  // value
3134  //
3135  if (i.value ())
3136  {
3137  ::xercesc::DOMAttr& a (
3138  ::xsd::cxx::xml::dom::create_attribute (
3139  "value",
3140  e));
3141 
3142  a << *i.value ();
3143  }
3144 
3145  // null
3146  //
3147  if (i.null ())
3148  {
3149  ::xercesc::DOMAttr& a (
3150  ::xsd::cxx::xml::dom::create_attribute (
3151  "null",
3152  e));
3153 
3154  a << *i.null ();
3155  }
3156 
3157  // fKeyTable
3158  //
3159  if (i.fKeyTable ())
3160  {
3161  ::xercesc::DOMAttr& a (
3162  ::xsd::cxx::xml::dom::create_attribute (
3163  "fKeyTable",
3164  e));
3165 
3166  a << *i.fKeyTable ();
3167  }
3168 
3169  // fKeyColumn
3170  //
3171  if (i.fKeyColumn ())
3172  {
3173  ::xercesc::DOMAttr& a (
3174  ::xsd::cxx::xml::dom::create_attribute (
3175  "fKeyColumn",
3176  e));
3177 
3178  a << *i.fKeyColumn ();
3179  }
3180  }
3181 
3182  void
3183  operator<< (::xercesc::DOMElement& e, const dBCheck_t& i)
3184  {
3185  e << static_cast< const ::xml_schema::type& > (i);
3186 
3187  // constraint
3188  //
3189  {
3190  ::xercesc::DOMAttr& a (
3191  ::xsd::cxx::xml::dom::create_attribute (
3192  "constraint",
3193  e));
3194 
3195  if (! i.hasConstraint ()) {
3196  std::cerr << "WARNING: attempting to serialize a dBCheck_t with an empty constraint field!" << std::endl;
3197  }
3198  a << i.constraint ();
3199  }
3200  }
3201 
3202  void
3203  operator<< (::xercesc::DOMElement& e, const dBRow_t& i)
3204  {
3205  e << static_cast< const ::xml_schema::type& > (i);
3206 
3207  // dBCol
3208  //
3210  b (i.dBCol ().begin ()), n (i.dBCol ().end ());
3211  b != n; ++b)
3212  {
3213  ::xercesc::DOMElement& s (
3214  ::xsd::cxx::xml::dom::create_element (
3215  "dBCol",
3216  e));
3217 
3218  s << *b;
3219  }
3220  }
3221 
3222  void
3223  operator<< (::xercesc::DOMElement& e, const dBTable& i)
3224  {
3225  e << static_cast< const ::xml_schema::type& > (i);
3226 
3227  // dBColumn
3228  //
3230  b (i.dBColumn ().begin ()), n (i.dBColumn ().end ());
3231  b != n; ++b)
3232  {
3233  ::xercesc::DOMElement& s (
3234  ::xsd::cxx::xml::dom::create_element (
3235  "dBColumn",
3236  e));
3237 
3238  s << *b;
3239  }
3240 
3241  // dBPKey
3242  //
3243  if (i.dBPKey ())
3244  {
3245  ::xercesc::DOMElement& s (
3246  ::xsd::cxx::xml::dom::create_element (
3247  "dBPKey",
3248  e));
3249 
3250  s << *i.dBPKey ();
3251  }
3252 
3253  // dBUnique
3254  //
3256  b (i.dBUnique ().begin ()), n (i.dBUnique ().end ());
3257  b != n; ++b)
3258  {
3259  ::xercesc::DOMElement& s (
3260  ::xsd::cxx::xml::dom::create_element (
3261  "dBUnique",
3262  e));
3263 
3264  s << *b;
3265  }
3266 
3267  // dBCheck
3268  //
3270  b (i.dBCheck ().begin ()), n (i.dBCheck ().end ());
3271  b != n; ++b)
3272  {
3273  ::xercesc::DOMElement& s (
3274  ::xsd::cxx::xml::dom::create_element (
3275  "dBCheck",
3276  e));
3277 
3278  s << *b;
3279  }
3280 
3281  // dBRow
3282  //
3284  b (i.dBRow ().begin ()), n (i.dBRow ().end ());
3285  b != n; ++b)
3286  {
3287  ::xercesc::DOMElement& s (
3288  ::xsd::cxx::xml::dom::create_element (
3289  "dBRow",
3290  e));
3291 
3292  s << *b;
3293  }
3294 
3295  // tableName
3296  //
3297  {
3298  ::xercesc::DOMAttr& a (
3299  ::xsd::cxx::xml::dom::create_attribute (
3300  "tableName",
3301  e));
3302 
3303  if (! i.hasTableName ()) {
3304  std::cerr << "WARNING: attempting to serialize a dBTable with an empty tableName field!" << std::endl;
3305  }
3306  a << i.tableName ();
3307  }
3308 
3309  // dbHost
3310  //
3311  {
3312  ::xercesc::DOMAttr& a (
3313  ::xsd::cxx::xml::dom::create_attribute (
3314  "dbHost",
3315  e));
3316 
3317  if (! i.hasDbHost ()) {
3318  std::cerr << "WARNING: attempting to serialize a dBTable with an empty dbHost field!" << std::endl;
3319  }
3320  a << i.dbHost ();
3321  }
3322 
3323  // dbName
3324  //
3325  {
3326  ::xercesc::DOMAttr& a (
3327  ::xsd::cxx::xml::dom::create_attribute (
3328  "dbName",
3329  e));
3330 
3331  if (! i.hasDbName ()) {
3332  std::cerr << "WARNING: attempting to serialize a dBTable with an empty dbName field!" << std::endl;
3333  }
3334  a << i.dbName ();
3335  }
3336 
3337  // dbType
3338  //
3339  if (i.dbType ())
3340  {
3341  ::xercesc::DOMAttr& a (
3342  ::xsd::cxx::xml::dom::create_attribute (
3343  "dbType",
3344  e));
3345 
3346  a << *i.dbType ();
3347  }
3348 
3349  // dbPort
3350  //
3351  if (i.dbPort ())
3352  {
3353  ::xercesc::DOMAttr& a (
3354  ::xsd::cxx::xml::dom::create_attribute (
3355  "dbPort",
3356  e));
3357 
3358  a << *i.dbPort ();
3359  }
3360 
3361  // tableType
3362  //
3363  if (i.tableType ())
3364  {
3365  ::xercesc::DOMAttr& a (
3366  ::xsd::cxx::xml::dom::create_attribute (
3367  "tableType",
3368  e));
3369 
3370  a << *i.tableType ();
3371  }
3372 
3373  // creationDate
3374  //
3375  if (i.creationDate ())
3376  {
3377  ::xercesc::DOMAttr& a (
3378  ::xsd::cxx::xml::dom::create_attribute (
3379  "creationDate",
3380  e));
3381 
3382  a << *i.creationDate ();
3383  }
3384 
3385  // maintainer
3386  //
3387  if (i.maintainer ())
3388  {
3389  ::xercesc::DOMAttr& a (
3390  ::xsd::cxx::xml::dom::create_attribute (
3391  "maintainer",
3392  e));
3393 
3394  a << *i.maintainer ();
3395  }
3396 
3397  // xmlOverDB
3398  //
3399  if (i.xmlOverDB ())
3400  {
3401  ::xercesc::DOMAttr& a (
3402  ::xsd::cxx::xml::dom::create_attribute (
3403  "xmlOverDB",
3404  e));
3405 
3406  a << *i.xmlOverDB ();
3407  }
3408 
3409  // ignoreDB
3410  //
3411  if (i.ignoreDB ())
3412  {
3413  ::xercesc::DOMAttr& a (
3414  ::xsd::cxx::xml::dom::create_attribute (
3415  "ignoreDB",
3416  e));
3417 
3418  a << *i.ignoreDB ();
3419  }
3420 
3421  // addInsertTime
3422  //
3423  if (i.addInsertTime ())
3424  {
3425  ::xercesc::DOMAttr& a (
3426  ::xsd::cxx::xml::dom::create_attribute (
3427  "addInsertTime",
3428  e));
3429 
3430  a << *i.addInsertTime ();
3431  }
3432 
3433  // addInsertUser
3434  //
3435  if (i.addInsertUser ())
3436  {
3437  ::xercesc::DOMAttr& a (
3438  ::xsd::cxx::xml::dom::create_attribute (
3439  "addInsertUser",
3440  e));
3441 
3442  a << *i.addInsertUser ();
3443  }
3444 
3445  // addUpdateTime
3446  //
3447  if (i.addUpdateTime ())
3448  {
3449  ::xercesc::DOMAttr& a (
3450  ::xsd::cxx::xml::dom::create_attribute (
3451  "addUpdateTime",
3452  e));
3453 
3454  a << *i.addUpdateTime ();
3455  }
3456 
3457  // addUpdateUser
3458  //
3459  if (i.addUpdateUser ())
3460  {
3461  ::xercesc::DOMAttr& a (
3462  ::xsd::cxx::xml::dom::create_attribute (
3463  "addUpdateUser",
3464  e));
3465 
3466  a << *i.addUpdateUser ();
3467  }
3468 
3469  // schema
3470  //
3471  if (i.schema ())
3472  {
3473  ::xercesc::DOMAttr& a (
3474  ::xsd::cxx::xml::dom::create_attribute (
3475  "schema",
3476  e));
3477 
3478  a << *i.schema ();
3479  }
3480  }
3481  }
3482 }
3483 
3484 #include <xsd/cxx/post.hxx>
3485 
3486 // Begin epilogue.
3487 //
3488 //
3489 // End epilogue.
3490 
::xsd::cxx::tree::optional< addUpdateTime_type > addUpdateTime_optional
static void copyNeededFields(dBRow_t const &source, Y &target)
addUpdateTime_optional addUpdateTime_
maintainer_optional maintainer_
::xsd::cxx::tree::optional< addUpdateUser_type > addUpdateUser_optional
dBRow_sequence::const_iterator dBRow_const_iterator
Definition: NovaDatabase.h:914
const XML_Char * name
Definition: expat.h:151
static void copyNeededFields(dBRow_t const &source, dBRow_t &target)
const tableType_optional & tableType() const
ignoreDB_optional ignoreDB_
::xsd::cxx::tree::sequence< dBUnique_type > dBUnique_sequence
Definition: NovaDatabase.h:842
::xsd::cxx::tree::optional< value_type > value_optional
Definition: NovaDatabase.h:474
void parse(::xsd::cxx::xml::dom::parser< char > &,::xml_schema::flags)
const dbName_type & getDbName() const
virtual dBCheck_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
void setTableType(const tableType_type &x)
::xml_schema::float_ tolValue_type
Definition: NovaDatabase.h:296
void setCreationDate(const creationDate_type &x)
addUpdateUser_optional addUpdateUser_
const XML_Char * target
Definition: expat.h:268
void setDBPKey(const dBPKey_type &x)
void addDBRow(const dBRow_type &newDBRow)
static void copyNeededFields(Tolerance_t const &source, Tolerance_t &target)
dBUnique_sequence::const_iterator dBUnique_const_iterator
Definition: NovaDatabase.h:844
::xsd::cxx::tree::flags flags
Definition: Database.h:214
static void copyNeededFields(dBTable const &source, Y &target)
::xml_schema::string name_type
Definition: NovaDatabase.h:417
void setColType(const colType_type &x)
::xml_schema::boolean null_type
Definition: NovaDatabase.h:503
::xml_schema::string dbName_type
Definition: NovaDatabase.h:998
void setDbName(const dbName_type &x)
void setDbType(const dbType_type &x)
static void copyNeededFields(dBCheck_t const &source, dBCheck_t &target)
virtual ::boost::shared_ptr< ::novadaq::XMLSerializable > clone() const
::xml_schema::boolean addUpdateTime_type
dbType_optional dbType_
dBTable & operator=(const dBTable &x)
void setFKeyTable(const fKeyTable_type &x)
const tolType_type & getTolType() const
::xsd::cxx::tree::optional< creationDate_type > creationDate_optional
const char * p
Definition: xmltok.h:285
void copyNeededFields(const dBCheck_t &x)
static void copyNeededFields(dBColumn_t const &source, Y &target)
::xsd::cxx::tree::sequence< dBColumn_type > dBColumn_sequence
Definition: NovaDatabase.h:777
::xsd::cxx::tree::optional< colType_type > colType_optional
Definition: NovaDatabase.h:444
const fKeyTable_optional & fKeyTable() const
const tableName_type & tableName() const
virtual ::std::string getClassName() const
void setTableName(const tableName_type &x)
static void copyNeededFields(X const &source, X &target)
::xsd::cxx::tree::optional< fKeyColumn_type > fKeyColumn_optional
Definition: NovaDatabase.h:561
void parse(::xsd::cxx::xml::dom::parser< char > &,::xml_schema::flags)
const xmlOverDB_optional & xmlOverDB() const
void addDBCol(const dBCol_type &newDBCol)
void parse(::xsd::cxx::xml::dom::parser< char > &,::xml_schema::flags)
const colType_type & getColType() const
::xml_schema::boolean xmlOverDB_type
OStream cerr
Definition: OStream.cxx:7
::xsd::cxx::tree::optional< schema_type > schema_optional
const dBRow_type & getDBRow(int index) const
void addDBColumn(const dBColumn_type &newDBColumn)
void setSchema(const schema_type &x)
const addUpdateUser_type & getAddUpdateUser() const
::xml_schema::integer getDBUniqueCount() const
const constraint_type & getConstraint() const
fKeyColumn_optional fKeyColumn_
Definition: NovaDatabase.h:628
void registerClass(std::string className, boost::shared_ptr< XMLSerializable > classInstance)
dBPKey_optional dBPKey_
dBCol_sequence::const_iterator dBCol_const_iterator
Definition: NovaDatabase.h:705
dBUnique_sequence dBUnique_
const dBUnique_type & getDBUnique(int index) const
::xsd::cxx::tree::optional< tableType_type > tableType_optional
const dBUnique_sequence & dBUnique() const
::xsd::cxx::tree::optional< addInsertTime_type > addInsertTime_optional
dBCol_type & getDBColReference(int index)
const dBCol_sequence & dBCol() const
::xsd::cxx::tree::optional< tolerance_type > tolerance_optional
Definition: NovaDatabase.h:388
const XML_Char int const XML_Char int const XML_Char * base
Definition: expat.h:331
::xsd::cxx::tree::optional< dBPKey_type > dBPKey_optional
Definition: NovaDatabase.h:812
virtual Tolerance_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
::xml_schema::string dbPort_type
bool hasTableName() const
fKeyTable_optional fKeyTable_
Definition: NovaDatabase.h:627
static const unsigned long allow_missing_elements
const addUpdateUser_optional & addUpdateUser() const
double value_
static void copyNeededFields(Tolerance_t const &source, Y &target)
void setConstraint(const constraint_type &x)
dbPort_optional dbPort_
void setValue(const value_type &x)
void setTolValue(const tolValue_type &x)
Float_t Y
Definition: plot.C:38
::xsd::cxx::tree::type type
Definition: Database.h:110
::std::unique_ptr< ::nova::dbi::dBTable > dBTable_(const ::std::string &uri,::xml_schema::flags f=0, const ::xml_schema::properties &p=::xml_schema::properties())
Definition: Database.cpp:2371
const schema_type & getSchema() const
dBCheck_type & getDBCheckReference(int index)
const dbHost_type & getDbHost() const
const dBCol_type & getDBCol(int index) const
void setFKeyColumn(const fKeyColumn_type &x)
const addInsertTime_optional & addInsertTime() const
const dBRow_sequence & dBRow() const
void copyNeededFields(const dBColumn_t &x)
void parse(::xsd::cxx::xml::dom::parser< char > &,::xml_schema::flags)
::xml_schema::string colType_type
Definition: NovaDatabase.h:443
const fKeyColumn_optional & fKeyColumn() const
const value_optional & value() const
const fKeyTable_type & getFKeyTable() const
const tolerance_optional & tolerance() const
const addInsertUser_optional & addInsertUser() const
const XML_Char * s
Definition: expat.h:262
const name_type & getName() const
void setTolType(const tolType_type &x)
schema_optional schema_
::xml_schema::string schema_type
::xsd::cxx::tree::optional< xmlOverDB_type > xmlOverDB_optional
const ignoreDB_type & getIgnoreDB() const
::xsd::cxx::tree::sequence< dBCheck_type > dBCheck_sequence
Definition: NovaDatabase.h:877
const null_type & getNull() const
dBColumn_sequence::const_iterator dBColumn_const_iterator
Definition: NovaDatabase.h:779
::xml_schema::integer getDBRowCount() const
const dBPKey_type & getDBPKey() const
::xsd::cxx::tree::optional< dbType_type > dbType_optional
xmlOverDB_optional xmlOverDB_
void addDBUnique(const dBUnique_type &newDBUnique)
dBColumn_t & operator=(const dBColumn_t &x)
dBColumn_type & getDBColumnReference(int index)
::xsd::cxx::tree::sequence< dBCol_type > dBCol_sequence
Definition: NovaDatabase.h:703
const double a
::xml_schema::integer getDBColCount() const
::xml_schema::integer getDBCheckCount() const
::xml_schema::string fKeyTable_type
Definition: NovaDatabase.h:530
const dbPort_optional & dbPort() const
dBRow_t & operator=(const dBRow_t &x)
const tolValue_type & getTolValue() const
::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap
Definition: Database.h:206
creationDate_optional creationDate_
void addDBCheck(const dBCheck_type &newDBCheck)
const colType_optional & colType() const
void setDbPort(const dbPort_type &x)
static void copyNeededFields(X const &source, Y &target)
dBCheck_t & operator=(const dBCheck_t &x)
bool hasAddInsertTime() const
Float_t d
Definition: plot.C:236
bool hasAddUpdateTime() const
addInsertUser_optional addInsertUser_
const fKeyColumn_type & getFKeyColumn() const
::xsd::cxx::tree::optional< fKeyTable_type > fKeyTable_optional
Definition: NovaDatabase.h:531
void setXmlOverDB(const xmlOverDB_type &x)
::xsd::cxx::tree::one< tableName_type > tableName_
::xsd::cxx::xml::error_handler< char > error_handler
Definition: Database.h:239
::xsd::cxx::tree::optional< null_type > null_optional
Definition: NovaDatabase.h:504
tableType_optional tableType_
const XMLCh *const tree_node_key
Definition: Database.h:253
::xsd::cxx::tree::properties< char > properties
Definition: Database.h:215
::xml_schema::boolean addInsertTime_type
const dbType_optional & dbType() const
const null_optional & null() const
const dbName_type & dbName() const
const maintainer_type & getMaintainer() const
::xml_schema::boolean addUpdateUser_type
virtual dBTable * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
::xsd::cxx::tree::optional< ignoreDB_type > ignoreDB_optional
static boost::mutex _serializationMutex
const name_type & name() const
::xml_schema::string constraint_type
Definition: NovaDatabase.h:636
Hold drift constants from current run.
Definition: DriftCache.h:17
const xmlOverDB_type & getXmlOverDB() const
::xsd::cxx::tree::one< name_type > name_
Definition: NovaDatabase.h:623
const creationDate_optional & creationDate() const
void copyNeededFields(const dBTable &x)
void setDbHost(const dbHost_type &x)
void copyNeededFields(const dBRow_t &x)
const dBCheck_sequence & dBCheck() const
const dBPKey_optional & dBPKey() const
void setName(const name_type &x)
static void copyNeededFields(dBCheck_t const &source, Y &target)
const schema_optional & schema() const
::xml_schema::integer getDBColumnCount() const
const dbPort_type & getDbPort() const
::xsd::cxx::tree::sequence< dBRow_type > dBRow_sequence
Definition: NovaDatabase.h:912
void deserialize(const ::std::string &)
::xsd::cxx::tree::optional< dbPort_type > dbPort_optional
::xsd::cxx::tree::one< tolValue_type > tolValue_
Definition: NovaDatabase.h:378
dBCol_sequence dBCol_
Definition: NovaDatabase.h:767
dBColumn_sequence dBColumn_
const constraint_type & constraint() const
::xml_schema::string dbHost_type
Definition: NovaDatabase.h:972
::xml_schema::string creationDate_type
::xml_schema::string tableType_type
const tolerance_type & getTolerance() const
::xsd::cxx::tree::one< constraint_type > constraint_
Definition: NovaDatabase.h:694
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
static XMLDeserializationRegistry & getInstance()
const tolType_type & tolType() const
::std::string serialize() const
::xml_schema::boolean addInsertUser_type
dBCheck_sequence::const_iterator dBCheck_const_iterator
Definition: NovaDatabase.h:879
static void copyNeededFields(dBColumn_t const &source, dBColumn_t &target)
void setMaintainer(const maintainer_type &x)
virtual dBRow_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
const ignoreDB_optional & ignoreDB() const
const tolValue_type & tolValue() const
::xsd::cxx::tree::optional< addInsertUser_type > addInsertUser_optional
void setAddUpdateUser(const addUpdateUser_type &x)
bool hasCreationDate() const
const value_type & getValue() const
::std::unique_ptr< ::nova::database::dBTable > dBTable_(const ::std::string &uri,::xml_schema::flags f=0, const ::xml_schema::properties &p=::xml_schema::properties())
const tableType_type & getTableType() const
const addUpdateTime_optional & addUpdateTime() const
const dBColumn_type & getDBColumn(int index) const
std::ostream & operator<<(std::ostream &stream, const Column &col)
Definition: Column.h:134
addInsertTime_optional addInsertTime_
const hit & b
Definition: hits.cxx:21
void parse(::xsd::cxx::xml::dom::parser< char > &,::xml_schema::flags)
bool hasAddInsertUser() const
void setAddInsertTime(const addInsertTime_type &x)
TRandom3 r(0)
tolerance_optional tolerance_
Definition: NovaDatabase.h:622
const maintainer_optional & maintainer() const
colType_optional colType_
Definition: NovaDatabase.h:624
const addInsertUser_type & getAddInsertUser() const
void setAddUpdateTime(const addUpdateTime_type &x)
::xml_schema::string dbType_type
const dBColumn_sequence & dBColumn() const
::xsd::cxx::tree::type container
Definition: Database.h:112
dBCheck_sequence dBCheck_
::xml_schema::string fKeyColumn_type
Definition: NovaDatabase.h:560
void setAddInsertUser(const addInsertUser_type &x)
dBRow_type & getDBRowReference(int index)
::xml_schema::string value_type
Definition: NovaDatabase.h:473
::xml_schema::string tolType_type
Definition: NovaDatabase.h:319
dBUnique_type & getDBUniqueReference(int index)
const addUpdateTime_type & getAddUpdateTime() const
static void registerForDeserialization()
const creationDate_type & getCreationDate() const
Tolerance_t & operator=(const Tolerance_t &x)
virtual dBColumn_t * _clone(::xml_schema::flags f=0,::xml_schema::container *c=0) const
Float_t e
Definition: plot.C:35
long long integer
Definition: Database.h:136
const dbType_type & getDbType() const
static void copyNeededFields(dBTable const &source, dBTable &target)
Float_t X
Definition: plot.C:38
const dbHost_type & dbHost() const
void copyNeededFields(const Tolerance_t &x)
::xsd::cxx::tree::one< tolType_type > tolType_
Definition: NovaDatabase.h:379
::xsd::cxx::tree::one< dbHost_type > dbHost_
::xml_schema::boolean ignoreDB_type
::xsd::cxx::tree::one< dbName_type > dbName_
void setTolerance(const tolerance_type &x)
void setIgnoreDB(const ignoreDB_type &x)
::xsd::cxx::tree::optional< maintainer_type > maintainer_optional
const dBCheck_type & getDBCheck(int index) const
::xml_schema::string tableName_type
Definition: NovaDatabase.h:946
const addInsertTime_type & getAddInsertTime() const
::xml_schema::string maintainer_type
void setNull(const null_type &x)
bool hasAddUpdateUser() const
const tableName_type & getTableName() const