OpcUaCanOpen
CANopen OPC-UA server
CANOpenServerConfig.h
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 #ifndef C__USERS_VFILIMON_WORKSPACE_OPC_UA_ELMB_CONFIGURATION_CANOPEN_SERVER_CONFIG_H
35 #define C__USERS_VFILIMON_WORKSPACE_OPC_UA_ELMB_CONFIGURATION_CANOPEN_SERVER_CONFIG_H
36 
37 #ifndef XSD_USE_CHAR
38 #define XSD_USE_CHAR
39 #endif
40 
41 #ifndef XSD_CXX_TREE_USE_CHAR
42 #define XSD_CXX_TREE_USE_CHAR
43 #endif
44 
45 // Begin prologue.
46 //
47 //
48 // End prologue.
49 
50 #include <xsd/cxx/config.hxx>
51 
52 #if (XSD_INT_VERSION != 4000000L)
53 #error XSD runtime version mismatch
54 #endif
55 
56 #include <xsd/cxx/pre.hxx>
57 
58 #include <xsd/cxx/xml/char-utf8.hxx>
59 
60 #include <xsd/cxx/tree/exceptions.hxx>
61 #include <xsd/cxx/tree/elements.hxx>
62 #include <xsd/cxx/tree/types.hxx>
63 
64 #include <xsd/cxx/xml/error-handler.hxx>
65 
66 #include <xsd/cxx/xml/dom/auto-ptr.hxx>
67 
68 #include <xsd/cxx/tree/parsing.hxx>
69 #include <xsd/cxx/tree/parsing/byte.hxx>
70 #include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
71 #include <xsd/cxx/tree/parsing/short.hxx>
72 #include <xsd/cxx/tree/parsing/unsigned-short.hxx>
73 #include <xsd/cxx/tree/parsing/int.hxx>
74 #include <xsd/cxx/tree/parsing/unsigned-int.hxx>
75 #include <xsd/cxx/tree/parsing/long.hxx>
76 #include <xsd/cxx/tree/parsing/unsigned-long.hxx>
77 #include <xsd/cxx/tree/parsing/boolean.hxx>
78 #include <xsd/cxx/tree/parsing/float.hxx>
79 #include <xsd/cxx/tree/parsing/double.hxx>
80 #include <xsd/cxx/tree/parsing/decimal.hxx>
81 
82 namespace xml_schema
83 {
84  // anyType and anySimpleType.
85  //
86  typedef ::xsd::cxx::tree::type type;
87  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
88  typedef ::xsd::cxx::tree::type container;
89 
90  // 8-bit
91  //
92  typedef signed char byte;
93  typedef unsigned char unsigned_byte;
94 
95  // 16-bit
96  //
97  typedef short short_;
98  typedef unsigned short unsigned_short;
99 
100  // 32-bit
101  //
102  typedef int int_;
103  typedef unsigned int unsigned_int;
104 
105  // 64-bit
106  //
107  typedef long long long_;
108  typedef unsigned long long unsigned_long;
109 
110  // Supposed to be arbitrary-length integral types.
111  //
112  typedef long long integer;
113  typedef long long non_positive_integer;
114  typedef unsigned long long non_negative_integer;
115  typedef unsigned long long positive_integer;
116  typedef long long negative_integer;
117 
118  // Boolean.
119  //
120  typedef bool boolean;
121 
122  // Floating-point types.
123  //
124  typedef float float_;
125  typedef double double_;
126  typedef double decimal;
127 
128  // String types.
129  //
130  typedef ::xsd::cxx::tree::string< char, simple_type > string;
131  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
132  typedef ::xsd::cxx::tree::token< char, normalized_string > token;
133  typedef ::xsd::cxx::tree::name< char, token > name;
134  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
135  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
136  typedef ::xsd::cxx::tree::ncname< char, name > ncname;
137  typedef ::xsd::cxx::tree::language< char, token > language;
138 
139  // ID/IDREF.
140  //
141  typedef ::xsd::cxx::tree::id< char, ncname > id;
142  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
143  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;
144 
145  // URI.
146  //
147  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;
148 
149  // Qualified name.
150  //
151  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;
152 
153  // Binary.
154  //
155  typedef ::xsd::cxx::tree::buffer< char > buffer;
156  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
157  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;
158 
159  // Date/time.
160  //
161  typedef ::xsd::cxx::tree::time_zone time_zone;
162  typedef ::xsd::cxx::tree::date< char, simple_type > date;
163  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
164  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
165  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
166  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
167  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
168  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
169  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
170  typedef ::xsd::cxx::tree::time< char, simple_type > time;
171 
172  // Entity.
173  //
174  typedef ::xsd::cxx::tree::entity< char, ncname > entity;
175  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;
176 
177  typedef ::xsd::cxx::tree::content_order content_order;
178  // Flags and properties.
179  //
180  typedef ::xsd::cxx::tree::flags flags;
181  typedef ::xsd::cxx::tree::properties< char > properties;
182 
183  // Parsing/serialization diagnostics.
184  //
185  typedef ::xsd::cxx::tree::severity severity;
186  typedef ::xsd::cxx::tree::error< char > error;
187  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;
188 
189  // Exceptions.
190  //
191  typedef ::xsd::cxx::tree::exception< char > exception;
192  typedef ::xsd::cxx::tree::bounds< char > bounds;
193  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
194  typedef ::xsd::cxx::tree::parsing< char > parsing;
195  typedef ::xsd::cxx::tree::expected_element< char > expected_element;
196  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
197  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
198  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
199  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
200  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
201 
202  // Error handler callback interface.
203  //
204  typedef ::xsd::cxx::xml::error_handler< char > error_handler;
205 
206  // DOM interaction.
207  //
208  namespace dom
209  {
210  // Automatic pointer for DOMDocument.
211  //
212  using ::xsd::cxx::xml::dom::auto_ptr;
213 
214 #ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
215 #define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
216  // DOM user data key for back pointers to tree nodes.
217  //
218  const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
219 #endif
220  }
221 }
222 
223 // Forward declarations.
224 //
225 class NODE;
226 class CANBUS;
227 class CanOpenOpcServerConfig;
228 class SDO;
229 class PDO;
230 class NPDO;
231 class RPDO1;
232 class RPDO2;
233 class RPDO3;
234 class RPDO4;
235 class TPDO1;
236 class TPDO2;
237 class TPDO3;
238 class TPDO4;
239 class PDOITEM;
240 class SDOITEM_TYPE;
241 class SDOITEM_TYPE1;
242 class SDOITEM_TYPE2;
243 class SDOITEM_TYPE3;
244 class ITEM;
245 class REGEXPR;
246 class uatype;
247 class cobidrestriction;
248 class rtrvalue;
249 class accesssdo;
250 class nmtcommand;
251 class accesspdo;
252 class index_type;
253 class subindex_type;
254 class NODETYPE;
255 class name_type;
256 class regexpr_type;
257 class initialsettings;
258 class methodtype;
259 class SETTINGSTYPE;
260 class PROGRAM;
261 class nodeid;
262 class NODEGUARD;
263 class SYNC;
264 class speed;
265 
266 #include <memory> // ::std::auto_ptr
267 #include <limits> // std::numeric_limits
268 #include <algorithm> // std::binary_search
269 
270 #include <xsd/cxx/xml/char-utf8.hxx>
271 
272 #include <xsd/cxx/tree/exceptions.hxx>
273 #include <xsd/cxx/tree/elements.hxx>
274 #include <xsd/cxx/tree/containers.hxx>
275 #include <xsd/cxx/tree/list.hxx>
276 
277 #include <xsd/cxx/xml/dom/parsing-header.hxx>
278 
279 class NODE: public ::xml_schema::type
280 {
281  public:
282  // SDO
283  //
284  typedef ::SDO SDO_type;
285  typedef ::xsd::cxx::tree::sequence< SDO_type > SDO_sequence;
286  typedef SDO_sequence::iterator SDO_iterator;
287  typedef SDO_sequence::const_iterator SDO_const_iterator;
288  typedef ::xsd::cxx::tree::traits< SDO_type, char > SDO_traits;
289 
290  const SDO_sequence&
291  SDO () const;
292 
293  SDO_sequence&
294  SDO ();
295 
296  void
297  SDO (const SDO_sequence& s);
298 
299  // SDOITEM
300  //
301  typedef ::SDOITEM_TYPE2 SDOITEM_type;
302  typedef ::xsd::cxx::tree::sequence< SDOITEM_type > SDOITEM_sequence;
303  typedef SDOITEM_sequence::iterator SDOITEM_iterator;
304  typedef SDOITEM_sequence::const_iterator SDOITEM_const_iterator;
305  typedef ::xsd::cxx::tree::traits< SDOITEM_type, char > SDOITEM_traits;
306 
307  const SDOITEM_sequence&
308  SDOITEM () const;
309 
310  SDOITEM_sequence&
311  SDOITEM ();
312 
313  void
314  SDOITEM (const SDOITEM_sequence& s);
315 
316  // PDO
317  //
318  typedef ::PDO PDO_type;
319  typedef ::xsd::cxx::tree::sequence< PDO_type > PDO_sequence;
320  typedef PDO_sequence::iterator PDO_iterator;
321  typedef PDO_sequence::const_iterator PDO_const_iterator;
322  typedef ::xsd::cxx::tree::traits< PDO_type, char > PDO_traits;
323 
324  const PDO_sequence&
325  PDO () const;
326 
327  PDO_sequence&
328  PDO ();
329 
330  void
331  PDO (const PDO_sequence& s);
332 
333  // NPDO
334  //
335  typedef ::NPDO NPDO_type;
336  typedef ::xsd::cxx::tree::sequence< NPDO_type > NPDO_sequence;
337  typedef NPDO_sequence::iterator NPDO_iterator;
338  typedef NPDO_sequence::const_iterator NPDO_const_iterator;
339  typedef ::xsd::cxx::tree::traits< NPDO_type, char > NPDO_traits;
340 
341  const NPDO_sequence&
342  NPDO () const;
343 
344  NPDO_sequence&
345  NPDO ();
346 
347  void
348  NPDO (const NPDO_sequence& s);
349 
350  // RPDO1
351  //
352  typedef ::RPDO1 RPDO1_type;
353  typedef ::xsd::cxx::tree::sequence< RPDO1_type > RPDO1_sequence;
354  typedef RPDO1_sequence::iterator RPDO1_iterator;
355  typedef RPDO1_sequence::const_iterator RPDO1_const_iterator;
356  typedef ::xsd::cxx::tree::traits< RPDO1_type, char > RPDO1_traits;
357 
358  const RPDO1_sequence&
359  RPDO1 () const;
360 
361  RPDO1_sequence&
362  RPDO1 ();
363 
364  void
365  RPDO1 (const RPDO1_sequence& s);
366 
367  // RPDO2
368  //
369  typedef ::RPDO2 RPDO2_type;
370  typedef ::xsd::cxx::tree::sequence< RPDO2_type > RPDO2_sequence;
371  typedef RPDO2_sequence::iterator RPDO2_iterator;
372  typedef RPDO2_sequence::const_iterator RPDO2_const_iterator;
373  typedef ::xsd::cxx::tree::traits< RPDO2_type, char > RPDO2_traits;
374 
375  const RPDO2_sequence&
376  RPDO2 () const;
377 
378  RPDO2_sequence&
379  RPDO2 ();
380 
381  void
382  RPDO2 (const RPDO2_sequence& s);
383 
384  // RPDO3
385  //
386  typedef ::RPDO3 RPDO3_type;
387  typedef ::xsd::cxx::tree::sequence< RPDO3_type > RPDO3_sequence;
388  typedef RPDO3_sequence::iterator RPDO3_iterator;
389  typedef RPDO3_sequence::const_iterator RPDO3_const_iterator;
390  typedef ::xsd::cxx::tree::traits< RPDO3_type, char > RPDO3_traits;
391 
392  const RPDO3_sequence&
393  RPDO3 () const;
394 
395  RPDO3_sequence&
396  RPDO3 ();
397 
398  void
399  RPDO3 (const RPDO3_sequence& s);
400 
401  // RPDO4
402  //
403  typedef ::RPDO4 RPDO4_type;
404  typedef ::xsd::cxx::tree::sequence< RPDO4_type > RPDO4_sequence;
405  typedef RPDO4_sequence::iterator RPDO4_iterator;
406  typedef RPDO4_sequence::const_iterator RPDO4_const_iterator;
407  typedef ::xsd::cxx::tree::traits< RPDO4_type, char > RPDO4_traits;
408 
409  const RPDO4_sequence&
410  RPDO4 () const;
411 
412  RPDO4_sequence&
413  RPDO4 ();
414 
415  void
416  RPDO4 (const RPDO4_sequence& s);
417 
418  // TPDO1
419  //
420  typedef ::TPDO1 TPDO1_type;
421  typedef ::xsd::cxx::tree::sequence< TPDO1_type > TPDO1_sequence;
422  typedef TPDO1_sequence::iterator TPDO1_iterator;
423  typedef TPDO1_sequence::const_iterator TPDO1_const_iterator;
424  typedef ::xsd::cxx::tree::traits< TPDO1_type, char > TPDO1_traits;
425 
426  const TPDO1_sequence&
427  TPDO1 () const;
428 
429  TPDO1_sequence&
430  TPDO1 ();
431 
432  void
433  TPDO1 (const TPDO1_sequence& s);
434 
435  // TPDO2
436  //
437  typedef ::TPDO2 TPDO2_type;
438  typedef ::xsd::cxx::tree::sequence< TPDO2_type > TPDO2_sequence;
439  typedef TPDO2_sequence::iterator TPDO2_iterator;
440  typedef TPDO2_sequence::const_iterator TPDO2_const_iterator;
441  typedef ::xsd::cxx::tree::traits< TPDO2_type, char > TPDO2_traits;
442 
443  const TPDO2_sequence&
444  TPDO2 () const;
445 
446  TPDO2_sequence&
447  TPDO2 ();
448 
449  void
450  TPDO2 (const TPDO2_sequence& s);
451 
452  // TPDO3
453  //
454  typedef ::TPDO3 TPDO3_type;
455  typedef ::xsd::cxx::tree::sequence< TPDO3_type > TPDO3_sequence;
456  typedef TPDO3_sequence::iterator TPDO3_iterator;
457  typedef TPDO3_sequence::const_iterator TPDO3_const_iterator;
458  typedef ::xsd::cxx::tree::traits< TPDO3_type, char > TPDO3_traits;
459 
460  const TPDO3_sequence&
461  TPDO3 () const;
462 
463  TPDO3_sequence&
464  TPDO3 ();
465 
466  void
467  TPDO3 (const TPDO3_sequence& s);
468 
469  // TPDO4
470  //
471  typedef ::TPDO4 TPDO4_type;
472  typedef ::xsd::cxx::tree::sequence< TPDO4_type > TPDO4_sequence;
473  typedef TPDO4_sequence::iterator TPDO4_iterator;
474  typedef TPDO4_sequence::const_iterator TPDO4_const_iterator;
475  typedef ::xsd::cxx::tree::traits< TPDO4_type, char > TPDO4_traits;
476 
477  const TPDO4_sequence&
478  TPDO4 () const;
479 
480  TPDO4_sequence&
481  TPDO4 ();
482 
483  void
484  TPDO4 (const TPDO4_sequence& s);
485 
486  // PROGRAM
487  //
488  typedef ::PROGRAM PROGRAM_type;
489  typedef ::xsd::cxx::tree::sequence< PROGRAM_type > PROGRAM_sequence;
490  typedef PROGRAM_sequence::iterator PROGRAM_iterator;
491  typedef PROGRAM_sequence::const_iterator PROGRAM_const_iterator;
492  typedef ::xsd::cxx::tree::traits< PROGRAM_type, char > PROGRAM_traits;
493 
494  const PROGRAM_sequence&
495  PROGRAM () const;
496 
497  PROGRAM_sequence&
498  PROGRAM ();
499 
500  void
501  PROGRAM (const PROGRAM_sequence& s);
502 
503  // REGEXPR
504  //
505  typedef ::REGEXPR REGEXPR_type;
506  typedef ::xsd::cxx::tree::sequence< REGEXPR_type > REGEXPR_sequence;
507  typedef REGEXPR_sequence::iterator REGEXPR_iterator;
508  typedef REGEXPR_sequence::const_iterator REGEXPR_const_iterator;
509  typedef ::xsd::cxx::tree::traits< REGEXPR_type, char > REGEXPR_traits;
510 
511  const REGEXPR_sequence&
512  REGEXPR () const;
513 
514  REGEXPR_sequence&
515  REGEXPR ();
516 
517  void
518  REGEXPR (const REGEXPR_sequence& s);
519 
520  // ITEM
521  //
522  typedef ::ITEM ITEM_type;
523  typedef ::xsd::cxx::tree::sequence< ITEM_type > ITEM_sequence;
524  typedef ITEM_sequence::iterator ITEM_iterator;
525  typedef ITEM_sequence::const_iterator ITEM_const_iterator;
526  typedef ::xsd::cxx::tree::traits< ITEM_type, char > ITEM_traits;
527 
528  const ITEM_sequence&
529  ITEM () const;
530 
531  ITEM_sequence&
532  ITEM ();
533 
534  void
535  ITEM (const ITEM_sequence& s);
536 
537  // SET
538  //
539  typedef ::initialsettings SET_type;
540  typedef ::xsd::cxx::tree::sequence< SET_type > SET_sequence;
541  typedef SET_sequence::iterator SET_iterator;
542  typedef SET_sequence::const_iterator SET_const_iterator;
543  typedef ::xsd::cxx::tree::traits< SET_type, char > SET_traits;
544 
545  const SET_sequence&
546  SET () const;
547 
548  SET_sequence&
549  SET ();
550 
551  void
552  SET (const SET_sequence& s);
553 
554  // atStartup
555  //
556  typedef ::methodtype atStartup_type;
557  typedef ::xsd::cxx::tree::sequence< atStartup_type > atStartup_sequence;
558  typedef atStartup_sequence::iterator atStartup_iterator;
559  typedef atStartup_sequence::const_iterator atStartup_const_iterator;
560  typedef ::xsd::cxx::tree::traits< atStartup_type, char > atStartup_traits;
561 
562  const atStartup_sequence&
563  atStartup () const;
564 
565  atStartup_sequence&
566  atStartup ();
567 
568  void
569  atStartup (const atStartup_sequence& s);
570 
571  // name
572  //
573  typedef ::name_type name_type;
574  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
575 
576  const name_type&
577  name () const;
578 
579  name_type&
580  name ();
581 
582  void
583  name (const name_type& x);
584 
585  void
586  name (::std::auto_ptr< name_type > p);
587 
588  // nodeid
589  //
590  typedef ::nodeid nodeid_type;
591  typedef ::xsd::cxx::tree::traits< nodeid_type, char > nodeid_traits;
592 
593  const nodeid_type&
594  nodeid () const;
595 
596  nodeid_type&
597  nodeid ();
598 
599  void
600  nodeid (const nodeid_type& x);
601 
602  void
603  nodeid (::std::auto_ptr< nodeid_type > p);
604 
605  // type
606  //
607  typedef ::xml_schema::string type_type;
608  typedef ::xsd::cxx::tree::optional< type_type > type_optional;
609  typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
610 
611  const type_optional&
612  type () const;
613 
614  type_optional&
615  type ();
616 
617  void
618  type (const type_type& x);
619 
620  void
621  type (const type_optional& x);
622 
623  void
624  type (::std::auto_ptr< type_type > p);
625 
626  // nmt
627  //
628  typedef ::nmtcommand nmt_type;
629  typedef ::xsd::cxx::tree::optional< nmt_type > nmt_optional;
630  typedef ::xsd::cxx::tree::traits< nmt_type, char > nmt_traits;
631 
632  const nmt_optional&
633  nmt () const;
634 
635  nmt_optional&
636  nmt ();
637 
638  void
639  nmt (const nmt_type& x);
640 
641  void
642  nmt (const nmt_optional& x);
643 
644  void
645  nmt (::std::auto_ptr< nmt_type > p);
646 
647  // Constructors.
648  //
649  NODE (const name_type&,
650  const nodeid_type&);
651 
652  NODE (const ::xercesc::DOMElement& e,
653  ::xml_schema::flags f = 0,
654  ::xml_schema::container* c = 0);
655 
656  NODE (const NODE& x,
657  ::xml_schema::flags f = 0,
658  ::xml_schema::container* c = 0);
659 
660  virtual NODE*
661  _clone (::xml_schema::flags f = 0,
662  ::xml_schema::container* c = 0) const;
663 
664  NODE&
665  operator= (const NODE& x);
666 
667  virtual
668  ~NODE ();
669 
670  // Implementation.
671  //
672  protected:
673  void
674  parse (::xsd::cxx::xml::dom::parser< char >&,
675  ::xml_schema::flags);
676 
677  protected:
678  SDO_sequence SDO_;
679  SDOITEM_sequence SDOITEM_;
680  PDO_sequence PDO_;
681  NPDO_sequence NPDO_;
682  RPDO1_sequence RPDO1_;
683  RPDO2_sequence RPDO2_;
684  RPDO3_sequence RPDO3_;
685  RPDO4_sequence RPDO4_;
686  TPDO1_sequence TPDO1_;
687  TPDO2_sequence TPDO2_;
688  TPDO3_sequence TPDO3_;
689  TPDO4_sequence TPDO4_;
690  PROGRAM_sequence PROGRAM_;
691  REGEXPR_sequence REGEXPR_;
692  ITEM_sequence ITEM_;
693  SET_sequence SET_;
694  atStartup_sequence atStartup_;
695  ::xsd::cxx::tree::one< name_type > name_;
696  ::xsd::cxx::tree::one< nodeid_type > nodeid_;
697  type_optional type_;
698  nmt_optional nmt_;
699 };
700 
701 class CANBUS: public ::xml_schema::type
702 {
703  public:
704  // NODEGUARD
705  //
706  typedef ::NODEGUARD NODEGUARD_type;
707  typedef ::xsd::cxx::tree::optional< NODEGUARD_type > NODEGUARD_optional;
708  typedef ::xsd::cxx::tree::traits< NODEGUARD_type, char > NODEGUARD_traits;
709 
710  const NODEGUARD_optional&
711  NODEGUARD () const;
712 
713  NODEGUARD_optional&
714  NODEGUARD ();
715 
716  void
717  NODEGUARD (const NODEGUARD_type& x);
718 
719  void
720  NODEGUARD (const NODEGUARD_optional& x);
721 
722  void
723  NODEGUARD (::std::auto_ptr< NODEGUARD_type > p);
724 
725  // SYNC
726  //
727  typedef ::SYNC SYNC_type;
728  typedef ::xsd::cxx::tree::optional< SYNC_type > SYNC_optional;
729  typedef ::xsd::cxx::tree::traits< SYNC_type, char > SYNC_traits;
730 
731  const SYNC_optional&
732  SYNC () const;
733 
734  SYNC_optional&
735  SYNC ();
736 
737  void
738  SYNC (const SYNC_type& x);
739 
740  void
741  SYNC (const SYNC_optional& x);
742 
743  void
744  SYNC (::std::auto_ptr< SYNC_type > p);
745 
746  // NODE
747  //
748  typedef ::NODE NODE_type;
749  typedef ::xsd::cxx::tree::sequence< NODE_type > NODE_sequence;
750  typedef NODE_sequence::iterator NODE_iterator;
751  typedef NODE_sequence::const_iterator NODE_const_iterator;
752  typedef ::xsd::cxx::tree::traits< NODE_type, char > NODE_traits;
753 
754  const NODE_sequence&
755  NODE () const;
756 
757  NODE_sequence&
758  NODE ();
759 
760  void
761  NODE (const NODE_sequence& s);
762 
763  // REGEXPR
764  //
765  typedef ::REGEXPR REGEXPR_type;
766  typedef ::xsd::cxx::tree::sequence< REGEXPR_type > REGEXPR_sequence;
767  typedef REGEXPR_sequence::iterator REGEXPR_iterator;
768  typedef REGEXPR_sequence::const_iterator REGEXPR_const_iterator;
769  typedef ::xsd::cxx::tree::traits< REGEXPR_type, char > REGEXPR_traits;
770 
771  const REGEXPR_sequence&
772  REGEXPR () const;
773 
774  REGEXPR_sequence&
775  REGEXPR ();
776 
777  void
778  REGEXPR (const REGEXPR_sequence& s);
779 
780  // ITEM
781  //
782  typedef ::ITEM ITEM_type;
783  typedef ::xsd::cxx::tree::sequence< ITEM_type > ITEM_sequence;
784  typedef ITEM_sequence::iterator ITEM_iterator;
785  typedef ITEM_sequence::const_iterator ITEM_const_iterator;
786  typedef ::xsd::cxx::tree::traits< ITEM_type, char > ITEM_traits;
787 
788  const ITEM_sequence&
789  ITEM () const;
790 
791  ITEM_sequence&
792  ITEM ();
793 
794  void
795  ITEM (const ITEM_sequence& s);
796 
797  // SET
798  //
799  typedef ::initialsettings SET_type;
800  typedef ::xsd::cxx::tree::sequence< SET_type > SET_sequence;
801  typedef SET_sequence::iterator SET_iterator;
802  typedef SET_sequence::const_iterator SET_const_iterator;
803  typedef ::xsd::cxx::tree::traits< SET_type, char > SET_traits;
804 
805  const SET_sequence&
806  SET () const;
807 
808  SET_sequence&
809  SET ();
810 
811  void
812  SET (const SET_sequence& s);
813 
814  // atStartup
815  //
816  typedef ::methodtype atStartup_type;
817  typedef ::xsd::cxx::tree::sequence< atStartup_type > atStartup_sequence;
818  typedef atStartup_sequence::iterator atStartup_iterator;
819  typedef atStartup_sequence::const_iterator atStartup_const_iterator;
820  typedef ::xsd::cxx::tree::traits< atStartup_type, char > atStartup_traits;
821 
822  const atStartup_sequence&
823  atStartup () const;
824 
825  atStartup_sequence&
826  atStartup ();
827 
828  void
829  atStartup (const atStartup_sequence& s);
830 
831  // name
832  //
833  typedef ::name_type name_type;
834  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
835 
836  const name_type&
837  name () const;
838 
839  name_type&
840  name ();
841 
842  void
843  name (const name_type& x);
844 
845  void
846  name (::std::auto_ptr< name_type > p);
847 
848  // type
849  //
850  typedef ::xml_schema::string type_type;
851  typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
852 
853  const type_type&
854  type () const;
855 
856  type_type&
857  type ();
858 
859  void
860  type (const type_type& x);
861 
862  void
863  type (::std::auto_ptr< type_type > p);
864 
865  // port
866  //
867  typedef ::xml_schema::string port_type;
868  typedef ::xsd::cxx::tree::traits< port_type, char > port_traits;
869 
870  const port_type&
871  port () const;
872 
873  port_type&
874  port ();
875 
876  void
877  port (const port_type& x);
878 
879  void
880  port (::std::auto_ptr< port_type > p);
881 
882  // nmt
883  //
884  typedef ::nmtcommand nmt_type;
885  typedef ::xsd::cxx::tree::optional< nmt_type > nmt_optional;
886  typedef ::xsd::cxx::tree::traits< nmt_type, char > nmt_traits;
887 
888  const nmt_optional&
889  nmt () const;
890 
891  nmt_optional&
892  nmt ();
893 
894  void
895  nmt (const nmt_type& x);
896 
897  void
898  nmt (const nmt_optional& x);
899 
900  void
901  nmt (::std::auto_ptr< nmt_type > p);
902 
903  // speed
904  //
905  typedef ::speed speed_type;
906  typedef ::xsd::cxx::tree::traits< speed_type, char > speed_traits;
907 
908  const speed_type&
909  speed () const;
910 
911  speed_type&
912  speed ();
913 
914  void
915  speed (const speed_type& x);
916 
917  void
918  speed (::std::auto_ptr< speed_type > p);
919 
920  // Constructors.
921  //
922  CANBUS (const name_type&,
923  const type_type&,
924  const port_type&,
925  const speed_type&);
926 
927  CANBUS (const ::xercesc::DOMElement& e,
928  ::xml_schema::flags f = 0,
929  ::xml_schema::container* c = 0);
930 
931  CANBUS (const CANBUS& x,
932  ::xml_schema::flags f = 0,
933  ::xml_schema::container* c = 0);
934 
935  virtual CANBUS*
936  _clone (::xml_schema::flags f = 0,
937  ::xml_schema::container* c = 0) const;
938 
939  CANBUS&
940  operator= (const CANBUS& x);
941 
942  virtual
943  ~CANBUS ();
944 
945  // Implementation.
946  //
947  protected:
948  void
949  parse (::xsd::cxx::xml::dom::parser< char >&,
950  ::xml_schema::flags);
951 
952  protected:
953  NODEGUARD_optional NODEGUARD_;
954  SYNC_optional SYNC_;
955  NODE_sequence NODE_;
956  REGEXPR_sequence REGEXPR_;
957  ITEM_sequence ITEM_;
958  SET_sequence SET_;
959  atStartup_sequence atStartup_;
960  ::xsd::cxx::tree::one< name_type > name_;
961  ::xsd::cxx::tree::one< type_type > type_;
962  ::xsd::cxx::tree::one< port_type > port_;
963  nmt_optional nmt_;
964  ::xsd::cxx::tree::one< speed_type > speed_;
965 };
966 
967 class CanOpenOpcServerConfig: public ::xml_schema::type
968 {
969  public:
970  // NODETYPE
971  //
972  typedef ::NODETYPE NODETYPE_type;
973  typedef ::xsd::cxx::tree::sequence< NODETYPE_type > NODETYPE_sequence;
974  typedef NODETYPE_sequence::iterator NODETYPE_iterator;
975  typedef NODETYPE_sequence::const_iterator NODETYPE_const_iterator;
976  typedef ::xsd::cxx::tree::traits< NODETYPE_type, char > NODETYPE_traits;
977 
978  const NODETYPE_sequence&
979  NODETYPE () const;
980 
981  NODETYPE_sequence&
982  NODETYPE ();
983 
984  void
985  NODETYPE (const NODETYPE_sequence& s);
986 
987  // CANBUS
988  //
989  typedef ::CANBUS CANBUS_type;
990  typedef ::xsd::cxx::tree::sequence< CANBUS_type > CANBUS_sequence;
991  typedef CANBUS_sequence::iterator CANBUS_iterator;
992  typedef CANBUS_sequence::const_iterator CANBUS_const_iterator;
993  typedef ::xsd::cxx::tree::traits< CANBUS_type, char > CANBUS_traits;
994 
995  const CANBUS_sequence&
996  CANBUS () const;
997 
998  CANBUS_sequence&
999  CANBUS ();
1000 
1001  void
1002  CANBUS (const CANBUS_sequence& s);
1003 
1004  // REGEXPR
1005  //
1006  typedef ::REGEXPR REGEXPR_type;
1007  typedef ::xsd::cxx::tree::sequence< REGEXPR_type > REGEXPR_sequence;
1008  typedef REGEXPR_sequence::iterator REGEXPR_iterator;
1009  typedef REGEXPR_sequence::const_iterator REGEXPR_const_iterator;
1010  typedef ::xsd::cxx::tree::traits< REGEXPR_type, char > REGEXPR_traits;
1011 
1012  const REGEXPR_sequence&
1013  REGEXPR () const;
1014 
1015  REGEXPR_sequence&
1016  REGEXPR ();
1017 
1018  void
1019  REGEXPR (const REGEXPR_sequence& s);
1020 
1021  // ITEM
1022  //
1023  typedef ::ITEM ITEM_type;
1024  typedef ::xsd::cxx::tree::sequence< ITEM_type > ITEM_sequence;
1025  typedef ITEM_sequence::iterator ITEM_iterator;
1026  typedef ITEM_sequence::const_iterator ITEM_const_iterator;
1027  typedef ::xsd::cxx::tree::traits< ITEM_type, char > ITEM_traits;
1028 
1029  const ITEM_sequence&
1030  ITEM () const;
1031 
1032  ITEM_sequence&
1033  ITEM ();
1034 
1035  void
1036  ITEM (const ITEM_sequence& s);
1037 
1038  // SET
1039  //
1040  typedef ::initialsettings SET_type;
1041  typedef ::xsd::cxx::tree::sequence< SET_type > SET_sequence;
1042  typedef SET_sequence::iterator SET_iterator;
1043  typedef SET_sequence::const_iterator SET_const_iterator;
1044  typedef ::xsd::cxx::tree::traits< SET_type, char > SET_traits;
1045 
1046  const SET_sequence&
1047  SET () const;
1048 
1049  SET_sequence&
1050  SET ();
1051 
1052  void
1053  SET (const SET_sequence& s);
1054 
1055  // atStartup
1056  //
1057  typedef ::methodtype atStartup_type;
1058  typedef ::xsd::cxx::tree::sequence< atStartup_type > atStartup_sequence;
1059  typedef atStartup_sequence::iterator atStartup_iterator;
1060  typedef atStartup_sequence::const_iterator atStartup_const_iterator;
1061  typedef ::xsd::cxx::tree::traits< atStartup_type, char > atStartup_traits;
1062 
1063  const atStartup_sequence&
1064  atStartup () const;
1065 
1066  atStartup_sequence&
1067  atStartup ();
1068 
1069  void
1070  atStartup (const atStartup_sequence& s);
1071 
1072  // SETTINGS
1073  //
1074  typedef ::SETTINGSTYPE SETTINGS_type;
1075  typedef ::xsd::cxx::tree::optional< SETTINGS_type > SETTINGS_optional;
1076  typedef ::xsd::cxx::tree::traits< SETTINGS_type, char > SETTINGS_traits;
1077 
1078  const SETTINGS_optional&
1079  SETTINGS () const;
1080 
1081  SETTINGS_optional&
1082  SETTINGS ();
1083 
1084  void
1085  SETTINGS (const SETTINGS_type& x);
1086 
1087  void
1088  SETTINGS (const SETTINGS_optional& x);
1089 
1090  void
1091  SETTINGS (::std::auto_ptr< SETTINGS_type > p);
1092 
1093  // Constructors.
1094  //
1095  CanOpenOpcServerConfig ();
1096 
1097  CanOpenOpcServerConfig (const ::xercesc::DOMElement& e,
1098  ::xml_schema::flags f = 0,
1099  ::xml_schema::container* c = 0);
1100 
1101  CanOpenOpcServerConfig (const CanOpenOpcServerConfig& x,
1102  ::xml_schema::flags f = 0,
1103  ::xml_schema::container* c = 0);
1104 
1105  virtual CanOpenOpcServerConfig*
1106  _clone (::xml_schema::flags f = 0,
1107  ::xml_schema::container* c = 0) const;
1108 
1109  CanOpenOpcServerConfig&
1110  operator= (const CanOpenOpcServerConfig& x);
1111 
1112  virtual
1113  ~CanOpenOpcServerConfig ();
1114 
1115  // Implementation.
1116  //
1117  protected:
1118  void
1119  parse (::xsd::cxx::xml::dom::parser< char >&,
1120  ::xml_schema::flags);
1121 
1122  protected:
1123  NODETYPE_sequence NODETYPE_;
1124  CANBUS_sequence CANBUS_;
1125  REGEXPR_sequence REGEXPR_;
1126  ITEM_sequence ITEM_;
1127  SET_sequence SET_;
1128  atStartup_sequence atStartup_;
1129  SETTINGS_optional SETTINGS_;
1130 };
1131 
1132 class SDO: public ::xml_schema::type
1133 {
1134  public:
1135  // SDOITEM
1136  //
1137  typedef ::SDOITEM_TYPE1 SDOITEM_type;
1138  typedef ::xsd::cxx::tree::sequence< SDOITEM_type > SDOITEM_sequence;
1139  typedef SDOITEM_sequence::iterator SDOITEM_iterator;
1140  typedef SDOITEM_sequence::const_iterator SDOITEM_const_iterator;
1141  typedef ::xsd::cxx::tree::traits< SDOITEM_type, char > SDOITEM_traits;
1142 
1143  const SDOITEM_sequence&
1144  SDOITEM () const;
1145 
1146  SDOITEM_sequence&
1147  SDOITEM ();
1148 
1149  void
1150  SDOITEM (const SDOITEM_sequence& s);
1151 
1152  // SDOITEMARRAY
1153  //
1154  typedef ::SDOITEM_TYPE3 SDOITEMARRAY_type;
1155  typedef ::xsd::cxx::tree::optional< SDOITEMARRAY_type > SDOITEMARRAY_optional;
1156  typedef ::xsd::cxx::tree::traits< SDOITEMARRAY_type, char > SDOITEMARRAY_traits;
1157 
1158  const SDOITEMARRAY_optional&
1159  SDOITEMARRAY () const;
1160 
1161  SDOITEMARRAY_optional&
1162  SDOITEMARRAY ();
1163 
1164  void
1165  SDOITEMARRAY (const SDOITEMARRAY_type& x);
1166 
1167  void
1168  SDOITEMARRAY (const SDOITEMARRAY_optional& x);
1169 
1170  void
1171  SDOITEMARRAY (::std::auto_ptr< SDOITEMARRAY_type > p);
1172 
1173  // name
1174  //
1175  typedef ::name_type name_type;
1176  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
1177 
1178  const name_type&
1179  name () const;
1180 
1181  name_type&
1182  name ();
1183 
1184  void
1185  name (const name_type& x);
1186 
1187  void
1188  name (::std::auto_ptr< name_type > p);
1189 
1190  // index
1191  //
1192  typedef ::index_type index_type;
1193  typedef ::xsd::cxx::tree::traits< index_type, char > index_traits;
1194 
1195  const index_type&
1196  index () const;
1197 
1198  index_type&
1199  index ();
1200 
1201  void
1202  index (const index_type& x);
1203 
1204  void
1205  index (::std::auto_ptr< index_type > p);
1206 
1207  // Constructors.
1208  //
1209  SDO (const name_type&,
1210  const index_type&);
1211 
1212  SDO (const ::xercesc::DOMElement& e,
1213  ::xml_schema::flags f = 0,
1214  ::xml_schema::container* c = 0);
1215 
1216  SDO (const SDO& x,
1217  ::xml_schema::flags f = 0,
1218  ::xml_schema::container* c = 0);
1219 
1220  virtual SDO*
1221  _clone (::xml_schema::flags f = 0,
1222  ::xml_schema::container* c = 0) const;
1223 
1224  SDO&
1225  operator= (const SDO& x);
1226 
1227  virtual
1228  ~SDO ();
1229 
1230  // Implementation.
1231  //
1232  protected:
1233  void
1234  parse (::xsd::cxx::xml::dom::parser< char >&,
1235  ::xml_schema::flags);
1236 
1237  protected:
1238  SDOITEM_sequence SDOITEM_;
1239  SDOITEMARRAY_optional SDOITEMARRAY_;
1240  ::xsd::cxx::tree::one< name_type > name_;
1241  ::xsd::cxx::tree::one< index_type > index_;
1242 };
1243 
1244 class PDO: public ::xml_schema::type
1245 {
1246  public:
1247  // PDOITEM
1248  //
1249  typedef ::PDOITEM PDOITEM_type;
1250  typedef ::xsd::cxx::tree::sequence< PDOITEM_type > PDOITEM_sequence;
1251  typedef PDOITEM_sequence::iterator PDOITEM_iterator;
1252  typedef PDOITEM_sequence::const_iterator PDOITEM_const_iterator;
1253  typedef ::xsd::cxx::tree::traits< PDOITEM_type, char > PDOITEM_traits;
1254 
1255  const PDOITEM_sequence&
1256  PDOITEM () const;
1257 
1258  PDOITEM_sequence&
1259  PDOITEM ();
1260 
1261  void
1262  PDOITEM (const PDOITEM_sequence& s);
1263 
1264  // name
1265  //
1266  typedef ::name_type name_type;
1267  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
1268 
1269  const name_type&
1270  name () const;
1271 
1272  name_type&
1273  name ();
1274 
1275  void
1276  name (const name_type& x);
1277 
1278  void
1279  name (::std::auto_ptr< name_type > p);
1280 
1281  // cobid
1282  //
1283  typedef ::cobidrestriction cobid_type;
1284  typedef ::xsd::cxx::tree::traits< cobid_type, char > cobid_traits;
1285 
1286  const cobid_type&
1287  cobid () const;
1288 
1289  cobid_type&
1290  cobid ();
1291 
1292  void
1293  cobid (const cobid_type& x);
1294 
1295  void
1296  cobid (::std::auto_ptr< cobid_type > p);
1297 
1298  // access
1299  //
1300  typedef ::accesspdo access_type;
1301  typedef ::xsd::cxx::tree::traits< access_type, char > access_traits;
1302 
1303  const access_type&
1304  access () const;
1305 
1306  access_type&
1307  access ();
1308 
1309  void
1310  access (const access_type& x);
1311 
1312  void
1313  access (::std::auto_ptr< access_type > p);
1314 
1315  // numch
1316  //
1317  typedef ::xml_schema::unsigned_byte numch_type;
1318  typedef ::xsd::cxx::tree::traits< numch_type, char > numch_traits;
1319 
1320  const numch_type&
1321  numch () const;
1322 
1323  numch_type&
1324  numch ();
1325 
1326  void
1327  numch (const numch_type& x);
1328 
1329  static numch_type
1330  numch_default_value ();
1331 
1332  // rtr
1333  //
1334  typedef ::rtrvalue rtr_type;
1335  typedef ::xsd::cxx::tree::traits< rtr_type, char > rtr_traits;
1336 
1337  const rtr_type&
1338  rtr () const;
1339 
1340  rtr_type&
1341  rtr ();
1342 
1343  void
1344  rtr (const rtr_type& x);
1345 
1346  void
1347  rtr (::std::auto_ptr< rtr_type > p);
1348 
1349  static const rtr_type&
1350  rtr_default_value ();
1351 
1352  // Constructors.
1353  //
1354  PDO (const name_type&,
1355  const cobid_type&,
1356  const access_type&);
1357 
1358  PDO (const ::xercesc::DOMElement& e,
1359  ::xml_schema::flags f = 0,
1360  ::xml_schema::container* c = 0);
1361 
1362  PDO (const PDO& x,
1363  ::xml_schema::flags f = 0,
1364  ::xml_schema::container* c = 0);
1365 
1366  virtual PDO*
1367  _clone (::xml_schema::flags f = 0,
1368  ::xml_schema::container* c = 0) const;
1369 
1370  PDO&
1371  operator= (const PDO& x);
1372 
1373  virtual
1374  ~PDO ();
1375 
1376  // Implementation.
1377  //
1378  protected:
1379  void
1380  parse (::xsd::cxx::xml::dom::parser< char >&,
1381  ::xml_schema::flags);
1382 
1383  protected:
1384  PDOITEM_sequence PDOITEM_;
1385  ::xsd::cxx::tree::one< name_type > name_;
1386  ::xsd::cxx::tree::one< cobid_type > cobid_;
1387  ::xsd::cxx::tree::one< access_type > access_;
1388  ::xsd::cxx::tree::one< numch_type > numch_;
1389  ::xsd::cxx::tree::one< rtr_type > rtr_;
1390  static const rtr_type rtr_default_value_;
1391 };
1392 
1393 class NPDO: public ::PDO
1394 {
1395  public:
1396  // Constructors.
1397  //
1398  NPDO (const name_type&,
1399  const cobid_type&,
1400  const access_type&);
1401 
1402  NPDO (const ::xercesc::DOMElement& e,
1403  ::xml_schema::flags f = 0,
1404  ::xml_schema::container* c = 0);
1405 
1406  NPDO (const NPDO& x,
1407  ::xml_schema::flags f = 0,
1408  ::xml_schema::container* c = 0);
1409 
1410  virtual NPDO*
1411  _clone (::xml_schema::flags f = 0,
1412  ::xml_schema::container* c = 0) const;
1413 
1414  virtual
1415  ~NPDO ();
1416 };
1417 
1418 class RPDO1: public ::PDO
1419 {
1420  public:
1421  // Constructors.
1422  //
1423  RPDO1 (const name_type&,
1424  const cobid_type&,
1425  const access_type&);
1426 
1427  RPDO1 (const ::xercesc::DOMElement& e,
1428  ::xml_schema::flags f = 0,
1429  ::xml_schema::container* c = 0);
1430 
1431  RPDO1 (const RPDO1& x,
1432  ::xml_schema::flags f = 0,
1433  ::xml_schema::container* c = 0);
1434 
1435  virtual RPDO1*
1436  _clone (::xml_schema::flags f = 0,
1437  ::xml_schema::container* c = 0) const;
1438 
1439  virtual
1440  ~RPDO1 ();
1441 };
1442 
1443 class RPDO2: public ::PDO
1444 {
1445  public:
1446  // Constructors.
1447  //
1448  RPDO2 (const name_type&,
1449  const cobid_type&,
1450  const access_type&);
1451 
1452  RPDO2 (const ::xercesc::DOMElement& e,
1453  ::xml_schema::flags f = 0,
1454  ::xml_schema::container* c = 0);
1455 
1456  RPDO2 (const RPDO2& x,
1457  ::xml_schema::flags f = 0,
1458  ::xml_schema::container* c = 0);
1459 
1460  virtual RPDO2*
1461  _clone (::xml_schema::flags f = 0,
1462  ::xml_schema::container* c = 0) const;
1463 
1464  virtual
1465  ~RPDO2 ();
1466 };
1467 
1468 class RPDO3: public ::PDO
1469 {
1470  public:
1471  // Constructors.
1472  //
1473  RPDO3 (const name_type&,
1474  const cobid_type&,
1475  const access_type&);
1476 
1477  RPDO3 (const ::xercesc::DOMElement& e,
1478  ::xml_schema::flags f = 0,
1479  ::xml_schema::container* c = 0);
1480 
1481  RPDO3 (const RPDO3& x,
1482  ::xml_schema::flags f = 0,
1483  ::xml_schema::container* c = 0);
1484 
1485  virtual RPDO3*
1486  _clone (::xml_schema::flags f = 0,
1487  ::xml_schema::container* c = 0) const;
1488 
1489  virtual
1490  ~RPDO3 ();
1491 };
1492 
1493 class RPDO4: public ::PDO
1494 {
1495  public:
1496  // Constructors.
1497  //
1498  RPDO4 (const name_type&,
1499  const cobid_type&,
1500  const access_type&);
1501 
1502  RPDO4 (const ::xercesc::DOMElement& e,
1503  ::xml_schema::flags f = 0,
1504  ::xml_schema::container* c = 0);
1505 
1506  RPDO4 (const RPDO4& x,
1507  ::xml_schema::flags f = 0,
1508  ::xml_schema::container* c = 0);
1509 
1510  virtual RPDO4*
1511  _clone (::xml_schema::flags f = 0,
1512  ::xml_schema::container* c = 0) const;
1513 
1514  virtual
1515  ~RPDO4 ();
1516 };
1517 
1518 class TPDO1: public ::PDO
1519 {
1520  public:
1521  // Constructors.
1522  //
1523  TPDO1 (const name_type&,
1524  const cobid_type&,
1525  const access_type&);
1526 
1527  TPDO1 (const ::xercesc::DOMElement& e,
1528  ::xml_schema::flags f = 0,
1529  ::xml_schema::container* c = 0);
1530 
1531  TPDO1 (const TPDO1& x,
1532  ::xml_schema::flags f = 0,
1533  ::xml_schema::container* c = 0);
1534 
1535  virtual TPDO1*
1536  _clone (::xml_schema::flags f = 0,
1537  ::xml_schema::container* c = 0) const;
1538 
1539  virtual
1540  ~TPDO1 ();
1541 };
1542 
1543 class TPDO2: public ::PDO
1544 {
1545  public:
1546  // Constructors.
1547  //
1548  TPDO2 (const name_type&,
1549  const cobid_type&,
1550  const access_type&);
1551 
1552  TPDO2 (const ::xercesc::DOMElement& e,
1553  ::xml_schema::flags f = 0,
1554  ::xml_schema::container* c = 0);
1555 
1556  TPDO2 (const TPDO2& x,
1557  ::xml_schema::flags f = 0,
1558  ::xml_schema::container* c = 0);
1559 
1560  virtual TPDO2*
1561  _clone (::xml_schema::flags f = 0,
1562  ::xml_schema::container* c = 0) const;
1563 
1564  virtual
1565  ~TPDO2 ();
1566 };
1567 
1568 class TPDO3: public ::PDO
1569 {
1570  public:
1571  // Constructors.
1572  //
1573  TPDO3 (const name_type&,
1574  const cobid_type&,
1575  const access_type&);
1576 
1577  TPDO3 (const ::xercesc::DOMElement& e,
1578  ::xml_schema::flags f = 0,
1579  ::xml_schema::container* c = 0);
1580 
1581  TPDO3 (const TPDO3& x,
1582  ::xml_schema::flags f = 0,
1583  ::xml_schema::container* c = 0);
1584 
1585  virtual TPDO3*
1586  _clone (::xml_schema::flags f = 0,
1587  ::xml_schema::container* c = 0) const;
1588 
1589  virtual
1590  ~TPDO3 ();
1591 };
1592 
1593 class TPDO4: public ::PDO
1594 {
1595  public:
1596  // Constructors.
1597  //
1598  TPDO4 (const name_type&,
1599  const cobid_type&,
1600  const access_type&);
1601 
1602  TPDO4 (const ::xercesc::DOMElement& e,
1603  ::xml_schema::flags f = 0,
1604  ::xml_schema::container* c = 0);
1605 
1606  TPDO4 (const TPDO4& x,
1607  ::xml_schema::flags f = 0,
1608  ::xml_schema::container* c = 0);
1609 
1610  virtual TPDO4*
1611  _clone (::xml_schema::flags f = 0,
1612  ::xml_schema::container* c = 0) const;
1613 
1614  virtual
1615  ~TPDO4 ();
1616 };
1617 
1618 class PDOITEM: public ::xml_schema::type
1619 {
1620  public:
1621  // name
1622  //
1623  typedef ::name_type name_type;
1624  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
1625 
1626  const name_type&
1627  name () const;
1628 
1629  name_type&
1630  name ();
1631 
1632  void
1633  name (const name_type& x);
1634 
1635  void
1636  name (::std::auto_ptr< name_type > p);
1637 
1638  // byteindex
1639  //
1640  typedef ::xml_schema::int_ byteindex_type;
1641  typedef ::xsd::cxx::tree::traits< byteindex_type, char > byteindex_traits;
1642 
1643  const byteindex_type&
1644  byteindex () const;
1645 
1646  byteindex_type&
1647  byteindex ();
1648 
1649  void
1650  byteindex (const byteindex_type& x);
1651 
1652  // bit
1653  //
1654  typedef ::xml_schema::byte bit_type;
1655  typedef ::xsd::cxx::tree::traits< bit_type, char > bit_traits;
1656 
1657  const bit_type&
1658  bit () const;
1659 
1660  bit_type&
1661  bit ();
1662 
1663  void
1664  bit (const bit_type& x);
1665 
1666  static bit_type
1667  bit_default_value ();
1668 
1669  // type
1670  //
1671  typedef ::uatype type_type;
1672  typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
1673 
1674  const type_type&
1675  type () const;
1676 
1677  type_type&
1678  type ();
1679 
1680  void
1681  type (const type_type& x);
1682 
1683  void
1684  type (::std::auto_ptr< type_type > p);
1685 
1686  // Constructors.
1687  //
1688  PDOITEM (const name_type&,
1689  const byteindex_type&,
1690  const type_type&);
1691 
1692  PDOITEM (const ::xercesc::DOMElement& e,
1693  ::xml_schema::flags f = 0,
1694  ::xml_schema::container* c = 0);
1695 
1696  PDOITEM (const PDOITEM& x,
1697  ::xml_schema::flags f = 0,
1698  ::xml_schema::container* c = 0);
1699 
1700  virtual PDOITEM*
1701  _clone (::xml_schema::flags f = 0,
1702  ::xml_schema::container* c = 0) const;
1703 
1704  PDOITEM&
1705  operator= (const PDOITEM& x);
1706 
1707  virtual
1708  ~PDOITEM ();
1709 
1710  // Implementation.
1711  //
1712  protected:
1713  void
1714  parse (::xsd::cxx::xml::dom::parser< char >&,
1715  ::xml_schema::flags);
1716 
1717  protected:
1718  ::xsd::cxx::tree::one< name_type > name_;
1719  ::xsd::cxx::tree::one< byteindex_type > byteindex_;
1720  ::xsd::cxx::tree::one< bit_type > bit_;
1721  ::xsd::cxx::tree::one< type_type > type_;
1722 };
1723 
1724 class SDOITEM_TYPE: public ::xml_schema::type
1725 {
1726  public:
1727  // name
1728  //
1729  typedef ::name_type name_type;
1730  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
1731 
1732  const name_type&
1733  name () const;
1734 
1735  name_type&
1736  name ();
1737 
1738  void
1739  name (const name_type& x);
1740 
1741  void
1742  name (::std::auto_ptr< name_type > p);
1743 
1744  // type
1745  //
1746  typedef ::uatype type_type;
1747  typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
1748 
1749  const type_type&
1750  type () const;
1751 
1752  type_type&
1753  type ();
1754 
1755  void
1756  type (const type_type& x);
1757 
1758  void
1759  type (::std::auto_ptr< type_type > p);
1760 
1761  // access
1762  //
1763  typedef ::accesssdo access_type;
1764  typedef ::xsd::cxx::tree::traits< access_type, char > access_traits;
1765 
1766  const access_type&
1767  access () const;
1768 
1769  access_type&
1770  access ();
1771 
1772  void
1773  access (const access_type& x);
1774 
1775  void
1776  access (::std::auto_ptr< access_type > p);
1777 
1778  // timeout
1779  //
1780  typedef ::xml_schema::unsigned_int timeout_type;
1781  typedef ::xsd::cxx::tree::traits< timeout_type, char > timeout_traits;
1782 
1783  const timeout_type&
1784  timeout () const;
1785 
1786  timeout_type&
1787  timeout ();
1788 
1789  void
1790  timeout (const timeout_type& x);
1791 
1792  static timeout_type
1793  timeout_default_value ();
1794 
1795  // Constructors.
1796  //
1797  SDOITEM_TYPE (const name_type&,
1798  const type_type&,
1799  const access_type&);
1800 
1801  SDOITEM_TYPE (const ::xercesc::DOMElement& e,
1802  ::xml_schema::flags f = 0,
1803  ::xml_schema::container* c = 0);
1804 
1805  SDOITEM_TYPE (const SDOITEM_TYPE& x,
1806  ::xml_schema::flags f = 0,
1807  ::xml_schema::container* c = 0);
1808 
1809  virtual SDOITEM_TYPE*
1810  _clone (::xml_schema::flags f = 0,
1811  ::xml_schema::container* c = 0) const;
1812 
1813  SDOITEM_TYPE&
1814  operator= (const SDOITEM_TYPE& x);
1815 
1816  virtual
1817  ~SDOITEM_TYPE ();
1818 
1819  // Implementation.
1820  //
1821  protected:
1822  void
1823  parse (::xsd::cxx::xml::dom::parser< char >&,
1824  ::xml_schema::flags);
1825 
1826  protected:
1827  ::xsd::cxx::tree::one< name_type > name_;
1828  ::xsd::cxx::tree::one< type_type > type_;
1829  ::xsd::cxx::tree::one< access_type > access_;
1830  ::xsd::cxx::tree::one< timeout_type > timeout_;
1831 };
1832 
1833 class SDOITEM_TYPE1: public ::SDOITEM_TYPE
1834 {
1835  public:
1836  // subindex
1837  //
1838  typedef ::subindex_type subindex_type;
1839  typedef ::xsd::cxx::tree::traits< subindex_type, char > subindex_traits;
1840 
1841  const subindex_type&
1842  subindex () const;
1843 
1844  subindex_type&
1845  subindex ();
1846 
1847  void
1848  subindex (const subindex_type& x);
1849 
1850  void
1851  subindex (::std::auto_ptr< subindex_type > p);
1852 
1853  // Constructors.
1854  //
1855  SDOITEM_TYPE1 (const name_type&,
1856  const type_type&,
1857  const access_type&,
1858  const subindex_type&);
1859 
1860  SDOITEM_TYPE1 (const ::xercesc::DOMElement& e,
1861  ::xml_schema::flags f = 0,
1862  ::xml_schema::container* c = 0);
1863 
1864  SDOITEM_TYPE1 (const SDOITEM_TYPE1& x,
1865  ::xml_schema::flags f = 0,
1866  ::xml_schema::container* c = 0);
1867 
1868  virtual SDOITEM_TYPE1*
1869  _clone (::xml_schema::flags f = 0,
1870  ::xml_schema::container* c = 0) const;
1871 
1872  SDOITEM_TYPE1&
1873  operator= (const SDOITEM_TYPE1& x);
1874 
1875  virtual
1876  ~SDOITEM_TYPE1 ();
1877 
1878  // Implementation.
1879  //
1880  protected:
1881  void
1882  parse (::xsd::cxx::xml::dom::parser< char >&,
1883  ::xml_schema::flags);
1884 
1885  protected:
1886  ::xsd::cxx::tree::one< subindex_type > subindex_;
1887 };
1888 
1889 class SDOITEM_TYPE2: public ::SDOITEM_TYPE
1890 {
1891  public:
1892  // index
1893  //
1894  typedef ::index_type index_type;
1895  typedef ::xsd::cxx::tree::traits< index_type, char > index_traits;
1896 
1897  const index_type&
1898  index () const;
1899 
1900  index_type&
1901  index ();
1902 
1903  void
1904  index (const index_type& x);
1905 
1906  void
1907  index (::std::auto_ptr< index_type > p);
1908 
1909  // subindex
1910  //
1911  typedef ::subindex_type subindex_type;
1912  typedef ::xsd::cxx::tree::traits< subindex_type, char > subindex_traits;
1913 
1914  const subindex_type&
1915  subindex () const;
1916 
1917  subindex_type&
1918  subindex ();
1919 
1920  void
1921  subindex (const subindex_type& x);
1922 
1923  void
1924  subindex (::std::auto_ptr< subindex_type > p);
1925 
1926  // Constructors.
1927  //
1928  SDOITEM_TYPE2 (const name_type&,
1929  const type_type&,
1930  const access_type&,
1931  const index_type&,
1932  const subindex_type&);
1933 
1934  SDOITEM_TYPE2 (const ::xercesc::DOMElement& e,
1935  ::xml_schema::flags f = 0,
1936  ::xml_schema::container* c = 0);
1937 
1938  SDOITEM_TYPE2 (const SDOITEM_TYPE2& x,
1939  ::xml_schema::flags f = 0,
1940  ::xml_schema::container* c = 0);
1941 
1942  virtual SDOITEM_TYPE2*
1943  _clone (::xml_schema::flags f = 0,
1944  ::xml_schema::container* c = 0) const;
1945 
1946  SDOITEM_TYPE2&
1947  operator= (const SDOITEM_TYPE2& x);
1948 
1949  virtual
1950  ~SDOITEM_TYPE2 ();
1951 
1952  // Implementation.
1953  //
1954  protected:
1955  void
1956  parse (::xsd::cxx::xml::dom::parser< char >&,
1957  ::xml_schema::flags);
1958 
1959  protected:
1960  ::xsd::cxx::tree::one< index_type > index_;
1961  ::xsd::cxx::tree::one< subindex_type > subindex_;
1962 };
1963 
1964 class SDOITEM_TYPE3: public ::SDOITEM_TYPE
1965 {
1966  public:
1967  // number
1968  //
1969  typedef ::xml_schema::byte number_type;
1970  typedef ::xsd::cxx::tree::traits< number_type, char > number_traits;
1971 
1972  const number_type&
1973  number () const;
1974 
1975  number_type&
1976  number ();
1977 
1978  void
1979  number (const number_type& x);
1980 
1981  // Constructors.
1982  //
1983  SDOITEM_TYPE3 (const name_type&,
1984  const type_type&,
1985  const access_type&,
1986  const number_type&);
1987 
1988  SDOITEM_TYPE3 (const ::xercesc::DOMElement& e,
1989  ::xml_schema::flags f = 0,
1990  ::xml_schema::container* c = 0);
1991 
1992  SDOITEM_TYPE3 (const SDOITEM_TYPE3& x,
1993  ::xml_schema::flags f = 0,
1994  ::xml_schema::container* c = 0);
1995 
1996  virtual SDOITEM_TYPE3*
1997  _clone (::xml_schema::flags f = 0,
1998  ::xml_schema::container* c = 0) const;
1999 
2000  SDOITEM_TYPE3&
2001  operator= (const SDOITEM_TYPE3& x);
2002 
2003  virtual
2004  ~SDOITEM_TYPE3 ();
2005 
2006  // Implementation.
2007  //
2008  protected:
2009  void
2010  parse (::xsd::cxx::xml::dom::parser< char >&,
2011  ::xml_schema::flags);
2012 
2013  protected:
2014  ::xsd::cxx::tree::one< number_type > number_;
2015 };
2016 
2017 class ITEM: public ::xml_schema::type
2018 {
2019  public:
2020  // name
2021  //
2022  typedef ::name_type name_type;
2023  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
2024 
2025  const name_type&
2026  name () const;
2027 
2028  name_type&
2029  name ();
2030 
2031  void
2032  name (const name_type& x);
2033 
2034  void
2035  name (::std::auto_ptr< name_type > p);
2036 
2037  // value
2038  //
2039  typedef ::xml_schema::string value_type;
2040  typedef ::xsd::cxx::tree::traits< value_type, char > value_traits;
2041 
2042  const value_type&
2043  value () const;
2044 
2045  value_type&
2046  value ();
2047 
2048  void
2049  value (const value_type& x);
2050 
2051  void
2052  value (::std::auto_ptr< value_type > p);
2053 
2054  // when
2055  //
2056  typedef ::xml_schema::string when_type;
2057  typedef ::xsd::cxx::tree::optional< when_type > when_optional;
2058  typedef ::xsd::cxx::tree::traits< when_type, char > when_traits;
2059 
2060  const when_optional&
2061  when () const;
2062 
2063  when_optional&
2064  when ();
2065 
2066  void
2067  when (const when_type& x);
2068 
2069  void
2070  when (const when_optional& x);
2071 
2072  void
2073  when (::std::auto_ptr< when_type > p);
2074 
2075  // status
2076  //
2077  typedef ::xml_schema::string status_type;
2078  typedef ::xsd::cxx::tree::optional< status_type > status_optional;
2079  typedef ::xsd::cxx::tree::traits< status_type, char > status_traits;
2080 
2081  const status_optional&
2082  status () const;
2083 
2084  status_optional&
2085  status ();
2086 
2087  void
2088  status (const status_type& x);
2089 
2090  void
2091  status (const status_optional& x);
2092 
2093  void
2094  status (::std::auto_ptr< status_type > p);
2095 
2096  // Constructors.
2097  //
2098  ITEM (const name_type&,
2099  const value_type&);
2100 
2101  ITEM (const ::xercesc::DOMElement& e,
2102  ::xml_schema::flags f = 0,
2103  ::xml_schema::container* c = 0);
2104 
2105  ITEM (const ITEM& x,
2106  ::xml_schema::flags f = 0,
2107  ::xml_schema::container* c = 0);
2108 
2109  virtual ITEM*
2110  _clone (::xml_schema::flags f = 0,
2111  ::xml_schema::container* c = 0) const;
2112 
2113  ITEM&
2114  operator= (const ITEM& x);
2115 
2116  virtual
2117  ~ITEM ();
2118 
2119  // Implementation.
2120  //
2121  protected:
2122  void
2123  parse (::xsd::cxx::xml::dom::parser< char >&,
2124  ::xml_schema::flags);
2125 
2126  protected:
2127  ::xsd::cxx::tree::one< name_type > name_;
2128  ::xsd::cxx::tree::one< value_type > value_;
2129  when_optional when_;
2130  status_optional status_;
2131 };
2132 
2133 class REGEXPR: public ::xml_schema::type
2134 {
2135  public:
2136  // name
2137  //
2138  typedef ::regexpr_type name_type;
2139  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
2140 
2141  const name_type&
2142  name () const;
2143 
2144  name_type&
2145  name ();
2146 
2147  void
2148  name (const name_type& x);
2149 
2150  void
2151  name (::std::auto_ptr< name_type > p);
2152 
2153  // value
2154  //
2155  typedef ::xml_schema::string value_type;
2156  typedef ::xsd::cxx::tree::traits< value_type, char > value_traits;
2157 
2158  const value_type&
2159  value () const;
2160 
2161  value_type&
2162  value ();
2163 
2164  void
2165  value (const value_type& x);
2166 
2167  void
2168  value (::std::auto_ptr< value_type > p);
2169 
2170  // Constructors.
2171  //
2172  REGEXPR (const name_type&,
2173  const value_type&);
2174 
2175  REGEXPR (const ::xercesc::DOMElement& e,
2176  ::xml_schema::flags f = 0,
2177  ::xml_schema::container* c = 0);
2178 
2179  REGEXPR (const REGEXPR& x,
2180  ::xml_schema::flags f = 0,
2181  ::xml_schema::container* c = 0);
2182 
2183  virtual REGEXPR*
2184  _clone (::xml_schema::flags f = 0,
2185  ::xml_schema::container* c = 0) const;
2186 
2187  REGEXPR&
2188  operator= (const REGEXPR& x);
2189 
2190  virtual
2191  ~REGEXPR ();
2192 
2193  // Implementation.
2194  //
2195  protected:
2196  void
2197  parse (::xsd::cxx::xml::dom::parser< char >&,
2198  ::xml_schema::flags);
2199 
2200  protected:
2201  ::xsd::cxx::tree::one< name_type > name_;
2202  ::xsd::cxx::tree::one< value_type > value_;
2203 };
2204 
2205 class uatype: public ::xml_schema::string
2206 {
2207  public:
2208  enum value
2209  {
2210  bool_,
2211  bit,
2212  byte,
2213  Int32,
2214  UInt32,
2215  Int16,
2216  UInt16,
2217  float_,
2218  double_,
2219  array
2220  };
2221 
2222  uatype (value v);
2223 
2224  uatype (const char* v);
2225 
2226  uatype (const ::std::string& v);
2227 
2228  uatype (const ::xml_schema::string& v);
2229 
2230  uatype (const ::xercesc::DOMElement& e,
2231  ::xml_schema::flags f = 0,
2232  ::xml_schema::container* c = 0);
2233 
2234  uatype (const ::xercesc::DOMAttr& a,
2235  ::xml_schema::flags f = 0,
2236  ::xml_schema::container* c = 0);
2237 
2238  uatype (const ::std::string& s,
2239  const ::xercesc::DOMElement* e,
2240  ::xml_schema::flags f = 0,
2241  ::xml_schema::container* c = 0);
2242 
2243  uatype (const uatype& x,
2244  ::xml_schema::flags f = 0,
2245  ::xml_schema::container* c = 0);
2246 
2247  virtual uatype*
2248  _clone (::xml_schema::flags f = 0,
2249  ::xml_schema::container* c = 0) const;
2250 
2251  uatype&
2252  operator= (value v);
2253 
2254  virtual
2255  operator value () const
2256  {
2257  return _xsd_uatype_convert ();
2258  }
2259 
2260  protected:
2261  value
2262  _xsd_uatype_convert () const;
2263 
2264  public:
2265  static const char* const _xsd_uatype_literals_[10];
2266  static const value _xsd_uatype_indexes_[10];
2267 };
2268 
2269 class cobidrestriction: public ::xml_schema::string
2270 {
2271  public:
2272  // Constructors.
2273  //
2274  cobidrestriction ();
2275 
2276  cobidrestriction (const char*);
2277 
2278  cobidrestriction (const ::std::string&);
2279 
2280  cobidrestriction (const ::xml_schema::string&);
2281 
2282  cobidrestriction (const ::xercesc::DOMElement& e,
2283  ::xml_schema::flags f = 0,
2284  ::xml_schema::container* c = 0);
2285 
2286  cobidrestriction (const ::xercesc::DOMAttr& a,
2287  ::xml_schema::flags f = 0,
2288  ::xml_schema::container* c = 0);
2289 
2290  cobidrestriction (const ::std::string& s,
2291  const ::xercesc::DOMElement* e,
2292  ::xml_schema::flags f = 0,
2293  ::xml_schema::container* c = 0);
2294 
2295  cobidrestriction (const cobidrestriction& x,
2296  ::xml_schema::flags f = 0,
2297  ::xml_schema::container* c = 0);
2298 
2299  virtual cobidrestriction*
2300  _clone (::xml_schema::flags f = 0,
2301  ::xml_schema::container* c = 0) const;
2302 
2303  virtual
2304  ~cobidrestriction ();
2305 };
2306 
2307 class rtrvalue: public ::xml_schema::string
2308 {
2309  public:
2310  enum value
2311  {
2312  init,
2313  yes,
2314  no
2315  };
2316 
2317  rtrvalue (value v);
2318 
2319  rtrvalue (const char* v);
2320 
2321  rtrvalue (const ::std::string& v);
2322 
2323  rtrvalue (const ::xml_schema::string& v);
2324 
2325  rtrvalue (const ::xercesc::DOMElement& e,
2326  ::xml_schema::flags f = 0,
2327  ::xml_schema::container* c = 0);
2328 
2329  rtrvalue (const ::xercesc::DOMAttr& a,
2330  ::xml_schema::flags f = 0,
2331  ::xml_schema::container* c = 0);
2332 
2333  rtrvalue (const ::std::string& s,
2334  const ::xercesc::DOMElement* e,
2335  ::xml_schema::flags f = 0,
2336  ::xml_schema::container* c = 0);
2337 
2338  rtrvalue (const rtrvalue& x,
2339  ::xml_schema::flags f = 0,
2340  ::xml_schema::container* c = 0);
2341 
2342  virtual rtrvalue*
2343  _clone (::xml_schema::flags f = 0,
2344  ::xml_schema::container* c = 0) const;
2345 
2346  rtrvalue&
2347  operator= (value v);
2348 
2349  virtual
2350  operator value () const
2351  {
2352  return _xsd_rtrvalue_convert ();
2353  }
2354 
2355  protected:
2356  value
2357  _xsd_rtrvalue_convert () const;
2358 
2359  public:
2360  static const char* const _xsd_rtrvalue_literals_[3];
2361  static const value _xsd_rtrvalue_indexes_[3];
2362 };
2363 
2364 class accesssdo: public ::xml_schema::string
2365 {
2366  public:
2367  enum value
2368  {
2369  R,
2370  W,
2371  RW
2372  };
2373 
2374  accesssdo (value v);
2375 
2376  accesssdo (const char* v);
2377 
2378  accesssdo (const ::std::string& v);
2379 
2380  accesssdo (const ::xml_schema::string& v);
2381 
2382  accesssdo (const ::xercesc::DOMElement& e,
2383  ::xml_schema::flags f = 0,
2384  ::xml_schema::container* c = 0);
2385 
2386  accesssdo (const ::xercesc::DOMAttr& a,
2387  ::xml_schema::flags f = 0,
2388  ::xml_schema::container* c = 0);
2389 
2390  accesssdo (const ::std::string& s,
2391  const ::xercesc::DOMElement* e,
2392  ::xml_schema::flags f = 0,
2393  ::xml_schema::container* c = 0);
2394 
2395  accesssdo (const accesssdo& x,
2396  ::xml_schema::flags f = 0,
2397  ::xml_schema::container* c = 0);
2398 
2399  virtual accesssdo*
2400  _clone (::xml_schema::flags f = 0,
2401  ::xml_schema::container* c = 0) const;
2402 
2403  accesssdo&
2404  operator= (value v);
2405 
2406  virtual
2407  operator value () const
2408  {
2409  return _xsd_accesssdo_convert ();
2410  }
2411 
2412  protected:
2413  value
2414  _xsd_accesssdo_convert () const;
2415 
2416  public:
2417  static const char* const _xsd_accesssdo_literals_[3];
2418  static const value _xsd_accesssdo_indexes_[3];
2419 };
2420 
2421 class nmtcommand: public ::xml_schema::string
2422 {
2423  public:
2424  enum value
2425  {
2426  start,
2427  stop,
2428  reset,
2429  preOperational,
2430  none
2431  };
2432 
2433  nmtcommand (value v);
2434 
2435  nmtcommand (const char* v);
2436 
2437  nmtcommand (const ::std::string& v);
2438 
2439  nmtcommand (const ::xml_schema::string& v);
2440 
2441  nmtcommand (const ::xercesc::DOMElement& e,
2442  ::xml_schema::flags f = 0,
2443  ::xml_schema::container* c = 0);
2444 
2445  nmtcommand (const ::xercesc::DOMAttr& a,
2446  ::xml_schema::flags f = 0,
2447  ::xml_schema::container* c = 0);
2448 
2449  nmtcommand (const ::std::string& s,
2450  const ::xercesc::DOMElement* e,
2451  ::xml_schema::flags f = 0,
2452  ::xml_schema::container* c = 0);
2453 
2454  nmtcommand (const nmtcommand& x,
2455  ::xml_schema::flags f = 0,
2456  ::xml_schema::container* c = 0);
2457 
2458  virtual nmtcommand*
2459  _clone (::xml_schema::flags f = 0,
2460  ::xml_schema::container* c = 0) const;
2461 
2462  nmtcommand&
2463  operator= (value v);
2464 
2465  virtual
2466  operator value () const
2467  {
2468  return _xsd_nmtcommand_convert ();
2469  }
2470 
2471  protected:
2472  value
2473  _xsd_nmtcommand_convert () const;
2474 
2475  public:
2476  static const char* const _xsd_nmtcommand_literals_[5];
2477  static const value _xsd_nmtcommand_indexes_[5];
2478 };
2479 
2480 class accesspdo: public ::xml_schema::string
2481 {
2482  public:
2483  enum value
2484  {
2485  R,
2486  W
2487  };
2488 
2489  accesspdo (value v);
2490 
2491  accesspdo (const char* v);
2492 
2493  accesspdo (const ::std::string& v);
2494 
2495  accesspdo (const ::xml_schema::string& v);
2496 
2497  accesspdo (const ::xercesc::DOMElement& e,
2498  ::xml_schema::flags f = 0,
2499  ::xml_schema::container* c = 0);
2500 
2501  accesspdo (const ::xercesc::DOMAttr& a,
2502  ::xml_schema::flags f = 0,
2503  ::xml_schema::container* c = 0);
2504 
2505  accesspdo (const ::std::string& s,
2506  const ::xercesc::DOMElement* e,
2507  ::xml_schema::flags f = 0,
2508  ::xml_schema::container* c = 0);
2509 
2510  accesspdo (const accesspdo& x,
2511  ::xml_schema::flags f = 0,
2512  ::xml_schema::container* c = 0);
2513 
2514  virtual accesspdo*
2515  _clone (::xml_schema::flags f = 0,
2516  ::xml_schema::container* c = 0) const;
2517 
2518  accesspdo&
2519  operator= (value v);
2520 
2521  virtual
2522  operator value () const
2523  {
2524  return _xsd_accesspdo_convert ();
2525  }
2526 
2527  protected:
2528  value
2529  _xsd_accesspdo_convert () const;
2530 
2531  public:
2532  static const char* const _xsd_accesspdo_literals_[2];
2533  static const value _xsd_accesspdo_indexes_[2];
2534 };
2535 
2536 class index_type: public ::xml_schema::string
2537 {
2538  public:
2539  // Constructors.
2540  //
2541  index_type ();
2542 
2543  index_type (const char*);
2544 
2545  index_type (const ::std::string&);
2546 
2547  index_type (const ::xml_schema::string&);
2548 
2549  index_type (const ::xercesc::DOMElement& e,
2550  ::xml_schema::flags f = 0,
2551  ::xml_schema::container* c = 0);
2552 
2553  index_type (const ::xercesc::DOMAttr& a,
2554  ::xml_schema::flags f = 0,
2555  ::xml_schema::container* c = 0);
2556 
2557  index_type (const ::std::string& s,
2558  const ::xercesc::DOMElement* e,
2559  ::xml_schema::flags f = 0,
2560  ::xml_schema::container* c = 0);
2561 
2562  index_type (const index_type& x,
2563  ::xml_schema::flags f = 0,
2564  ::xml_schema::container* c = 0);
2565 
2566  virtual index_type*
2567  _clone (::xml_schema::flags f = 0,
2568  ::xml_schema::container* c = 0) const;
2569 
2570  virtual
2571  ~index_type ();
2572 };
2573 
2574 class subindex_type: public ::xml_schema::string
2575 {
2576  public:
2577  // Constructors.
2578  //
2579  subindex_type ();
2580 
2581  subindex_type (const char*);
2582 
2583  subindex_type (const ::std::string&);
2584 
2585  subindex_type (const ::xml_schema::string&);
2586 
2587  subindex_type (const ::xercesc::DOMElement& e,
2588  ::xml_schema::flags f = 0,
2589  ::xml_schema::container* c = 0);
2590 
2591  subindex_type (const ::xercesc::DOMAttr& a,
2592  ::xml_schema::flags f = 0,
2593  ::xml_schema::container* c = 0);
2594 
2595  subindex_type (const ::std::string& s,
2596  const ::xercesc::DOMElement* e,
2597  ::xml_schema::flags f = 0,
2598  ::xml_schema::container* c = 0);
2599 
2600  subindex_type (const subindex_type& x,
2601  ::xml_schema::flags f = 0,
2602  ::xml_schema::container* c = 0);
2603 
2604  virtual subindex_type*
2605  _clone (::xml_schema::flags f = 0,
2606  ::xml_schema::container* c = 0) const;
2607 
2608  virtual
2609  ~subindex_type ();
2610 };
2611 
2612 class NODETYPE: public ::xml_schema::type
2613 {
2614  public:
2615  // SDO
2616  //
2617  typedef ::SDO SDO_type;
2618  typedef ::xsd::cxx::tree::sequence< SDO_type > SDO_sequence;
2619  typedef SDO_sequence::iterator SDO_iterator;
2620  typedef SDO_sequence::const_iterator SDO_const_iterator;
2621  typedef ::xsd::cxx::tree::traits< SDO_type, char > SDO_traits;
2622 
2623  const SDO_sequence&
2624  SDO () const;
2625 
2626  SDO_sequence&
2627  SDO ();
2628 
2629  void
2630  SDO (const SDO_sequence& s);
2631 
2632  // NPDO
2633  //
2634  typedef ::NPDO NPDO_type;
2635  typedef ::xsd::cxx::tree::sequence< NPDO_type > NPDO_sequence;
2636  typedef NPDO_sequence::iterator NPDO_iterator;
2637  typedef NPDO_sequence::const_iterator NPDO_const_iterator;
2638  typedef ::xsd::cxx::tree::traits< NPDO_type, char > NPDO_traits;
2639 
2640  const NPDO_sequence&
2641  NPDO () const;
2642 
2643  NPDO_sequence&
2644  NPDO ();
2645 
2646  void
2647  NPDO (const NPDO_sequence& s);
2648 
2649  // RPDO1
2650  //
2651  typedef ::RPDO1 RPDO1_type;
2652  typedef ::xsd::cxx::tree::sequence< RPDO1_type > RPDO1_sequence;
2653  typedef RPDO1_sequence::iterator RPDO1_iterator;
2654  typedef RPDO1_sequence::const_iterator RPDO1_const_iterator;
2655  typedef ::xsd::cxx::tree::traits< RPDO1_type, char > RPDO1_traits;
2656 
2657  const RPDO1_sequence&
2658  RPDO1 () const;
2659 
2660  RPDO1_sequence&
2661  RPDO1 ();
2662 
2663  void
2664  RPDO1 (const RPDO1_sequence& s);
2665 
2666  // RPDO2
2667  //
2668  typedef ::RPDO2 RPDO2_type;
2669  typedef ::xsd::cxx::tree::sequence< RPDO2_type > RPDO2_sequence;
2670  typedef RPDO2_sequence::iterator RPDO2_iterator;
2671  typedef RPDO2_sequence::const_iterator RPDO2_const_iterator;
2672  typedef ::xsd::cxx::tree::traits< RPDO2_type, char > RPDO2_traits;
2673 
2674  const RPDO2_sequence&
2675  RPDO2 () const;
2676 
2677  RPDO2_sequence&
2678  RPDO2 ();
2679 
2680  void
2681  RPDO2 (const RPDO2_sequence& s);
2682 
2683  // RPDO3
2684  //
2685  typedef ::RPDO3 RPDO3_type;
2686  typedef ::xsd::cxx::tree::sequence< RPDO3_type > RPDO3_sequence;
2687  typedef RPDO3_sequence::iterator RPDO3_iterator;
2688  typedef RPDO3_sequence::const_iterator RPDO3_const_iterator;
2689  typedef ::xsd::cxx::tree::traits< RPDO3_type, char > RPDO3_traits;
2690 
2691  const RPDO3_sequence&
2692  RPDO3 () const;
2693 
2694  RPDO3_sequence&
2695  RPDO3 ();
2696 
2697  void
2698  RPDO3 (const RPDO3_sequence& s);
2699 
2700  // RPDO4
2701  //
2702  typedef ::RPDO4 RPDO4_type;
2703  typedef ::xsd::cxx::tree::sequence< RPDO4_type > RPDO4_sequence;
2704  typedef RPDO4_sequence::iterator RPDO4_iterator;
2705  typedef RPDO4_sequence::const_iterator RPDO4_const_iterator;
2706  typedef ::xsd::cxx::tree::traits< RPDO4_type, char > RPDO4_traits;
2707 
2708  const RPDO4_sequence&
2709  RPDO4 () const;
2710 
2711  RPDO4_sequence&
2712  RPDO4 ();
2713 
2714  void
2715  RPDO4 (const RPDO4_sequence& s);
2716 
2717  // TPDO1
2718  //
2719  typedef ::TPDO1 TPDO1_type;
2720  typedef ::xsd::cxx::tree::sequence< TPDO1_type > TPDO1_sequence;
2721  typedef TPDO1_sequence::iterator TPDO1_iterator;
2722  typedef TPDO1_sequence::const_iterator TPDO1_const_iterator;
2723  typedef ::xsd::cxx::tree::traits< TPDO1_type, char > TPDO1_traits;
2724 
2725  const TPDO1_sequence&
2726  TPDO1 () const;
2727 
2728  TPDO1_sequence&
2729  TPDO1 ();
2730 
2731  void
2732  TPDO1 (const TPDO1_sequence& s);
2733 
2734  // TPDO2
2735  //
2736  typedef ::TPDO2 TPDO2_type;
2737  typedef ::xsd::cxx::tree::sequence< TPDO2_type > TPDO2_sequence;
2738  typedef TPDO2_sequence::iterator TPDO2_iterator;
2739  typedef TPDO2_sequence::const_iterator TPDO2_const_iterator;
2740  typedef ::xsd::cxx::tree::traits< TPDO2_type, char > TPDO2_traits;
2741 
2742  const TPDO2_sequence&
2743  TPDO2 () const;
2744 
2745  TPDO2_sequence&
2746  TPDO2 ();
2747 
2748  void
2749  TPDO2 (const TPDO2_sequence& s);
2750 
2751  // TPDO3
2752  //
2753  typedef ::TPDO3 TPDO3_type;
2754  typedef ::xsd::cxx::tree::sequence< TPDO3_type > TPDO3_sequence;
2755  typedef TPDO3_sequence::iterator TPDO3_iterator;
2756  typedef TPDO3_sequence::const_iterator TPDO3_const_iterator;
2757  typedef ::xsd::cxx::tree::traits< TPDO3_type, char > TPDO3_traits;
2758 
2759  const TPDO3_sequence&
2760  TPDO3 () const;
2761 
2762  TPDO3_sequence&
2763  TPDO3 ();
2764 
2765  void
2766  TPDO3 (const TPDO3_sequence& s);
2767 
2768  // TPDO4
2769  //
2770  typedef ::TPDO4 TPDO4_type;
2771  typedef ::xsd::cxx::tree::sequence< TPDO4_type > TPDO4_sequence;
2772  typedef TPDO4_sequence::iterator TPDO4_iterator;
2773  typedef TPDO4_sequence::const_iterator TPDO4_const_iterator;
2774  typedef ::xsd::cxx::tree::traits< TPDO4_type, char > TPDO4_traits;
2775 
2776  const TPDO4_sequence&
2777  TPDO4 () const;
2778 
2779  TPDO4_sequence&
2780  TPDO4 ();
2781 
2782  void
2783  TPDO4 (const TPDO4_sequence& s);
2784 
2785  // SDOITEM
2786  //
2787  typedef ::SDOITEM_TYPE2 SDOITEM_type;
2788  typedef ::xsd::cxx::tree::sequence< SDOITEM_type > SDOITEM_sequence;
2789  typedef SDOITEM_sequence::iterator SDOITEM_iterator;
2790  typedef SDOITEM_sequence::const_iterator SDOITEM_const_iterator;
2791  typedef ::xsd::cxx::tree::traits< SDOITEM_type, char > SDOITEM_traits;
2792 
2793  const SDOITEM_sequence&
2794  SDOITEM () const;
2795 
2796  SDOITEM_sequence&
2797  SDOITEM ();
2798 
2799  void
2800  SDOITEM (const SDOITEM_sequence& s);
2801 
2802  // REGEXPR
2803  //
2804  typedef ::REGEXPR REGEXPR_type;
2805  typedef ::xsd::cxx::tree::sequence< REGEXPR_type > REGEXPR_sequence;
2806  typedef REGEXPR_sequence::iterator REGEXPR_iterator;
2807  typedef REGEXPR_sequence::const_iterator REGEXPR_const_iterator;
2808  typedef ::xsd::cxx::tree::traits< REGEXPR_type, char > REGEXPR_traits;
2809 
2810  const REGEXPR_sequence&
2811  REGEXPR () const;
2812 
2813  REGEXPR_sequence&
2814  REGEXPR ();
2815 
2816  void
2817  REGEXPR (const REGEXPR_sequence& s);
2818 
2819  // ITEM
2820  //
2821  typedef ::ITEM ITEM_type;
2822  typedef ::xsd::cxx::tree::sequence< ITEM_type > ITEM_sequence;
2823  typedef ITEM_sequence::iterator ITEM_iterator;
2824  typedef ITEM_sequence::const_iterator ITEM_const_iterator;
2825  typedef ::xsd::cxx::tree::traits< ITEM_type, char > ITEM_traits;
2826 
2827  const ITEM_sequence&
2828  ITEM () const;
2829 
2830  ITEM_sequence&
2831  ITEM ();
2832 
2833  void
2834  ITEM (const ITEM_sequence& s);
2835 
2836  // name
2837  //
2838  typedef ::name_type name_type;
2839  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
2840 
2841  const name_type&
2842  name () const;
2843 
2844  name_type&
2845  name ();
2846 
2847  void
2848  name (const name_type& x);
2849 
2850  void
2851  name (::std::auto_ptr< name_type > p);
2852 
2853  // Constructors.
2854  //
2855  NODETYPE (const name_type&);
2856 
2857  NODETYPE (const ::xercesc::DOMElement& e,
2858  ::xml_schema::flags f = 0,
2859  ::xml_schema::container* c = 0);
2860 
2861  NODETYPE (const NODETYPE& x,
2862  ::xml_schema::flags f = 0,
2863  ::xml_schema::container* c = 0);
2864 
2865  virtual NODETYPE*
2866  _clone (::xml_schema::flags f = 0,
2867  ::xml_schema::container* c = 0) const;
2868 
2869  NODETYPE&
2870  operator= (const NODETYPE& x);
2871 
2872  virtual
2873  ~NODETYPE ();
2874 
2875  // Implementation.
2876  //
2877  protected:
2878  void
2879  parse (::xsd::cxx::xml::dom::parser< char >&,
2880  ::xml_schema::flags);
2881 
2882  protected:
2883  SDO_sequence SDO_;
2884  NPDO_sequence NPDO_;
2885  RPDO1_sequence RPDO1_;
2886  RPDO2_sequence RPDO2_;
2887  RPDO3_sequence RPDO3_;
2888  RPDO4_sequence RPDO4_;
2889  TPDO1_sequence TPDO1_;
2890  TPDO2_sequence TPDO2_;
2891  TPDO3_sequence TPDO3_;
2892  TPDO4_sequence TPDO4_;
2893  SDOITEM_sequence SDOITEM_;
2894  REGEXPR_sequence REGEXPR_;
2895  ITEM_sequence ITEM_;
2896  ::xsd::cxx::tree::one< name_type > name_;
2897 };
2898 
2899 class name_type: public ::xml_schema::string
2900 {
2901  public:
2902  // Constructors.
2903  //
2904  name_type ();
2905 
2906  name_type (const char*);
2907 
2908  name_type (const ::std::string&);
2909 
2910  name_type (const ::xml_schema::string&);
2911 
2912  name_type (const ::xercesc::DOMElement& e,
2913  ::xml_schema::flags f = 0,
2914  ::xml_schema::container* c = 0);
2915 
2916  name_type (const ::xercesc::DOMAttr& a,
2917  ::xml_schema::flags f = 0,
2918  ::xml_schema::container* c = 0);
2919 
2920  name_type (const ::std::string& s,
2921  const ::xercesc::DOMElement* e,
2922  ::xml_schema::flags f = 0,
2923  ::xml_schema::container* c = 0);
2924 
2925  name_type (const name_type& x,
2926  ::xml_schema::flags f = 0,
2927  ::xml_schema::container* c = 0);
2928 
2929  virtual name_type*
2930  _clone (::xml_schema::flags f = 0,
2931  ::xml_schema::container* c = 0) const;
2932 
2933  virtual
2934  ~name_type ();
2935 };
2936 
2937 class regexpr_type: public ::xml_schema::string
2938 {
2939  public:
2940  // Constructors.
2941  //
2942  regexpr_type ();
2943 
2944  regexpr_type (const char*);
2945 
2946  regexpr_type (const ::std::string&);
2947 
2948  regexpr_type (const ::xml_schema::string&);
2949 
2950  regexpr_type (const ::xercesc::DOMElement& e,
2951  ::xml_schema::flags f = 0,
2952  ::xml_schema::container* c = 0);
2953 
2954  regexpr_type (const ::xercesc::DOMAttr& a,
2955  ::xml_schema::flags f = 0,
2956  ::xml_schema::container* c = 0);
2957 
2958  regexpr_type (const ::std::string& s,
2959  const ::xercesc::DOMElement* e,
2960  ::xml_schema::flags f = 0,
2961  ::xml_schema::container* c = 0);
2962 
2963  regexpr_type (const regexpr_type& x,
2964  ::xml_schema::flags f = 0,
2965  ::xml_schema::container* c = 0);
2966 
2967  virtual regexpr_type*
2968  _clone (::xml_schema::flags f = 0,
2969  ::xml_schema::container* c = 0) const;
2970 
2971  virtual
2972  ~regexpr_type ();
2973 };
2974 
2975 class initialsettings: public ::xml_schema::type
2976 {
2977  public:
2978  // variable
2979  //
2980  typedef ::xml_schema::string variable_type;
2981  typedef ::xsd::cxx::tree::optional< variable_type > variable_optional;
2982  typedef ::xsd::cxx::tree::traits< variable_type, char > variable_traits;
2983 
2984  const variable_optional&
2985  variable () const;
2986 
2987  variable_optional&
2988  variable ();
2989 
2990  void
2991  variable (const variable_type& x);
2992 
2993  void
2994  variable (const variable_optional& x);
2995 
2996  void
2997  variable (::std::auto_ptr< variable_type > p);
2998 
2999  // value
3000  //
3001  typedef ::xml_schema::string value_type;
3002  typedef ::xsd::cxx::tree::optional< value_type > value_optional;
3003  typedef ::xsd::cxx::tree::traits< value_type, char > value_traits;
3004 
3005  const value_optional&
3006  value () const;
3007 
3008  value_optional&
3009  value ();
3010 
3011  void
3012  value (const value_type& x);
3013 
3014  void
3015  value (const value_optional& x);
3016 
3017  void
3018  value (::std::auto_ptr< value_type > p);
3019 
3020  // Constructors.
3021  //
3022  initialsettings ();
3023 
3024  initialsettings (const ::xercesc::DOMElement& e,
3025  ::xml_schema::flags f = 0,
3026  ::xml_schema::container* c = 0);
3027 
3028  initialsettings (const initialsettings& x,
3029  ::xml_schema::flags f = 0,
3030  ::xml_schema::container* c = 0);
3031 
3032  virtual initialsettings*
3033  _clone (::xml_schema::flags f = 0,
3034  ::xml_schema::container* c = 0) const;
3035 
3036  initialsettings&
3037  operator= (const initialsettings& x);
3038 
3039  virtual
3040  ~initialsettings ();
3041 
3042  // Implementation.
3043  //
3044  protected:
3045  void
3046  parse (::xsd::cxx::xml::dom::parser< char >&,
3047  ::xml_schema::flags);
3048 
3049  protected:
3050  variable_optional variable_;
3051  value_optional value_;
3052 };
3053 
3054 class methodtype: public ::xml_schema::type
3055 {
3056  public:
3057  // command
3058  //
3059  typedef ::xml_schema::string command_type;
3060  typedef ::xsd::cxx::tree::optional< command_type > command_optional;
3061  typedef ::xsd::cxx::tree::traits< command_type, char > command_traits;
3062 
3063  const command_optional&
3064  command () const;
3065 
3066  command_optional&
3067  command ();
3068 
3069  void
3070  command (const command_type& x);
3071 
3072  void
3073  command (const command_optional& x);
3074 
3075  void
3076  command (::std::auto_ptr< command_type > p);
3077 
3078  // address
3079  //
3080  typedef ::xml_schema::string address_type;
3081  typedef ::xsd::cxx::tree::optional< address_type > address_optional;
3082  typedef ::xsd::cxx::tree::traits< address_type, char > address_traits;
3083 
3084  const address_optional&
3085  address () const;
3086 
3087  address_optional&
3088  address ();
3089 
3090  void
3091  address (const address_type& x);
3092 
3093  void
3094  address (const address_optional& x);
3095 
3096  void
3097  address (::std::auto_ptr< address_type > p);
3098 
3099  // value
3100  //
3101  typedef ::xml_schema::string value_type;
3102  typedef ::xsd::cxx::tree::optional< value_type > value_optional;
3103  typedef ::xsd::cxx::tree::traits< value_type, char > value_traits;
3104 
3105  const value_optional&
3106  value () const;
3107 
3108  value_optional&
3109  value ();
3110 
3111  void
3112  value (const value_type& x);
3113 
3114  void
3115  value (const value_optional& x);
3116 
3117  void
3118  value (::std::auto_ptr< value_type > p);
3119 
3120  // Constructors.
3121  //
3122  methodtype ();
3123 
3124  methodtype (const ::xercesc::DOMElement& e,
3125  ::xml_schema::flags f = 0,
3126  ::xml_schema::container* c = 0);
3127 
3128  methodtype (const methodtype& x,
3129  ::xml_schema::flags f = 0,
3130  ::xml_schema::container* c = 0);
3131 
3132  virtual methodtype*
3133  _clone (::xml_schema::flags f = 0,
3134  ::xml_schema::container* c = 0) const;
3135 
3136  methodtype&
3137  operator= (const methodtype& x);
3138 
3139  virtual
3140  ~methodtype ();
3141 
3142  // Implementation.
3143  //
3144  protected:
3145  void
3146  parse (::xsd::cxx::xml::dom::parser< char >&,
3147  ::xml_schema::flags);
3148 
3149  protected:
3150  command_optional command_;
3151  address_optional address_;
3152  value_optional value_;
3153 };
3154 
3155 class SETTINGSTYPE: public ::xml_schema::type
3156 {
3157  public:
3158  // NGcounter
3159  //
3160  typedef ::xml_schema::unsigned_int NGcounter_type;
3161  typedef ::xsd::cxx::tree::traits< NGcounter_type, char > NGcounter_traits;
3162 
3163  const NGcounter_type&
3164  NGcounter () const;
3165 
3166  NGcounter_type&
3167  NGcounter ();
3168 
3169  void
3170  NGcounter (const NGcounter_type& x);
3171 
3172  static NGcounter_type
3173  NGcounter_default_value ();
3174 
3175  // TypeConversion
3176  //
3177  typedef ::xml_schema::boolean TypeConversion_type;
3178  typedef ::xsd::cxx::tree::traits< TypeConversion_type, char > TypeConversion_traits;
3179 
3180  const TypeConversion_type&
3181  TypeConversion () const;
3182 
3183  TypeConversion_type&
3184  TypeConversion ();
3185 
3186  void
3187  TypeConversion (const TypeConversion_type& x);
3188 
3189  static TypeConversion_type
3190  TypeConversion_default_value ();
3191 
3192  // InitTimeout
3193  //
3194  typedef ::xml_schema::unsigned_int InitTimeout_type;
3195  typedef ::xsd::cxx::tree::traits< InitTimeout_type, char > InitTimeout_traits;
3196 
3197  const InitTimeout_type&
3198  InitTimeout () const;
3199 
3200  InitTimeout_type&
3201  InitTimeout ();
3202 
3203  void
3204  InitTimeout (const InitTimeout_type& x);
3205 
3206  static InitTimeout_type
3207  InitTimeout_default_value ();
3208 
3209  // DisconectRecovery
3210  //
3211  typedef ::xml_schema::boolean DisconectRecovery_type;
3212  typedef ::xsd::cxx::tree::traits< DisconectRecovery_type, char > DisconectRecovery_traits;
3213 
3214  const DisconectRecovery_type&
3215  DisconectRecovery () const;
3216 
3217  DisconectRecovery_type&
3218  DisconectRecovery ();
3219 
3220  void
3221  DisconectRecovery (const DisconectRecovery_type& x);
3222 
3223  static DisconectRecovery_type
3224  DisconectRecovery_default_value ();
3225 
3226  // Constructors.
3227  //
3228  SETTINGSTYPE ();
3229 
3230  SETTINGSTYPE (const ::xercesc::DOMElement& e,
3231  ::xml_schema::flags f = 0,
3232  ::xml_schema::container* c = 0);
3233 
3234  SETTINGSTYPE (const SETTINGSTYPE& x,
3235  ::xml_schema::flags f = 0,
3236  ::xml_schema::container* c = 0);
3237 
3238  virtual SETTINGSTYPE*
3239  _clone (::xml_schema::flags f = 0,
3240  ::xml_schema::container* c = 0) const;
3241 
3242  SETTINGSTYPE&
3243  operator= (const SETTINGSTYPE& x);
3244 
3245  virtual
3246  ~SETTINGSTYPE ();
3247 
3248  // Implementation.
3249  //
3250  protected:
3251  void
3252  parse (::xsd::cxx::xml::dom::parser< char >&,
3253  ::xml_schema::flags);
3254 
3255  protected:
3256  ::xsd::cxx::tree::one< NGcounter_type > NGcounter_;
3257  ::xsd::cxx::tree::one< TypeConversion_type > TypeConversion_;
3258  ::xsd::cxx::tree::one< InitTimeout_type > InitTimeout_;
3259  ::xsd::cxx::tree::one< DisconectRecovery_type > DisconectRecovery_;
3260 };
3261 
3262 class PROGRAM: public ::xml_schema::type
3263 {
3264  public:
3265  // METHOD
3266  //
3267  typedef ::methodtype METHOD_type;
3268  typedef ::xsd::cxx::tree::sequence< METHOD_type > METHOD_sequence;
3269  typedef METHOD_sequence::iterator METHOD_iterator;
3270  typedef METHOD_sequence::const_iterator METHOD_const_iterator;
3271  typedef ::xsd::cxx::tree::traits< METHOD_type, char > METHOD_traits;
3272 
3273  const METHOD_sequence&
3274  METHOD () const;
3275 
3276  METHOD_sequence&
3277  METHOD ();
3278 
3279  void
3280  METHOD (const METHOD_sequence& s);
3281 
3282  // name
3283  //
3284  typedef ::name_type name_type;
3285  typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
3286 
3287  const name_type&
3288  name () const;
3289 
3290  name_type&
3291  name ();
3292 
3293  void
3294  name (const name_type& x);
3295 
3296  void
3297  name (::std::auto_ptr< name_type > p);
3298 
3299  // Constructors.
3300  //
3301  PROGRAM (const name_type&);
3302 
3303  PROGRAM (const ::xercesc::DOMElement& e,
3304  ::xml_schema::flags f = 0,
3305  ::xml_schema::container* c = 0);
3306 
3307  PROGRAM (const PROGRAM& x,
3308  ::xml_schema::flags f = 0,
3309  ::xml_schema::container* c = 0);
3310 
3311  virtual PROGRAM*
3312  _clone (::xml_schema::flags f = 0,
3313  ::xml_schema::container* c = 0) const;
3314 
3315  PROGRAM&
3316  operator= (const PROGRAM& x);
3317 
3318  virtual
3319  ~PROGRAM ();
3320 
3321  // Implementation.
3322  //
3323  protected:
3324  void
3325  parse (::xsd::cxx::xml::dom::parser< char >&,
3326  ::xml_schema::flags);
3327 
3328  protected:
3329  METHOD_sequence METHOD_;
3330  ::xsd::cxx::tree::one< name_type > name_;
3331 };
3332 
3333 class nodeid: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::byte, char, ::xml_schema::simple_type >
3334 {
3335  public:
3336  // Constructors.
3337  //
3338  nodeid (const ::xml_schema::byte&);
3339 
3340  nodeid (const ::xercesc::DOMElement& e,
3341  ::xml_schema::flags f = 0,
3342  ::xml_schema::container* c = 0);
3343 
3344  nodeid (const ::xercesc::DOMAttr& a,
3345  ::xml_schema::flags f = 0,
3346  ::xml_schema::container* c = 0);
3347 
3348  nodeid (const ::std::string& s,
3349  const ::xercesc::DOMElement* e,
3350  ::xml_schema::flags f = 0,
3351  ::xml_schema::container* c = 0);
3352 
3353  nodeid (const nodeid& x,
3354  ::xml_schema::flags f = 0,
3355  ::xml_schema::container* c = 0);
3356 
3357  virtual nodeid*
3358  _clone (::xml_schema::flags f = 0,
3359  ::xml_schema::container* c = 0) const;
3360 
3361  virtual
3362  ~nodeid ();
3363 };
3364 
3365 class NODEGUARD: public ::xml_schema::type
3366 {
3367  public:
3368  // interval
3369  //
3370  typedef ::xml_schema::unsigned_int interval_type;
3371  typedef ::xsd::cxx::tree::traits< interval_type, char > interval_traits;
3372 
3373  const interval_type&
3374  interval () const;
3375 
3376  interval_type&
3377  interval ();
3378 
3379  void
3380  interval (const interval_type& x);
3381 
3382  // Constructors.
3383  //
3384  NODEGUARD (const interval_type&);
3385 
3386  NODEGUARD (const ::xercesc::DOMElement& e,
3387  ::xml_schema::flags f = 0,
3388  ::xml_schema::container* c = 0);
3389 
3390  NODEGUARD (const NODEGUARD& x,
3391  ::xml_schema::flags f = 0,
3392  ::xml_schema::container* c = 0);
3393 
3394  virtual NODEGUARD*
3395  _clone (::xml_schema::flags f = 0,
3396  ::xml_schema::container* c = 0) const;
3397 
3398  NODEGUARD&
3399  operator= (const NODEGUARD& x);
3400 
3401  virtual
3402  ~NODEGUARD ();
3403 
3404  // Implementation.
3405  //
3406  protected:
3407  void
3408  parse (::xsd::cxx::xml::dom::parser< char >&,
3409  ::xml_schema::flags);
3410 
3411  protected:
3412  ::xsd::cxx::tree::one< interval_type > interval_;
3413 };
3414 
3415 class SYNC: public ::xml_schema::type
3416 {
3417  public:
3418  // interval
3419  //
3420  typedef ::xml_schema::unsigned_int interval_type;
3421  typedef ::xsd::cxx::tree::traits< interval_type, char > interval_traits;
3422 
3423  const interval_type&
3424  interval () const;
3425 
3426  interval_type&
3427  interval ();
3428 
3429  void
3430  interval (const interval_type& x);
3431 
3432  // Constructors.
3433  //
3434  SYNC (const interval_type&);
3435 
3436  SYNC (const ::xercesc::DOMElement& e,
3437  ::xml_schema::flags f = 0,
3438  ::xml_schema::container* c = 0);
3439 
3440  SYNC (const SYNC& x,
3441  ::xml_schema::flags f = 0,
3442  ::xml_schema::container* c = 0);
3443 
3444  virtual SYNC*
3445  _clone (::xml_schema::flags f = 0,
3446  ::xml_schema::container* c = 0) const;
3447 
3448  SYNC&
3449  operator= (const SYNC& x);
3450 
3451  virtual
3452  ~SYNC ();
3453 
3454  // Implementation.
3455  //
3456  protected:
3457  void
3458  parse (::xsd::cxx::xml::dom::parser< char >&,
3459  ::xml_schema::flags);
3460 
3461  protected:
3462  ::xsd::cxx::tree::one< interval_type > interval_;
3463 };
3464 
3465 class speed: public ::xml_schema::string
3466 {
3467  public:
3468  enum value
3469  {
3470  cxx_50000,
3471  cxx_100000,
3472  cxx_125000,
3473  cxx_250000,
3474  cxx_500000,
3475  cxx_1000000,
3476  Unspecified
3477  };
3478 
3479  speed (value v);
3480 
3481  speed (const char* v);
3482 
3483  speed (const ::std::string& v);
3484 
3485  speed (const ::xml_schema::string& v);
3486 
3487  speed (const ::xercesc::DOMElement& e,
3488  ::xml_schema::flags f = 0,
3489  ::xml_schema::container* c = 0);
3490 
3491  speed (const ::xercesc::DOMAttr& a,
3492  ::xml_schema::flags f = 0,
3493  ::xml_schema::container* c = 0);
3494 
3495  speed (const ::std::string& s,
3496  const ::xercesc::DOMElement* e,
3497  ::xml_schema::flags f = 0,
3498  ::xml_schema::container* c = 0);
3499 
3500  speed (const speed& x,
3501  ::xml_schema::flags f = 0,
3502  ::xml_schema::container* c = 0);
3503 
3504  virtual speed*
3505  _clone (::xml_schema::flags f = 0,
3506  ::xml_schema::container* c = 0) const;
3507 
3508  speed&
3509  operator= (value v);
3510 
3511  virtual
3512  operator value () const
3513  {
3514  return _xsd_speed_convert ();
3515  }
3516 
3517  protected:
3518  value
3519  _xsd_speed_convert () const;
3520 
3521  public:
3522  static const char* const _xsd_speed_literals_[7];
3523  static const value _xsd_speed_indexes_[7];
3524 };
3525 
3526 #include <iosfwd>
3527 
3528 #include <xercesc/sax/InputSource.hpp>
3529 #include <xercesc/dom/DOMDocument.hpp>
3530 #include <xercesc/dom/DOMErrorHandler.hpp>
3531 
3532 // Parse a URI or a local file.
3533 //
3534 
3535 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3536 CanOpenOpcServerConfig_ (const ::std::string& uri,
3537  ::xml_schema::flags f = 0,
3538  const ::xml_schema::properties& p = ::xml_schema::properties ());
3539 
3540 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3541 CanOpenOpcServerConfig_ (const ::std::string& uri,
3542  ::xml_schema::error_handler& eh,
3543  ::xml_schema::flags f = 0,
3544  const ::xml_schema::properties& p = ::xml_schema::properties ());
3545 
3546 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3547 CanOpenOpcServerConfig_ (const ::std::string& uri,
3548  ::xercesc::DOMErrorHandler& eh,
3549  ::xml_schema::flags f = 0,
3550  const ::xml_schema::properties& p = ::xml_schema::properties ());
3551 
3552 // Parse std::istream.
3553 //
3554 
3555 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3556 CanOpenOpcServerConfig_ (::std::istream& is,
3557  ::xml_schema::flags f = 0,
3558  const ::xml_schema::properties& p = ::xml_schema::properties ());
3559 
3560 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3561 CanOpenOpcServerConfig_ (::std::istream& is,
3562  ::xml_schema::error_handler& eh,
3563  ::xml_schema::flags f = 0,
3564  const ::xml_schema::properties& p = ::xml_schema::properties ());
3565 
3566 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3567 CanOpenOpcServerConfig_ (::std::istream& is,
3568  ::xercesc::DOMErrorHandler& eh,
3569  ::xml_schema::flags f = 0,
3570  const ::xml_schema::properties& p = ::xml_schema::properties ());
3571 
3572 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3573 CanOpenOpcServerConfig_ (::std::istream& is,
3574  const ::std::string& id,
3575  ::xml_schema::flags f = 0,
3576  const ::xml_schema::properties& p = ::xml_schema::properties ());
3577 
3578 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3579 CanOpenOpcServerConfig_ (::std::istream& is,
3580  const ::std::string& id,
3581  ::xml_schema::error_handler& eh,
3582  ::xml_schema::flags f = 0,
3583  const ::xml_schema::properties& p = ::xml_schema::properties ());
3584 
3585 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3586 CanOpenOpcServerConfig_ (::std::istream& is,
3587  const ::std::string& id,
3588  ::xercesc::DOMErrorHandler& eh,
3589  ::xml_schema::flags f = 0,
3590  const ::xml_schema::properties& p = ::xml_schema::properties ());
3591 
3592 // Parse xercesc::InputSource.
3593 //
3594 
3595 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3596 CanOpenOpcServerConfig_ (::xercesc::InputSource& is,
3597  ::xml_schema::flags f = 0,
3598  const ::xml_schema::properties& p = ::xml_schema::properties ());
3599 
3600 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3601 CanOpenOpcServerConfig_ (::xercesc::InputSource& is,
3602  ::xml_schema::error_handler& eh,
3603  ::xml_schema::flags f = 0,
3604  const ::xml_schema::properties& p = ::xml_schema::properties ());
3605 
3606 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3607 CanOpenOpcServerConfig_ (::xercesc::InputSource& is,
3608  ::xercesc::DOMErrorHandler& eh,
3609  ::xml_schema::flags f = 0,
3610  const ::xml_schema::properties& p = ::xml_schema::properties ());
3611 
3612 // Parse xercesc::DOMDocument.
3613 //
3614 
3615 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3616 CanOpenOpcServerConfig_ (const ::xercesc::DOMDocument& d,
3617  ::xml_schema::flags f = 0,
3618  const ::xml_schema::properties& p = ::xml_schema::properties ());
3619 
3620 ::std::auto_ptr< ::CanOpenOpcServerConfig >
3621 CanOpenOpcServerConfig_ (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d,
3622  ::xml_schema::flags f = 0,
3623  const ::xml_schema::properties& p = ::xml_schema::properties ());
3624 
3625 #include <xsd/cxx/post.hxx>
3626 
3627 // Begin epilogue.
3628 //
3629 //
3630 // End epilogue.
3631 
3632 #endif // C__USERS_VFILIMON_WORKSPACE_OPC_UA_ELMB_CONFIGURATION_CANOPEN_SERVER_CONFIG_H