panda
/
COMPASSi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
COMPASSi/trunk/code/inc/DataManager/XSDHeader/TonnageModelDS.hxx

2758 lines
63 KiB
C++
Raw Normal View History

first commit
2025-06-25 15:06:42 +08:00
// Copyright (c) 2005-2023 Code Synthesis.
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis gives permission
// to link this program with the Xerces-C++ library (or with modified
// versions of Xerces-C++ that use the same license as Xerces-C++), and
// distribute linked combinations including the two. You must obey the GNU
// General Public License version 2 in all respects for all of the code
// used other than Xerces-C++. If you modify this copy of the program, you
// may extend this exception to your version of the program, but you are
// not obligated to do so. If you do not wish to do so, delete this
// exception statement from your version.
//
// Furthermore, Code Synthesis makes a special exception for the Free/Libre
// and Open Source Software (FLOSS) which is described in the accompanying
// FLOSSE file.
//
#ifndef CXX__TONNAGE_MODEL_DS_HXX
#define CXX__TONNAGE_MODEL_DS_HXX
#ifndef XSD_CXX11
#define XSD_CXX11
#endif
#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif
#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif
// Begin prologue.
//
//
// End prologue.
#include <xsd/cxx/config.hxx>
#if (LIBXSD_VERSION != 400002000000000L)
#error XSD runtime version mismatch
#endif
#include <xsd/cxx/pre.hxx>
#include <xsd/cxx/xml/char-utf8.hxx>
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>
#include <xsd/cxx/xml/error-handler.hxx>
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>
#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>
namespace xml_schema
{
// anyType and anySimpleType.
//
typedef ::xsd::cxx::tree::type type;
typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
typedef ::xsd::cxx::tree::type container;
// 8-bit
//
typedef signed char byte;
typedef unsigned char unsigned_byte;
// 16-bit
//
typedef short short_;
typedef unsigned short unsigned_short;
// 32-bit
//
typedef int int_;
typedef unsigned int unsigned_int;
// 64-bit
//
typedef long long long_;
typedef unsigned long long unsigned_long;
// Supposed to be arbitrary-length integral types.
//
typedef long long integer;
typedef long long non_positive_integer;
typedef unsigned long long non_negative_integer;
typedef unsigned long long positive_integer;
typedef long long negative_integer;
// Boolean.
//
typedef bool boolean;
// Floating-point types.
//
typedef float float_;
typedef double double_;
typedef double decimal;
// String types.
//
typedef ::xsd::cxx::tree::string< char, simple_type > string;
typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
typedef ::xsd::cxx::tree::token< char, normalized_string > token;
typedef ::xsd::cxx::tree::name< char, token > name;
typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
typedef ::xsd::cxx::tree::ncname< char, name > ncname;
typedef ::xsd::cxx::tree::language< char, token > language;
// ID/IDREF.
//
typedef ::xsd::cxx::tree::id< char, ncname > id;
typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;
// URI.
//
typedef ::xsd::cxx::tree::uri< char, simple_type > uri;
// Qualified name.
//
typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;
// Binary.
//
typedef ::xsd::cxx::tree::buffer< char > buffer;
typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;
// Date/time.
//
typedef ::xsd::cxx::tree::time_zone time_zone;
typedef ::xsd::cxx::tree::date< char, simple_type > date;
typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
typedef ::xsd::cxx::tree::time< char, simple_type > time;
// Entity.
//
typedef ::xsd::cxx::tree::entity< char, ncname > entity;
typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;
typedef ::xsd::cxx::tree::content_order content_order;
// Namespace information and list stream. Used in
// serialization functions.
//
typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;
typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;
typedef ::xsd::cxx::tree::list_stream< char > list_stream;
typedef ::xsd::cxx::tree::as_double< double_ > as_double;
typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;
typedef ::xsd::cxx::tree::facet facet;
// Flags and properties.
//
typedef ::xsd::cxx::tree::flags flags;
typedef ::xsd::cxx::tree::properties< char > properties;
// Parsing/serialization diagnostics.
//
typedef ::xsd::cxx::tree::severity severity;
typedef ::xsd::cxx::tree::error< char > error;
typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;
// Exceptions.
//
typedef ::xsd::cxx::tree::exception< char > exception;
typedef ::xsd::cxx::tree::bounds< char > bounds;
typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
typedef ::xsd::cxx::tree::parsing< char > parsing;
typedef ::xsd::cxx::tree::expected_element< char > expected_element;
typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
typedef ::xsd::cxx::tree::serialization< char > serialization;
// Error handler callback interface.
//
typedef ::xsd::cxx::xml::error_handler< char > error_handler;
// DOM interaction.
//
namespace dom
{
// Automatic pointer for DOMDocument.
//
using ::xsd::cxx::xml::dom::unique_ptr;
#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
// DOM user data key for back pointers to tree nodes.
//
const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
}
}
// Forward declarations.
//
namespace tonnagemodel_ds
{
class TonnageModelDS;
class BInf;
class V1Inf;
class V1Simpson;
class V2Simpson;
class V2Block;
class V2other;
class V3;
class V43;
class V41;
class V42;
class V43Total;
class V5;
class V2Entity;
class V1Entity;
}
#include <memory> // ::std::unique_ptr
#include <limits> // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility> // std::move
#include <xsd/cxx/xml/char-utf8.hxx>
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>
#include <xsd/cxx/xml/dom/parsing-header.hxx>
namespace tonnagemodel_ds
{
class TonnageModelDS: public ::xml_schema::type
{
public:
// BInf
//
typedef ::tonnagemodel_ds::BInf BInf_type;
typedef ::xsd::cxx::tree::sequence< BInf_type > BInf_sequence;
typedef BInf_sequence::iterator BInf_iterator;
typedef BInf_sequence::const_iterator BInf_const_iterator;
typedef ::xsd::cxx::tree::traits< BInf_type, char > BInf_traits;
const BInf_sequence&
BInf () const;
BInf_sequence&
BInf ();
void
BInf (const BInf_sequence& s);
// V1Inf
//
typedef ::tonnagemodel_ds::V1Inf V1Inf_type;
typedef ::xsd::cxx::tree::sequence< V1Inf_type > V1Inf_sequence;
typedef V1Inf_sequence::iterator V1Inf_iterator;
typedef V1Inf_sequence::const_iterator V1Inf_const_iterator;
typedef ::xsd::cxx::tree::traits< V1Inf_type, char > V1Inf_traits;
const V1Inf_sequence&
V1Inf () const;
V1Inf_sequence&
V1Inf ();
void
V1Inf (const V1Inf_sequence& s);
// V1Simpson
//
typedef ::tonnagemodel_ds::V1Simpson V1Simpson_type;
typedef ::xsd::cxx::tree::sequence< V1Simpson_type > V1Simpson_sequence;
typedef V1Simpson_sequence::iterator V1Simpson_iterator;
typedef V1Simpson_sequence::const_iterator V1Simpson_const_iterator;
typedef ::xsd::cxx::tree::traits< V1Simpson_type, char > V1Simpson_traits;
const V1Simpson_sequence&
V1Simpson () const;
V1Simpson_sequence&
V1Simpson ();
void
V1Simpson (const V1Simpson_sequence& s);
// V2Simpson
//
typedef ::tonnagemodel_ds::V2Simpson V2Simpson_type;
typedef ::xsd::cxx::tree::sequence< V2Simpson_type > V2Simpson_sequence;
typedef V2Simpson_sequence::iterator V2Simpson_iterator;
typedef V2Simpson_sequence::const_iterator V2Simpson_const_iterator;
typedef ::xsd::cxx::tree::traits< V2Simpson_type, char > V2Simpson_traits;
const V2Simpson_sequence&
V2Simpson () const;
V2Simpson_sequence&
V2Simpson ();
void
V2Simpson (const V2Simpson_sequence& s);
// V2Block
//
typedef ::tonnagemodel_ds::V2Block V2Block_type;
typedef ::xsd::cxx::tree::sequence< V2Block_type > V2Block_sequence;
typedef V2Block_sequence::iterator V2Block_iterator;
typedef V2Block_sequence::const_iterator V2Block_const_iterator;
typedef ::xsd::cxx::tree::traits< V2Block_type, char > V2Block_traits;
const V2Block_sequence&
V2Block () const;
V2Block_sequence&
V2Block ();
void
V2Block (const V2Block_sequence& s);
// V2other
//
typedef ::tonnagemodel_ds::V2other V2other_type;
typedef ::xsd::cxx::tree::sequence< V2other_type > V2other_sequence;
typedef V2other_sequence::iterator V2other_iterator;
typedef V2other_sequence::const_iterator V2other_const_iterator;
typedef ::xsd::cxx::tree::traits< V2other_type, char > V2other_traits;
const V2other_sequence&
V2other () const;
V2other_sequence&
V2other ();
void
V2other (const V2other_sequence& s);
// V3
//
typedef ::tonnagemodel_ds::V3 V3_type;
typedef ::xsd::cxx::tree::sequence< V3_type > V3_sequence;
typedef V3_sequence::iterator V3_iterator;
typedef V3_sequence::const_iterator V3_const_iterator;
typedef ::xsd::cxx::tree::traits< V3_type, char > V3_traits;
const V3_sequence&
V3 () const;
V3_sequence&
V3 ();
void
V3 (const V3_sequence& s);
// V43
//
typedef ::tonnagemodel_ds::V43 V43_type;
typedef ::xsd::cxx::tree::sequence< V43_type > V43_sequence;
typedef V43_sequence::iterator V43_iterator;
typedef V43_sequence::const_iterator V43_const_iterator;
typedef ::xsd::cxx::tree::traits< V43_type, char > V43_traits;
const V43_sequence&
V43 () const;
V43_sequence&
V43 ();
void
V43 (const V43_sequence& s);
// V41
//
typedef ::tonnagemodel_ds::V41 V41_type;
typedef ::xsd::cxx::tree::sequence< V41_type > V41_sequence;
typedef V41_sequence::iterator V41_iterator;
typedef V41_sequence::const_iterator V41_const_iterator;
typedef ::xsd::cxx::tree::traits< V41_type, char > V41_traits;
const V41_sequence&
V41 () const;
V41_sequence&
V41 ();
void
V41 (const V41_sequence& s);
// V42
//
typedef ::tonnagemodel_ds::V42 V42_type;
typedef ::xsd::cxx::tree::sequence< V42_type > V42_sequence;
typedef V42_sequence::iterator V42_iterator;
typedef V42_sequence::const_iterator V42_const_iterator;
typedef ::xsd::cxx::tree::traits< V42_type, char > V42_traits;
const V42_sequence&
V42 () const;
V42_sequence&
V42 ();
void
V42 (const V42_sequence& s);
// V43Total
//
typedef ::tonnagemodel_ds::V43Total V43Total_type;
typedef ::xsd::cxx::tree::sequence< V43Total_type > V43Total_sequence;
typedef V43Total_sequence::iterator V43Total_iterator;
typedef V43Total_sequence::const_iterator V43Total_const_iterator;
typedef ::xsd::cxx::tree::traits< V43Total_type, char > V43Total_traits;
const V43Total_sequence&
V43Total () const;
V43Total_sequence&
V43Total ();
void
V43Total (const V43Total_sequence& s);
// V5
//
typedef ::tonnagemodel_ds::V5 V5_type;
typedef ::xsd::cxx::tree::sequence< V5_type > V5_sequence;
typedef V5_sequence::iterator V5_iterator;
typedef V5_sequence::const_iterator V5_const_iterator;
typedef ::xsd::cxx::tree::traits< V5_type, char > V5_traits;
const V5_sequence&
V5 () const;
V5_sequence&
V5 ();
void
V5 (const V5_sequence& s);
// V2Entity
//
typedef ::tonnagemodel_ds::V2Entity V2Entity_type;
typedef ::xsd::cxx::tree::sequence< V2Entity_type > V2Entity_sequence;
typedef V2Entity_sequence::iterator V2Entity_iterator;
typedef V2Entity_sequence::const_iterator V2Entity_const_iterator;
typedef ::xsd::cxx::tree::traits< V2Entity_type, char > V2Entity_traits;
const V2Entity_sequence&
V2Entity () const;
V2Entity_sequence&
V2Entity ();
void
V2Entity (const V2Entity_sequence& s);
// V1Entity
//
typedef ::tonnagemodel_ds::V1Entity V1Entity_type;
typedef ::xsd::cxx::tree::sequence< V1Entity_type > V1Entity_sequence;
typedef V1Entity_sequence::iterator V1Entity_iterator;
typedef V1Entity_sequence::const_iterator V1Entity_const_iterator;
typedef ::xsd::cxx::tree::traits< V1Entity_type, char > V1Entity_traits;
const V1Entity_sequence&
V1Entity () const;
V1Entity_sequence&
V1Entity ();
void
V1Entity (const V1Entity_sequence& s);
// Constructors.
//
TonnageModelDS ();
TonnageModelDS (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
TonnageModelDS (const TonnageModelDS& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual TonnageModelDS*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
TonnageModelDS&
operator= (const TonnageModelDS& x);
virtual
~TonnageModelDS ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
BInf_sequence BInf_;
V1Inf_sequence V1Inf_;
V1Simpson_sequence V1Simpson_;
V2Simpson_sequence V2Simpson_;
V2Block_sequence V2Block_;
V2other_sequence V2other_;
V3_sequence V3_;
V43_sequence V43_;
V41_sequence V41_;
V42_sequence V42_;
V43Total_sequence V43Total_;
V5_sequence V5_;
V2Entity_sequence V2Entity_;
V1Entity_sequence V1Entity_;
};
class BInf: public ::xml_schema::type
{
public:
// ParamID
//
typedef ::xml_schema::string ParamID_type;
typedef ::xsd::cxx::tree::traits< ParamID_type, char > ParamID_traits;
const ParamID_type&
ParamID () const;
ParamID_type&
ParamID ();
void
ParamID (const ParamID_type& x);
void
ParamID (::std::unique_ptr< ParamID_type > p);
// Unit
//
typedef ::xml_schema::string Unit_type;
typedef ::xsd::cxx::tree::optional< Unit_type > Unit_optional;
typedef ::xsd::cxx::tree::traits< Unit_type, char > Unit_traits;
const Unit_optional&
Unit () const;
Unit_optional&
Unit ();
void
Unit (const Unit_type& x);
void
Unit (const Unit_optional& x);
void
Unit (::std::unique_ptr< Unit_type > p);
// Caption
//
typedef ::xml_schema::string Caption_type;
typedef ::xsd::cxx::tree::optional< Caption_type > Caption_optional;
typedef ::xsd::cxx::tree::traits< Caption_type, char > Caption_traits;
const Caption_optional&
Caption () const;
Caption_optional&
Caption ();
void
Caption (const Caption_type& x);
void
Caption (const Caption_optional& x);
void
Caption (::std::unique_ptr< Caption_type > p);
// ValueType
//
typedef ::xml_schema::string ValueType_type;
typedef ::xsd::cxx::tree::optional< ValueType_type > ValueType_optional;
typedef ::xsd::cxx::tree::traits< ValueType_type, char > ValueType_traits;
const ValueType_optional&
ValueType () const;
ValueType_optional&
ValueType ();
void
ValueType (const ValueType_type& x);
void
ValueType (const ValueType_optional& x);
void
ValueType (::std::unique_ptr< ValueType_type > p);
// Value
//
typedef ::xml_schema::string Value_type;
typedef ::xsd::cxx::tree::optional< Value_type > Value_optional;
typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;
const Value_optional&
Value () const;
Value_optional&
Value ();
void
Value (const Value_type& x);
void
Value (const Value_optional& x);
void
Value (::std::unique_ptr< Value_type > p);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// Constructors.
//
BInf (const ParamID_type&);
BInf (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
BInf (const BInf& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual BInf*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
BInf&
operator= (const BInf& x);
virtual
~BInf ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ParamID_type > ParamID_;
Unit_optional Unit_;
Caption_optional Caption_;
ValueType_optional ValueType_;
Value_optional Value_;
Remark_optional Remark_;
};
class V1Inf: public ::xml_schema::type
{
public:
// ParamID
//
typedef ::xml_schema::string ParamID_type;
typedef ::xsd::cxx::tree::traits< ParamID_type, char > ParamID_traits;
const ParamID_type&
ParamID () const;
ParamID_type&
ParamID ();
void
ParamID (const ParamID_type& x);
void
ParamID (::std::unique_ptr< ParamID_type > p);
// Unit
//
typedef ::xml_schema::string Unit_type;
typedef ::xsd::cxx::tree::optional< Unit_type > Unit_optional;
typedef ::xsd::cxx::tree::traits< Unit_type, char > Unit_traits;
const Unit_optional&
Unit () const;
Unit_optional&
Unit ();
void
Unit (const Unit_type& x);
void
Unit (const Unit_optional& x);
void
Unit (::std::unique_ptr< Unit_type > p);
// Caption
//
typedef ::xml_schema::string Caption_type;
typedef ::xsd::cxx::tree::optional< Caption_type > Caption_optional;
typedef ::xsd::cxx::tree::traits< Caption_type, char > Caption_traits;
const Caption_optional&
Caption () const;
Caption_optional&
Caption ();
void
Caption (const Caption_type& x);
void
Caption (const Caption_optional& x);
void
Caption (::std::unique_ptr< Caption_type > p);
// ValueType
//
typedef ::xml_schema::string ValueType_type;
typedef ::xsd::cxx::tree::optional< ValueType_type > ValueType_optional;
typedef ::xsd::cxx::tree::traits< ValueType_type, char > ValueType_traits;
const ValueType_optional&
ValueType () const;
ValueType_optional&
ValueType ();
void
ValueType (const ValueType_type& x);
void
ValueType (const ValueType_optional& x);
void
ValueType (::std::unique_ptr< ValueType_type > p);
// Value
//
typedef ::xml_schema::string Value_type;
typedef ::xsd::cxx::tree::optional< Value_type > Value_optional;
typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;
const Value_optional&
Value () const;
Value_optional&
Value ();
void
Value (const Value_type& x);
void
Value (const Value_optional& x);
void
Value (::std::unique_ptr< Value_type > p);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// Constructors.
//
V1Inf (const ParamID_type&);
V1Inf (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V1Inf (const V1Inf& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V1Inf*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V1Inf&
operator= (const V1Inf& x);
virtual
~V1Inf ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ParamID_type > ParamID_;
Unit_optional Unit_;
Caption_optional Caption_;
ValueType_optional ValueType_;
Value_optional Value_;
Remark_optional Remark_;
};
class V1Simpson: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// L
//
typedef ::xml_schema::double_ L_type;
typedef ::xsd::cxx::tree::optional< L_type > L_optional;
typedef ::xsd::cxx::tree::traits< L_type, char, ::xsd::cxx::tree::schema_type::double_ > L_traits;
const L_optional&
L () const;
L_optional&
L ();
void
L (const L_type& x);
void
L (const L_optional& x);
// n
//
typedef ::xml_schema::int_ n_type;
typedef ::xsd::cxx::tree::optional< n_type > n_optional;
typedef ::xsd::cxx::tree::traits< n_type, char > n_traits;
const n_optional&
n () const;
n_optional&
n ();
void
n (const n_type& x);
void
n (const n_optional& x);
// SParam
//
typedef ::xml_schema::string SParam_type;
typedef ::xsd::cxx::tree::optional< SParam_type > SParam_optional;
typedef ::xsd::cxx::tree::traits< SParam_type, char > SParam_traits;
const SParam_optional&
SParam () const;
SParam_optional&
SParam ();
void
SParam (const SParam_type& x);
void
SParam (const SParam_optional& x);
void
SParam (::std::unique_ptr< SParam_type > p);
// Constructors.
//
V1Simpson (const ID_type&);
V1Simpson (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V1Simpson (const V1Simpson& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V1Simpson*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V1Simpson&
operator= (const V1Simpson& x);
virtual
~V1Simpson ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
L_optional L_;
n_optional n_;
SParam_optional SParam_;
};
class V2Simpson: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// L
//
typedef ::xml_schema::double_ L_type;
typedef ::xsd::cxx::tree::optional< L_type > L_optional;
typedef ::xsd::cxx::tree::traits< L_type, char, ::xsd::cxx::tree::schema_type::double_ > L_traits;
const L_optional&
L () const;
L_optional&
L ();
void
L (const L_type& x);
void
L (const L_optional& x);
// n
//
typedef ::xml_schema::int_ n_type;
typedef ::xsd::cxx::tree::optional< n_type > n_optional;
typedef ::xsd::cxx::tree::traits< n_type, char > n_traits;
const n_optional&
n () const;
n_optional&
n ();
void
n (const n_type& x);
void
n (const n_optional& x);
// S
//
typedef ::xml_schema::double_ S_type;
typedef ::xsd::cxx::tree::optional< S_type > S_optional;
typedef ::xsd::cxx::tree::traits< S_type, char, ::xsd::cxx::tree::schema_type::double_ > S_traits;
const S_optional&
S () const;
S_optional&
S ();
void
S (const S_type& x);
void
S (const S_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// BParam
//
typedef ::xml_schema::string BParam_type;
typedef ::xsd::cxx::tree::optional< BParam_type > BParam_optional;
typedef ::xsd::cxx::tree::traits< BParam_type, char > BParam_traits;
const BParam_optional&
BParam () const;
BParam_optional&
BParam ();
void
BParam (const BParam_type& x);
void
BParam (const BParam_optional& x);
void
BParam (::std::unique_ptr< BParam_type > p);
// HParam
//
typedef ::xml_schema::string HParam_type;
typedef ::xsd::cxx::tree::optional< HParam_type > HParam_optional;
typedef ::xsd::cxx::tree::traits< HParam_type, char > HParam_traits;
const HParam_optional&
HParam () const;
HParam_optional&
HParam ();
void
HParam (const HParam_type& x);
void
HParam (const HParam_optional& x);
void
HParam (::std::unique_ptr< HParam_type > p);
// Constructors.
//
V2Simpson (const ID_type&);
V2Simpson (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V2Simpson (const V2Simpson& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V2Simpson*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V2Simpson&
operator= (const V2Simpson& x);
virtual
~V2Simpson ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
L_optional L_;
n_optional n_;
S_optional S_;
H_optional H_;
BParam_optional BParam_;
HParam_optional HParam_;
};
class V2Block: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// L
//
typedef ::xml_schema::double_ L_type;
typedef ::xsd::cxx::tree::optional< L_type > L_optional;
typedef ::xsd::cxx::tree::traits< L_type, char, ::xsd::cxx::tree::schema_type::double_ > L_traits;
const L_optional&
L () const;
L_optional&
L ();
void
L (const L_type& x);
void
L (const L_optional& x);
// B
//
typedef ::xml_schema::double_ B_type;
typedef ::xsd::cxx::tree::optional< B_type > B_optional;
typedef ::xsd::cxx::tree::traits< B_type, char, ::xsd::cxx::tree::schema_type::double_ > B_traits;
const B_optional&
B () const;
B_optional&
B ();
void
B (const B_type& x);
void
B (const B_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// Constructors.
//
V2Block (const ID_type&);
V2Block (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V2Block (const V2Block& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V2Block*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V2Block&
operator= (const V2Block& x);
virtual
~V2Block ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
L_optional L_;
B_optional B_;
H_optional H_;
};
class V2other: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// Constructors.
//
V2other (const ID_type&);
V2other (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V2other (const V2other& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V2other*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V2other&
operator= (const V2other& x);
virtual
~V2other ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
Remark_optional Remark_;
};
class V3: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Type
//
typedef ::xml_schema::int_ Type_type;
typedef ::xsd::cxx::tree::optional< Type_type > Type_optional;
typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;
const Type_optional&
Type () const;
Type_optional&
Type ();
void
Type (const Type_type& x);
void
Type (const Type_optional& x);
static Type_type
Type_default_value ();
// S
//
typedef ::xml_schema::double_ S_type;
typedef ::xsd::cxx::tree::optional< S_type > S_optional;
typedef ::xsd::cxx::tree::traits< S_type, char, ::xsd::cxx::tree::schema_type::double_ > S_traits;
const S_optional&
S () const;
S_optional&
S ();
void
S (const S_type& x);
void
S (const S_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// Constructors.
//
V3 (const ID_type&);
V3 (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V3 (const V3& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V3*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V3&
operator= (const V3& x);
virtual
~V3 ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
Type_optional Type_;
S_optional S_;
H_optional H_;
};
class V43: public ::xml_schema::type
{
public:
// Case
//
typedef ::xml_schema::string Case_type;
typedef ::xsd::cxx::tree::traits< Case_type, char > Case_traits;
const Case_type&
Case () const;
Case_type&
Case ();
void
Case (const Case_type& x);
void
Case (::std::unique_ptr< Case_type > p);
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// S
//
typedef ::xml_schema::double_ S_type;
typedef ::xsd::cxx::tree::optional< S_type > S_optional;
typedef ::xsd::cxx::tree::traits< S_type, char, ::xsd::cxx::tree::schema_type::double_ > S_traits;
const S_optional&
S () const;
S_optional&
S ();
void
S (const S_type& x);
void
S (const S_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// hc
//
typedef ::xml_schema::double_ hc_type;
typedef ::xsd::cxx::tree::optional< hc_type > hc_optional;
typedef ::xsd::cxx::tree::traits< hc_type, char, ::xsd::cxx::tree::schema_type::double_ > hc_traits;
const hc_optional&
hc () const;
hc_optional&
hc ();
void
hc (const hc_type& x);
void
hc (const hc_optional& x);
// Constructors.
//
V43 (const Case_type&,
const ID_type&);
V43 (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V43 (const V43& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V43*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V43&
operator= (const V43& x);
virtual
~V43 ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< Case_type > Case_;
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
S_optional S_;
H_optional H_;
hc_optional hc_;
};
class V41: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Type
//
typedef ::xml_schema::int_ Type_type;
typedef ::xsd::cxx::tree::optional< Type_type > Type_optional;
typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;
const Type_optional&
Type () const;
Type_optional&
Type ();
void
Type (const Type_type& x);
void
Type (const Type_optional& x);
static Type_type
Type_default_value ();
// S
//
typedef ::xml_schema::double_ S_type;
typedef ::xsd::cxx::tree::optional< S_type > S_optional;
typedef ::xsd::cxx::tree::traits< S_type, char, ::xsd::cxx::tree::schema_type::double_ > S_traits;
const S_optional&
S () const;
S_optional&
S ();
void
S (const S_type& x);
void
S (const S_optional& x);
// L
//
typedef ::xml_schema::double_ L_type;
typedef ::xsd::cxx::tree::optional< L_type > L_optional;
typedef ::xsd::cxx::tree::traits< L_type, char, ::xsd::cxx::tree::schema_type::double_ > L_traits;
const L_optional&
L () const;
L_optional&
L ();
void
L (const L_type& x);
void
L (const L_optional& x);
// B
//
typedef ::xml_schema::double_ B_type;
typedef ::xsd::cxx::tree::optional< B_type > B_optional;
typedef ::xsd::cxx::tree::traits< B_type, char, ::xsd::cxx::tree::schema_type::double_ > B_traits;
const B_optional&
B () const;
B_optional&
B ();
void
B (const B_type& x);
void
B (const B_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// Ha
//
typedef ::xml_schema::double_ Ha_type;
typedef ::xsd::cxx::tree::optional< Ha_type > Ha_optional;
typedef ::xsd::cxx::tree::traits< Ha_type, char, ::xsd::cxx::tree::schema_type::double_ > Ha_traits;
const Ha_optional&
Ha () const;
Ha_optional&
Ha ();
void
Ha (const Ha_type& x);
void
Ha (const Ha_optional& x);
// Constructors.
//
V41 (const ID_type&);
V41 (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V41 (const V41& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V41*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V41&
operator= (const V41& x);
virtual
~V41 ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
Type_optional Type_;
S_optional S_;
L_optional L_;
B_optional B_;
H_optional H_;
Ha_optional Ha_;
};
class V42: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// IsCar
//
typedef ::xml_schema::boolean IsCar_type;
typedef ::xsd::cxx::tree::traits< IsCar_type, char > IsCar_traits;
const IsCar_type&
IsCar () const;
IsCar_type&
IsCar ();
void
IsCar (const IsCar_type& x);
static IsCar_type
IsCar_default_value ();
// S
//
typedef ::xml_schema::double_ S_type;
typedef ::xsd::cxx::tree::optional< S_type > S_optional;
typedef ::xsd::cxx::tree::traits< S_type, char, ::xsd::cxx::tree::schema_type::double_ > S_traits;
const S_optional&
S () const;
S_optional&
S ();
void
S (const S_type& x);
void
S (const S_optional& x);
// H
//
typedef ::xml_schema::double_ H_type;
typedef ::xsd::cxx::tree::optional< H_type > H_optional;
typedef ::xsd::cxx::tree::traits< H_type, char, ::xsd::cxx::tree::schema_type::double_ > H_traits;
const H_optional&
H () const;
H_optional&
H ();
void
H (const H_type& x);
void
H (const H_optional& x);
// Hv
//
typedef ::xml_schema::double_ Hv_type;
typedef ::xsd::cxx::tree::optional< Hv_type > Hv_optional;
typedef ::xsd::cxx::tree::traits< Hv_type, char, ::xsd::cxx::tree::schema_type::double_ > Hv_traits;
const Hv_optional&
Hv () const;
Hv_optional&
Hv ();
void
Hv (const Hv_type& x);
void
Hv (const Hv_optional& x);
// Ha
//
typedef ::xml_schema::double_ Ha_type;
typedef ::xsd::cxx::tree::optional< Ha_type > Ha_optional;
typedef ::xsd::cxx::tree::traits< Ha_type, char, ::xsd::cxx::tree::schema_type::double_ > Ha_traits;
const Ha_optional&
Ha () const;
Ha_optional&
Ha ();
void
Ha (const Ha_type& x);
void
Ha (const Ha_optional& x);
// Constructors.
//
V42 (const ID_type&,
const IsCar_type&);
V42 (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V42 (const V42& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V42*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V42&
operator= (const V42& x);
virtual
~V42 ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
::xsd::cxx::tree::one< IsCar_type > IsCar_;
S_optional S_;
H_optional H_;
Hv_optional Hv_;
Ha_optional Ha_;
};
class V43Total: public ::xml_schema::type
{
public:
// Case
//
typedef ::xml_schema::string Case_type;
typedef ::xsd::cxx::tree::traits< Case_type, char > Case_traits;
const Case_type&
Case () const;
Case_type&
Case ();
void
Case (const Case_type& x);
void
Case (::std::unique_ptr< Case_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Constructors.
//
V43Total (const Case_type&);
V43Total (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V43Total (const V43Total& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V43Total*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V43Total&
operator= (const V43Total& x);
virtual
~V43Total ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< Case_type > Case_;
V_optional V_;
};
class V5: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// Constructors.
//
V5 (const ID_type&);
V5 (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V5 (const V5& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V5*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V5&
operator= (const V5& x);
virtual
~V5 ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
V_optional V_;
Remark_optional Remark_;
};
class V2Entity: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// EntityID
//
typedef ::xml_schema::string EntityID_type;
typedef ::xsd::cxx::tree::optional< EntityID_type > EntityID_optional;
typedef ::xsd::cxx::tree::traits< EntityID_type, char > EntityID_traits;
const EntityID_optional&
EntityID () const;
EntityID_optional&
EntityID ();
void
EntityID (const EntityID_type& x);
void
EntityID (const EntityID_optional& x);
void
EntityID (::std::unique_ptr< EntityID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// SID
//
typedef ::xml_schema::int_ SID_type;
typedef ::xsd::cxx::tree::optional< SID_type > SID_optional;
typedef ::xsd::cxx::tree::traits< SID_type, char > SID_traits;
const SID_optional&
SID () const;
SID_optional&
SID ();
void
SID (const SID_type& x);
void
SID (const SID_optional& x);
// Constructors.
//
V2Entity (const ID_type&);
V2Entity (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V2Entity (const V2Entity& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V2Entity*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V2Entity&
operator= (const V2Entity& x);
virtual
~V2Entity ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
EntityID_optional EntityID_;
V_optional V_;
Remark_optional Remark_;
SID_optional SID_;
};
class V1Entity: public ::xml_schema::type
{
public:
// ID
//
typedef ::xml_schema::string ID_type;
typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits;
const ID_type&
ID () const;
ID_type&
ID ();
void
ID (const ID_type& x);
void
ID (::std::unique_ptr< ID_type > p);
// EntityID
//
typedef ::xml_schema::string EntityID_type;
typedef ::xsd::cxx::tree::optional< EntityID_type > EntityID_optional;
typedef ::xsd::cxx::tree::traits< EntityID_type, char > EntityID_traits;
const EntityID_optional&
EntityID () const;
EntityID_optional&
EntityID ();
void
EntityID (const EntityID_type& x);
void
EntityID (const EntityID_optional& x);
void
EntityID (::std::unique_ptr< EntityID_type > p);
// V
//
typedef ::xml_schema::double_ V_type;
typedef ::xsd::cxx::tree::optional< V_type > V_optional;
typedef ::xsd::cxx::tree::traits< V_type, char, ::xsd::cxx::tree::schema_type::double_ > V_traits;
const V_optional&
V () const;
V_optional&
V ();
void
V (const V_type& x);
void
V (const V_optional& x);
// Remark
//
typedef ::xml_schema::string Remark_type;
typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;
const Remark_optional&
Remark () const;
Remark_optional&
Remark ();
void
Remark (const Remark_type& x);
void
Remark (const Remark_optional& x);
void
Remark (::std::unique_ptr< Remark_type > p);
// SID
//
typedef ::xml_schema::int_ SID_type;
typedef ::xsd::cxx::tree::optional< SID_type > SID_optional;
typedef ::xsd::cxx::tree::traits< SID_type, char > SID_traits;
const SID_optional&
SID () const;
SID_optional&
SID ();
void
SID (const SID_type& x);
void
SID (const SID_optional& x);
// Constructors.
//
V1Entity (const ID_type&);
V1Entity (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
V1Entity (const V1Entity& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
virtual V1Entity*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
V1Entity&
operator= (const V1Entity& x);
virtual
~V1Entity ();
// Implementation.
//
protected:
void
parse (::xsd::cxx::xml::dom::parser< char >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< ID_type > ID_;
EntityID_optional EntityID_;
V_optional V_;
Remark_optional Remark_;
SID_optional SID_;
};
}
#include <iosfwd>
#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
namespace tonnagemodel_ds
{
// Parse a URI or a local file.
//
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (const ::std::string& uri,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (const ::std::string& uri,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (const ::std::string& uri,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
// Parse std::istream.
//
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
const ::std::string& id,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
const ::std::string& id,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::std::istream& is,
const ::std::string& id,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
// Parse xercesc::InputSource.
//
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::xercesc::InputSource& is,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::xercesc::InputSource& is,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::xercesc::InputSource& is,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
// Parse xercesc::DOMDocument.
//
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (const ::xercesc::DOMDocument& d,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
TonnageModelDS_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
}
#include <iosfwd>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
namespace tonnagemodel_ds
{
// Serialize to std::ostream.
//
void
TonnageModelDS_ (::std::ostream& os,
const ::tonnagemodel_ds::TonnageModelDS& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
void
TonnageModelDS_ (::std::ostream& os,
const ::tonnagemodel_ds::TonnageModelDS& x,
::xml_schema::error_handler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
void
TonnageModelDS_ (::std::ostream& os,
const ::tonnagemodel_ds::TonnageModelDS& x,
::xercesc::DOMErrorHandler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
// Serialize to xercesc::XMLFormatTarget.
//
void
TonnageModelDS_ (::xercesc::XMLFormatTarget& ft,
const ::tonnagemodel_ds::TonnageModelDS& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
void
TonnageModelDS_ (::xercesc::XMLFormatTarget& ft,
const ::tonnagemodel_ds::TonnageModelDS& x,
::xml_schema::error_handler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
void
TonnageModelDS_ (::xercesc::XMLFormatTarget& ft,
const ::tonnagemodel_ds::TonnageModelDS& x,
::xercesc::DOMErrorHandler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::string& e = "UTF-8",
::xml_schema::flags f = 0);
// Serialize to an existing xercesc::DOMDocument.
//
void
TonnageModelDS_ (::xercesc::DOMDocument& d,
const ::tonnagemodel_ds::TonnageModelDS& x,
::xml_schema::flags f = 0);
// Serialize to a new xercesc::DOMDocument.
//
::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
TonnageModelDS_ (const ::tonnagemodel_ds::TonnageModelDS& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
::xml_schema::flags f = 0);
void
operator<< (::xercesc::DOMElement&, const TonnageModelDS&);
void
operator<< (::xercesc::DOMElement&, const BInf&);
void
operator<< (::xercesc::DOMElement&, const V1Inf&);
void
operator<< (::xercesc::DOMElement&, const V1Simpson&);
void
operator<< (::xercesc::DOMElement&, const V2Simpson&);
void
operator<< (::xercesc::DOMElement&, const V2Block&);
void
operator<< (::xercesc::DOMElement&, const V2other&);
void
operator<< (::xercesc::DOMElement&, const V3&);
void
operator<< (::xercesc::DOMElement&, const V43&);
void
operator<< (::xercesc::DOMElement&, const V41&);
void
operator<< (::xercesc::DOMElement&, const V42&);
void
operator<< (::xercesc::DOMElement&, const V43Total&);
void
operator<< (::xercesc::DOMElement&, const V5&);
void
operator<< (::xercesc::DOMElement&, const V2Entity&);
void
operator<< (::xercesc::DOMElement&, const V1Entity&);
}
#include <xsd/cxx/post.hxx>
// Begin epilogue.
//
//
// End epilogue.
#endif // CXX__TONNAGE_MODEL_DS_HXX