9830 lines
223 KiB
C++
9830 lines
223 KiB
C++
// 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 MODEL_DS_HXX
|
|
#define 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 model_ds
|
|
{
|
|
class ModelDS;
|
|
class LWT;
|
|
class ImmersionPoint;
|
|
class LimitStaticPoint;
|
|
class WindFixed;
|
|
class Case;
|
|
class WindNonFixed;
|
|
class OtherHeel;
|
|
class Pull;
|
|
class Jet;
|
|
class Lift;
|
|
class Sidesway;
|
|
class Pile;
|
|
class MudAsym;
|
|
class Mud;
|
|
class DamCase;
|
|
class DamCompartment;
|
|
class BInf;
|
|
class XLabel;
|
|
class Compartment;
|
|
class FloodPoint;
|
|
class Deckline;
|
|
class IncliningExtraWeight;
|
|
class IncliningAbsentWeight;
|
|
class IncliningMobileWeight;
|
|
class IncliningRelocateWeight;
|
|
class IncliningStatus;
|
|
class IncliningDevice;
|
|
class IncliningDraft;
|
|
class IncliningTank;
|
|
class IncliningCase;
|
|
class IncliningRecord;
|
|
class Shell;
|
|
class PartialLoad;
|
|
class PartialLoadItem;
|
|
class StationLabel;
|
|
class WaterlineLabel;
|
|
class ButtocklineLabel;
|
|
class PartialLoadWeight;
|
|
class PartialLoadFreeSurf;
|
|
class PartialLoadPerson;
|
|
class PartialLoadBulk;
|
|
class OilRecover;
|
|
class PartialLoadIce;
|
|
class SuspendLoad;
|
|
class Fishing;
|
|
class CompExtent;
|
|
class DamRegion;
|
|
class DamCompartmentProb;
|
|
class DamCaseProb;
|
|
class AllowNM;
|
|
}
|
|
|
|
|
|
#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 model_ds
|
|
{
|
|
class ModelDS: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// LWT
|
|
//
|
|
typedef ::model_ds::LWT LWT_type;
|
|
typedef ::xsd::cxx::tree::sequence< LWT_type > LWT_sequence;
|
|
typedef LWT_sequence::iterator LWT_iterator;
|
|
typedef LWT_sequence::const_iterator LWT_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< LWT_type, char > LWT_traits;
|
|
|
|
const LWT_sequence&
|
|
LWT () const;
|
|
|
|
LWT_sequence&
|
|
LWT ();
|
|
|
|
void
|
|
LWT (const LWT_sequence& s);
|
|
|
|
// ImmersionPoint
|
|
//
|
|
typedef ::model_ds::ImmersionPoint ImmersionPoint_type;
|
|
typedef ::xsd::cxx::tree::sequence< ImmersionPoint_type > ImmersionPoint_sequence;
|
|
typedef ImmersionPoint_sequence::iterator ImmersionPoint_iterator;
|
|
typedef ImmersionPoint_sequence::const_iterator ImmersionPoint_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ImmersionPoint_type, char > ImmersionPoint_traits;
|
|
|
|
const ImmersionPoint_sequence&
|
|
ImmersionPoint () const;
|
|
|
|
ImmersionPoint_sequence&
|
|
ImmersionPoint ();
|
|
|
|
void
|
|
ImmersionPoint (const ImmersionPoint_sequence& s);
|
|
|
|
// LimitStaticPoint
|
|
//
|
|
typedef ::model_ds::LimitStaticPoint LimitStaticPoint_type;
|
|
typedef ::xsd::cxx::tree::sequence< LimitStaticPoint_type > LimitStaticPoint_sequence;
|
|
typedef LimitStaticPoint_sequence::iterator LimitStaticPoint_iterator;
|
|
typedef LimitStaticPoint_sequence::const_iterator LimitStaticPoint_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< LimitStaticPoint_type, char > LimitStaticPoint_traits;
|
|
|
|
const LimitStaticPoint_sequence&
|
|
LimitStaticPoint () const;
|
|
|
|
LimitStaticPoint_sequence&
|
|
LimitStaticPoint ();
|
|
|
|
void
|
|
LimitStaticPoint (const LimitStaticPoint_sequence& s);
|
|
|
|
// WindFixed
|
|
//
|
|
typedef ::model_ds::WindFixed WindFixed_type;
|
|
typedef ::xsd::cxx::tree::sequence< WindFixed_type > WindFixed_sequence;
|
|
typedef WindFixed_sequence::iterator WindFixed_iterator;
|
|
typedef WindFixed_sequence::const_iterator WindFixed_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< WindFixed_type, char > WindFixed_traits;
|
|
|
|
const WindFixed_sequence&
|
|
WindFixed () const;
|
|
|
|
WindFixed_sequence&
|
|
WindFixed ();
|
|
|
|
void
|
|
WindFixed (const WindFixed_sequence& s);
|
|
|
|
// Case
|
|
//
|
|
typedef ::model_ds::Case Case_type;
|
|
typedef ::xsd::cxx::tree::sequence< Case_type > Case_sequence;
|
|
typedef Case_sequence::iterator Case_iterator;
|
|
typedef Case_sequence::const_iterator Case_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Case_type, char > Case_traits;
|
|
|
|
const Case_sequence&
|
|
Case () const;
|
|
|
|
Case_sequence&
|
|
Case ();
|
|
|
|
void
|
|
Case (const Case_sequence& s);
|
|
|
|
// WindNonFixed
|
|
//
|
|
typedef ::model_ds::WindNonFixed WindNonFixed_type;
|
|
typedef ::xsd::cxx::tree::sequence< WindNonFixed_type > WindNonFixed_sequence;
|
|
typedef WindNonFixed_sequence::iterator WindNonFixed_iterator;
|
|
typedef WindNonFixed_sequence::const_iterator WindNonFixed_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< WindNonFixed_type, char > WindNonFixed_traits;
|
|
|
|
const WindNonFixed_sequence&
|
|
WindNonFixed () const;
|
|
|
|
WindNonFixed_sequence&
|
|
WindNonFixed ();
|
|
|
|
void
|
|
WindNonFixed (const WindNonFixed_sequence& s);
|
|
|
|
// OtherHeel
|
|
//
|
|
typedef ::model_ds::OtherHeel OtherHeel_type;
|
|
typedef ::xsd::cxx::tree::sequence< OtherHeel_type > OtherHeel_sequence;
|
|
typedef OtherHeel_sequence::iterator OtherHeel_iterator;
|
|
typedef OtherHeel_sequence::const_iterator OtherHeel_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< OtherHeel_type, char > OtherHeel_traits;
|
|
|
|
const OtherHeel_sequence&
|
|
OtherHeel () const;
|
|
|
|
OtherHeel_sequence&
|
|
OtherHeel ();
|
|
|
|
void
|
|
OtherHeel (const OtherHeel_sequence& s);
|
|
|
|
// Pull
|
|
//
|
|
typedef ::model_ds::Pull Pull_type;
|
|
typedef ::xsd::cxx::tree::sequence< Pull_type > Pull_sequence;
|
|
typedef Pull_sequence::iterator Pull_iterator;
|
|
typedef Pull_sequence::const_iterator Pull_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Pull_type, char > Pull_traits;
|
|
|
|
const Pull_sequence&
|
|
Pull () const;
|
|
|
|
Pull_sequence&
|
|
Pull ();
|
|
|
|
void
|
|
Pull (const Pull_sequence& s);
|
|
|
|
// Jet
|
|
//
|
|
typedef ::model_ds::Jet Jet_type;
|
|
typedef ::xsd::cxx::tree::sequence< Jet_type > Jet_sequence;
|
|
typedef Jet_sequence::iterator Jet_iterator;
|
|
typedef Jet_sequence::const_iterator Jet_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Jet_type, char > Jet_traits;
|
|
|
|
const Jet_sequence&
|
|
Jet () const;
|
|
|
|
Jet_sequence&
|
|
Jet ();
|
|
|
|
void
|
|
Jet (const Jet_sequence& s);
|
|
|
|
// Lift
|
|
//
|
|
typedef ::model_ds::Lift Lift_type;
|
|
typedef ::xsd::cxx::tree::sequence< Lift_type > Lift_sequence;
|
|
typedef Lift_sequence::iterator Lift_iterator;
|
|
typedef Lift_sequence::const_iterator Lift_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Lift_type, char > Lift_traits;
|
|
|
|
const Lift_sequence&
|
|
Lift () const;
|
|
|
|
Lift_sequence&
|
|
Lift ();
|
|
|
|
void
|
|
Lift (const Lift_sequence& s);
|
|
|
|
// Sidesway
|
|
//
|
|
typedef ::model_ds::Sidesway Sidesway_type;
|
|
typedef ::xsd::cxx::tree::sequence< Sidesway_type > Sidesway_sequence;
|
|
typedef Sidesway_sequence::iterator Sidesway_iterator;
|
|
typedef Sidesway_sequence::const_iterator Sidesway_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Sidesway_type, char > Sidesway_traits;
|
|
|
|
const Sidesway_sequence&
|
|
Sidesway () const;
|
|
|
|
Sidesway_sequence&
|
|
Sidesway ();
|
|
|
|
void
|
|
Sidesway (const Sidesway_sequence& s);
|
|
|
|
// Pile
|
|
//
|
|
typedef ::model_ds::Pile Pile_type;
|
|
typedef ::xsd::cxx::tree::sequence< Pile_type > Pile_sequence;
|
|
typedef Pile_sequence::iterator Pile_iterator;
|
|
typedef Pile_sequence::const_iterator Pile_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Pile_type, char > Pile_traits;
|
|
|
|
const Pile_sequence&
|
|
Pile () const;
|
|
|
|
Pile_sequence&
|
|
Pile ();
|
|
|
|
void
|
|
Pile (const Pile_sequence& s);
|
|
|
|
// MudAsym
|
|
//
|
|
typedef ::model_ds::MudAsym MudAsym_type;
|
|
typedef ::xsd::cxx::tree::sequence< MudAsym_type > MudAsym_sequence;
|
|
typedef MudAsym_sequence::iterator MudAsym_iterator;
|
|
typedef MudAsym_sequence::const_iterator MudAsym_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< MudAsym_type, char > MudAsym_traits;
|
|
|
|
const MudAsym_sequence&
|
|
MudAsym () const;
|
|
|
|
MudAsym_sequence&
|
|
MudAsym ();
|
|
|
|
void
|
|
MudAsym (const MudAsym_sequence& s);
|
|
|
|
// Mud
|
|
//
|
|
typedef ::model_ds::Mud Mud_type;
|
|
typedef ::xsd::cxx::tree::sequence< Mud_type > Mud_sequence;
|
|
typedef Mud_sequence::iterator Mud_iterator;
|
|
typedef Mud_sequence::const_iterator Mud_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Mud_type, char > Mud_traits;
|
|
|
|
const Mud_sequence&
|
|
Mud () const;
|
|
|
|
Mud_sequence&
|
|
Mud ();
|
|
|
|
void
|
|
Mud (const Mud_sequence& s);
|
|
|
|
// DamCase
|
|
//
|
|
typedef ::model_ds::DamCase DamCase_type;
|
|
typedef ::xsd::cxx::tree::sequence< DamCase_type > DamCase_sequence;
|
|
typedef DamCase_sequence::iterator DamCase_iterator;
|
|
typedef DamCase_sequence::const_iterator DamCase_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< DamCase_type, char > DamCase_traits;
|
|
|
|
const DamCase_sequence&
|
|
DamCase () const;
|
|
|
|
DamCase_sequence&
|
|
DamCase ();
|
|
|
|
void
|
|
DamCase (const DamCase_sequence& s);
|
|
|
|
// DamCompartment
|
|
//
|
|
typedef ::model_ds::DamCompartment DamCompartment_type;
|
|
typedef ::xsd::cxx::tree::sequence< DamCompartment_type > DamCompartment_sequence;
|
|
typedef DamCompartment_sequence::iterator DamCompartment_iterator;
|
|
typedef DamCompartment_sequence::const_iterator DamCompartment_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< DamCompartment_type, char > DamCompartment_traits;
|
|
|
|
const DamCompartment_sequence&
|
|
DamCompartment () const;
|
|
|
|
DamCompartment_sequence&
|
|
DamCompartment ();
|
|
|
|
void
|
|
DamCompartment (const DamCompartment_sequence& s);
|
|
|
|
// BInf
|
|
//
|
|
typedef ::model_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);
|
|
|
|
// XLabel
|
|
//
|
|
typedef ::model_ds::XLabel XLabel_type;
|
|
typedef ::xsd::cxx::tree::sequence< XLabel_type > XLabel_sequence;
|
|
typedef XLabel_sequence::iterator XLabel_iterator;
|
|
typedef XLabel_sequence::const_iterator XLabel_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< XLabel_type, char > XLabel_traits;
|
|
|
|
const XLabel_sequence&
|
|
XLabel () const;
|
|
|
|
XLabel_sequence&
|
|
XLabel ();
|
|
|
|
void
|
|
XLabel (const XLabel_sequence& s);
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::model_ds::Compartment Compartment_type;
|
|
typedef ::xsd::cxx::tree::sequence< Compartment_type > Compartment_sequence;
|
|
typedef Compartment_sequence::iterator Compartment_iterator;
|
|
typedef Compartment_sequence::const_iterator Compartment_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_sequence&
|
|
Compartment () const;
|
|
|
|
Compartment_sequence&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_sequence& s);
|
|
|
|
// FloodPoint
|
|
//
|
|
typedef ::model_ds::FloodPoint FloodPoint_type;
|
|
typedef ::xsd::cxx::tree::sequence< FloodPoint_type > FloodPoint_sequence;
|
|
typedef FloodPoint_sequence::iterator FloodPoint_iterator;
|
|
typedef FloodPoint_sequence::const_iterator FloodPoint_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< FloodPoint_type, char > FloodPoint_traits;
|
|
|
|
const FloodPoint_sequence&
|
|
FloodPoint () const;
|
|
|
|
FloodPoint_sequence&
|
|
FloodPoint ();
|
|
|
|
void
|
|
FloodPoint (const FloodPoint_sequence& s);
|
|
|
|
// Deckline
|
|
//
|
|
typedef ::model_ds::Deckline Deckline_type;
|
|
typedef ::xsd::cxx::tree::sequence< Deckline_type > Deckline_sequence;
|
|
typedef Deckline_sequence::iterator Deckline_iterator;
|
|
typedef Deckline_sequence::const_iterator Deckline_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Deckline_type, char > Deckline_traits;
|
|
|
|
const Deckline_sequence&
|
|
Deckline () const;
|
|
|
|
Deckline_sequence&
|
|
Deckline ();
|
|
|
|
void
|
|
Deckline (const Deckline_sequence& s);
|
|
|
|
// IncliningExtraWeight
|
|
//
|
|
typedef ::model_ds::IncliningExtraWeight IncliningExtraWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningExtraWeight_type > IncliningExtraWeight_sequence;
|
|
typedef IncliningExtraWeight_sequence::iterator IncliningExtraWeight_iterator;
|
|
typedef IncliningExtraWeight_sequence::const_iterator IncliningExtraWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningExtraWeight_type, char > IncliningExtraWeight_traits;
|
|
|
|
const IncliningExtraWeight_sequence&
|
|
IncliningExtraWeight () const;
|
|
|
|
IncliningExtraWeight_sequence&
|
|
IncliningExtraWeight ();
|
|
|
|
void
|
|
IncliningExtraWeight (const IncliningExtraWeight_sequence& s);
|
|
|
|
// IncliningAbsentWeight
|
|
//
|
|
typedef ::model_ds::IncliningAbsentWeight IncliningAbsentWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningAbsentWeight_type > IncliningAbsentWeight_sequence;
|
|
typedef IncliningAbsentWeight_sequence::iterator IncliningAbsentWeight_iterator;
|
|
typedef IncliningAbsentWeight_sequence::const_iterator IncliningAbsentWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningAbsentWeight_type, char > IncliningAbsentWeight_traits;
|
|
|
|
const IncliningAbsentWeight_sequence&
|
|
IncliningAbsentWeight () const;
|
|
|
|
IncliningAbsentWeight_sequence&
|
|
IncliningAbsentWeight ();
|
|
|
|
void
|
|
IncliningAbsentWeight (const IncliningAbsentWeight_sequence& s);
|
|
|
|
// IncliningMobileWeight
|
|
//
|
|
typedef ::model_ds::IncliningMobileWeight IncliningMobileWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningMobileWeight_type > IncliningMobileWeight_sequence;
|
|
typedef IncliningMobileWeight_sequence::iterator IncliningMobileWeight_iterator;
|
|
typedef IncliningMobileWeight_sequence::const_iterator IncliningMobileWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningMobileWeight_type, char > IncliningMobileWeight_traits;
|
|
|
|
const IncliningMobileWeight_sequence&
|
|
IncliningMobileWeight () const;
|
|
|
|
IncliningMobileWeight_sequence&
|
|
IncliningMobileWeight ();
|
|
|
|
void
|
|
IncliningMobileWeight (const IncliningMobileWeight_sequence& s);
|
|
|
|
// IncliningRelocateWeight
|
|
//
|
|
typedef ::model_ds::IncliningRelocateWeight IncliningRelocateWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningRelocateWeight_type > IncliningRelocateWeight_sequence;
|
|
typedef IncliningRelocateWeight_sequence::iterator IncliningRelocateWeight_iterator;
|
|
typedef IncliningRelocateWeight_sequence::const_iterator IncliningRelocateWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningRelocateWeight_type, char > IncliningRelocateWeight_traits;
|
|
|
|
const IncliningRelocateWeight_sequence&
|
|
IncliningRelocateWeight () const;
|
|
|
|
IncliningRelocateWeight_sequence&
|
|
IncliningRelocateWeight ();
|
|
|
|
void
|
|
IncliningRelocateWeight (const IncliningRelocateWeight_sequence& s);
|
|
|
|
// IncliningStatus
|
|
//
|
|
typedef ::model_ds::IncliningStatus IncliningStatus_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningStatus_type > IncliningStatus_sequence;
|
|
typedef IncliningStatus_sequence::iterator IncliningStatus_iterator;
|
|
typedef IncliningStatus_sequence::const_iterator IncliningStatus_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningStatus_type, char > IncliningStatus_traits;
|
|
|
|
const IncliningStatus_sequence&
|
|
IncliningStatus () const;
|
|
|
|
IncliningStatus_sequence&
|
|
IncliningStatus ();
|
|
|
|
void
|
|
IncliningStatus (const IncliningStatus_sequence& s);
|
|
|
|
// IncliningDevice
|
|
//
|
|
typedef ::model_ds::IncliningDevice IncliningDevice_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningDevice_type > IncliningDevice_sequence;
|
|
typedef IncliningDevice_sequence::iterator IncliningDevice_iterator;
|
|
typedef IncliningDevice_sequence::const_iterator IncliningDevice_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningDevice_type, char > IncliningDevice_traits;
|
|
|
|
const IncliningDevice_sequence&
|
|
IncliningDevice () const;
|
|
|
|
IncliningDevice_sequence&
|
|
IncliningDevice ();
|
|
|
|
void
|
|
IncliningDevice (const IncliningDevice_sequence& s);
|
|
|
|
// IncliningDraft
|
|
//
|
|
typedef ::model_ds::IncliningDraft IncliningDraft_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningDraft_type > IncliningDraft_sequence;
|
|
typedef IncliningDraft_sequence::iterator IncliningDraft_iterator;
|
|
typedef IncliningDraft_sequence::const_iterator IncliningDraft_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningDraft_type, char > IncliningDraft_traits;
|
|
|
|
const IncliningDraft_sequence&
|
|
IncliningDraft () const;
|
|
|
|
IncliningDraft_sequence&
|
|
IncliningDraft ();
|
|
|
|
void
|
|
IncliningDraft (const IncliningDraft_sequence& s);
|
|
|
|
// IncliningTank
|
|
//
|
|
typedef ::model_ds::IncliningTank IncliningTank_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningTank_type > IncliningTank_sequence;
|
|
typedef IncliningTank_sequence::iterator IncliningTank_iterator;
|
|
typedef IncliningTank_sequence::const_iterator IncliningTank_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningTank_type, char > IncliningTank_traits;
|
|
|
|
const IncliningTank_sequence&
|
|
IncliningTank () const;
|
|
|
|
IncliningTank_sequence&
|
|
IncliningTank ();
|
|
|
|
void
|
|
IncliningTank (const IncliningTank_sequence& s);
|
|
|
|
// IncliningCase
|
|
//
|
|
typedef ::model_ds::IncliningCase IncliningCase_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningCase_type > IncliningCase_sequence;
|
|
typedef IncliningCase_sequence::iterator IncliningCase_iterator;
|
|
typedef IncliningCase_sequence::const_iterator IncliningCase_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningCase_type, char > IncliningCase_traits;
|
|
|
|
const IncliningCase_sequence&
|
|
IncliningCase () const;
|
|
|
|
IncliningCase_sequence&
|
|
IncliningCase ();
|
|
|
|
void
|
|
IncliningCase (const IncliningCase_sequence& s);
|
|
|
|
// IncliningRecord
|
|
//
|
|
typedef ::model_ds::IncliningRecord IncliningRecord_type;
|
|
typedef ::xsd::cxx::tree::sequence< IncliningRecord_type > IncliningRecord_sequence;
|
|
typedef IncliningRecord_sequence::iterator IncliningRecord_iterator;
|
|
typedef IncliningRecord_sequence::const_iterator IncliningRecord_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< IncliningRecord_type, char > IncliningRecord_traits;
|
|
|
|
const IncliningRecord_sequence&
|
|
IncliningRecord () const;
|
|
|
|
IncliningRecord_sequence&
|
|
IncliningRecord ();
|
|
|
|
void
|
|
IncliningRecord (const IncliningRecord_sequence& s);
|
|
|
|
// Shell
|
|
//
|
|
typedef ::model_ds::Shell Shell_type;
|
|
typedef ::xsd::cxx::tree::sequence< Shell_type > Shell_sequence;
|
|
typedef Shell_sequence::iterator Shell_iterator;
|
|
typedef Shell_sequence::const_iterator Shell_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Shell_type, char > Shell_traits;
|
|
|
|
const Shell_sequence&
|
|
Shell () const;
|
|
|
|
Shell_sequence&
|
|
Shell ();
|
|
|
|
void
|
|
Shell (const Shell_sequence& s);
|
|
|
|
// PartialLoad
|
|
//
|
|
typedef ::model_ds::PartialLoad PartialLoad_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoad_type > PartialLoad_sequence;
|
|
typedef PartialLoad_sequence::iterator PartialLoad_iterator;
|
|
typedef PartialLoad_sequence::const_iterator PartialLoad_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoad_type, char > PartialLoad_traits;
|
|
|
|
const PartialLoad_sequence&
|
|
PartialLoad () const;
|
|
|
|
PartialLoad_sequence&
|
|
PartialLoad ();
|
|
|
|
void
|
|
PartialLoad (const PartialLoad_sequence& s);
|
|
|
|
// PartialLoadItem
|
|
//
|
|
typedef ::model_ds::PartialLoadItem PartialLoadItem_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadItem_type > PartialLoadItem_sequence;
|
|
typedef PartialLoadItem_sequence::iterator PartialLoadItem_iterator;
|
|
typedef PartialLoadItem_sequence::const_iterator PartialLoadItem_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadItem_type, char > PartialLoadItem_traits;
|
|
|
|
const PartialLoadItem_sequence&
|
|
PartialLoadItem () const;
|
|
|
|
PartialLoadItem_sequence&
|
|
PartialLoadItem ();
|
|
|
|
void
|
|
PartialLoadItem (const PartialLoadItem_sequence& s);
|
|
|
|
// StationLabel
|
|
//
|
|
typedef ::model_ds::StationLabel StationLabel_type;
|
|
typedef ::xsd::cxx::tree::sequence< StationLabel_type > StationLabel_sequence;
|
|
typedef StationLabel_sequence::iterator StationLabel_iterator;
|
|
typedef StationLabel_sequence::const_iterator StationLabel_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< StationLabel_type, char > StationLabel_traits;
|
|
|
|
const StationLabel_sequence&
|
|
StationLabel () const;
|
|
|
|
StationLabel_sequence&
|
|
StationLabel ();
|
|
|
|
void
|
|
StationLabel (const StationLabel_sequence& s);
|
|
|
|
// WaterlineLabel
|
|
//
|
|
typedef ::model_ds::WaterlineLabel WaterlineLabel_type;
|
|
typedef ::xsd::cxx::tree::sequence< WaterlineLabel_type > WaterlineLabel_sequence;
|
|
typedef WaterlineLabel_sequence::iterator WaterlineLabel_iterator;
|
|
typedef WaterlineLabel_sequence::const_iterator WaterlineLabel_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< WaterlineLabel_type, char > WaterlineLabel_traits;
|
|
|
|
const WaterlineLabel_sequence&
|
|
WaterlineLabel () const;
|
|
|
|
WaterlineLabel_sequence&
|
|
WaterlineLabel ();
|
|
|
|
void
|
|
WaterlineLabel (const WaterlineLabel_sequence& s);
|
|
|
|
// ButtocklineLabel
|
|
//
|
|
typedef ::model_ds::ButtocklineLabel ButtocklineLabel_type;
|
|
typedef ::xsd::cxx::tree::sequence< ButtocklineLabel_type > ButtocklineLabel_sequence;
|
|
typedef ButtocklineLabel_sequence::iterator ButtocklineLabel_iterator;
|
|
typedef ButtocklineLabel_sequence::const_iterator ButtocklineLabel_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ButtocklineLabel_type, char > ButtocklineLabel_traits;
|
|
|
|
const ButtocklineLabel_sequence&
|
|
ButtocklineLabel () const;
|
|
|
|
ButtocklineLabel_sequence&
|
|
ButtocklineLabel ();
|
|
|
|
void
|
|
ButtocklineLabel (const ButtocklineLabel_sequence& s);
|
|
|
|
// PartialLoadWeight
|
|
//
|
|
typedef ::model_ds::PartialLoadWeight PartialLoadWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadWeight_type > PartialLoadWeight_sequence;
|
|
typedef PartialLoadWeight_sequence::iterator PartialLoadWeight_iterator;
|
|
typedef PartialLoadWeight_sequence::const_iterator PartialLoadWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadWeight_type, char > PartialLoadWeight_traits;
|
|
|
|
const PartialLoadWeight_sequence&
|
|
PartialLoadWeight () const;
|
|
|
|
PartialLoadWeight_sequence&
|
|
PartialLoadWeight ();
|
|
|
|
void
|
|
PartialLoadWeight (const PartialLoadWeight_sequence& s);
|
|
|
|
// PartialLoadFreeSurf
|
|
//
|
|
typedef ::model_ds::PartialLoadFreeSurf PartialLoadFreeSurf_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadFreeSurf_type > PartialLoadFreeSurf_sequence;
|
|
typedef PartialLoadFreeSurf_sequence::iterator PartialLoadFreeSurf_iterator;
|
|
typedef PartialLoadFreeSurf_sequence::const_iterator PartialLoadFreeSurf_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadFreeSurf_type, char > PartialLoadFreeSurf_traits;
|
|
|
|
const PartialLoadFreeSurf_sequence&
|
|
PartialLoadFreeSurf () const;
|
|
|
|
PartialLoadFreeSurf_sequence&
|
|
PartialLoadFreeSurf ();
|
|
|
|
void
|
|
PartialLoadFreeSurf (const PartialLoadFreeSurf_sequence& s);
|
|
|
|
// PartialLoadPerson
|
|
//
|
|
typedef ::model_ds::PartialLoadPerson PartialLoadPerson_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadPerson_type > PartialLoadPerson_sequence;
|
|
typedef PartialLoadPerson_sequence::iterator PartialLoadPerson_iterator;
|
|
typedef PartialLoadPerson_sequence::const_iterator PartialLoadPerson_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadPerson_type, char > PartialLoadPerson_traits;
|
|
|
|
const PartialLoadPerson_sequence&
|
|
PartialLoadPerson () const;
|
|
|
|
PartialLoadPerson_sequence&
|
|
PartialLoadPerson ();
|
|
|
|
void
|
|
PartialLoadPerson (const PartialLoadPerson_sequence& s);
|
|
|
|
// PartialLoadBulk
|
|
//
|
|
typedef ::model_ds::PartialLoadBulk PartialLoadBulk_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadBulk_type > PartialLoadBulk_sequence;
|
|
typedef PartialLoadBulk_sequence::iterator PartialLoadBulk_iterator;
|
|
typedef PartialLoadBulk_sequence::const_iterator PartialLoadBulk_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadBulk_type, char > PartialLoadBulk_traits;
|
|
|
|
const PartialLoadBulk_sequence&
|
|
PartialLoadBulk () const;
|
|
|
|
PartialLoadBulk_sequence&
|
|
PartialLoadBulk ();
|
|
|
|
void
|
|
PartialLoadBulk (const PartialLoadBulk_sequence& s);
|
|
|
|
// OilRecover
|
|
//
|
|
typedef ::model_ds::OilRecover OilRecover_type;
|
|
typedef ::xsd::cxx::tree::sequence< OilRecover_type > OilRecover_sequence;
|
|
typedef OilRecover_sequence::iterator OilRecover_iterator;
|
|
typedef OilRecover_sequence::const_iterator OilRecover_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< OilRecover_type, char > OilRecover_traits;
|
|
|
|
const OilRecover_sequence&
|
|
OilRecover () const;
|
|
|
|
OilRecover_sequence&
|
|
OilRecover ();
|
|
|
|
void
|
|
OilRecover (const OilRecover_sequence& s);
|
|
|
|
// PartialLoadIce
|
|
//
|
|
typedef ::model_ds::PartialLoadIce PartialLoadIce_type;
|
|
typedef ::xsd::cxx::tree::sequence< PartialLoadIce_type > PartialLoadIce_sequence;
|
|
typedef PartialLoadIce_sequence::iterator PartialLoadIce_iterator;
|
|
typedef PartialLoadIce_sequence::const_iterator PartialLoadIce_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadIce_type, char > PartialLoadIce_traits;
|
|
|
|
const PartialLoadIce_sequence&
|
|
PartialLoadIce () const;
|
|
|
|
PartialLoadIce_sequence&
|
|
PartialLoadIce ();
|
|
|
|
void
|
|
PartialLoadIce (const PartialLoadIce_sequence& s);
|
|
|
|
// SuspendLoad
|
|
//
|
|
typedef ::model_ds::SuspendLoad SuspendLoad_type;
|
|
typedef ::xsd::cxx::tree::sequence< SuspendLoad_type > SuspendLoad_sequence;
|
|
typedef SuspendLoad_sequence::iterator SuspendLoad_iterator;
|
|
typedef SuspendLoad_sequence::const_iterator SuspendLoad_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SuspendLoad_type, char > SuspendLoad_traits;
|
|
|
|
const SuspendLoad_sequence&
|
|
SuspendLoad () const;
|
|
|
|
SuspendLoad_sequence&
|
|
SuspendLoad ();
|
|
|
|
void
|
|
SuspendLoad (const SuspendLoad_sequence& s);
|
|
|
|
// Fishing
|
|
//
|
|
typedef ::model_ds::Fishing Fishing_type;
|
|
typedef ::xsd::cxx::tree::sequence< Fishing_type > Fishing_sequence;
|
|
typedef Fishing_sequence::iterator Fishing_iterator;
|
|
typedef Fishing_sequence::const_iterator Fishing_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Fishing_type, char > Fishing_traits;
|
|
|
|
const Fishing_sequence&
|
|
Fishing () const;
|
|
|
|
Fishing_sequence&
|
|
Fishing ();
|
|
|
|
void
|
|
Fishing (const Fishing_sequence& s);
|
|
|
|
// CompExtent
|
|
//
|
|
typedef ::model_ds::CompExtent CompExtent_type;
|
|
typedef ::xsd::cxx::tree::sequence< CompExtent_type > CompExtent_sequence;
|
|
typedef CompExtent_sequence::iterator CompExtent_iterator;
|
|
typedef CompExtent_sequence::const_iterator CompExtent_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< CompExtent_type, char > CompExtent_traits;
|
|
|
|
const CompExtent_sequence&
|
|
CompExtent () const;
|
|
|
|
CompExtent_sequence&
|
|
CompExtent ();
|
|
|
|
void
|
|
CompExtent (const CompExtent_sequence& s);
|
|
|
|
// DamRegion
|
|
//
|
|
typedef ::model_ds::DamRegion DamRegion_type;
|
|
typedef ::xsd::cxx::tree::sequence< DamRegion_type > DamRegion_sequence;
|
|
typedef DamRegion_sequence::iterator DamRegion_iterator;
|
|
typedef DamRegion_sequence::const_iterator DamRegion_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< DamRegion_type, char > DamRegion_traits;
|
|
|
|
const DamRegion_sequence&
|
|
DamRegion () const;
|
|
|
|
DamRegion_sequence&
|
|
DamRegion ();
|
|
|
|
void
|
|
DamRegion (const DamRegion_sequence& s);
|
|
|
|
// DamCompartmentProb
|
|
//
|
|
typedef ::model_ds::DamCompartmentProb DamCompartmentProb_type;
|
|
typedef ::xsd::cxx::tree::sequence< DamCompartmentProb_type > DamCompartmentProb_sequence;
|
|
typedef DamCompartmentProb_sequence::iterator DamCompartmentProb_iterator;
|
|
typedef DamCompartmentProb_sequence::const_iterator DamCompartmentProb_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< DamCompartmentProb_type, char > DamCompartmentProb_traits;
|
|
|
|
const DamCompartmentProb_sequence&
|
|
DamCompartmentProb () const;
|
|
|
|
DamCompartmentProb_sequence&
|
|
DamCompartmentProb ();
|
|
|
|
void
|
|
DamCompartmentProb (const DamCompartmentProb_sequence& s);
|
|
|
|
// DamCaseProb
|
|
//
|
|
typedef ::model_ds::DamCaseProb DamCaseProb_type;
|
|
typedef ::xsd::cxx::tree::sequence< DamCaseProb_type > DamCaseProb_sequence;
|
|
typedef DamCaseProb_sequence::iterator DamCaseProb_iterator;
|
|
typedef DamCaseProb_sequence::const_iterator DamCaseProb_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< DamCaseProb_type, char > DamCaseProb_traits;
|
|
|
|
const DamCaseProb_sequence&
|
|
DamCaseProb () const;
|
|
|
|
DamCaseProb_sequence&
|
|
DamCaseProb ();
|
|
|
|
void
|
|
DamCaseProb (const DamCaseProb_sequence& s);
|
|
|
|
// AllowNM
|
|
//
|
|
typedef ::model_ds::AllowNM AllowNM_type;
|
|
typedef ::xsd::cxx::tree::sequence< AllowNM_type > AllowNM_sequence;
|
|
typedef AllowNM_sequence::iterator AllowNM_iterator;
|
|
typedef AllowNM_sequence::const_iterator AllowNM_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< AllowNM_type, char > AllowNM_traits;
|
|
|
|
const AllowNM_sequence&
|
|
AllowNM () const;
|
|
|
|
AllowNM_sequence&
|
|
AllowNM ();
|
|
|
|
void
|
|
AllowNM (const AllowNM_sequence& s);
|
|
|
|
// Constructors.
|
|
//
|
|
ModelDS ();
|
|
|
|
ModelDS (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ModelDS (const ModelDS& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ModelDS*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ModelDS&
|
|
operator= (const ModelDS& x);
|
|
|
|
virtual
|
|
~ModelDS ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
LWT_sequence LWT_;
|
|
ImmersionPoint_sequence ImmersionPoint_;
|
|
LimitStaticPoint_sequence LimitStaticPoint_;
|
|
WindFixed_sequence WindFixed_;
|
|
Case_sequence Case_;
|
|
WindNonFixed_sequence WindNonFixed_;
|
|
OtherHeel_sequence OtherHeel_;
|
|
Pull_sequence Pull_;
|
|
Jet_sequence Jet_;
|
|
Lift_sequence Lift_;
|
|
Sidesway_sequence Sidesway_;
|
|
Pile_sequence Pile_;
|
|
MudAsym_sequence MudAsym_;
|
|
Mud_sequence Mud_;
|
|
DamCase_sequence DamCase_;
|
|
DamCompartment_sequence DamCompartment_;
|
|
BInf_sequence BInf_;
|
|
XLabel_sequence XLabel_;
|
|
Compartment_sequence Compartment_;
|
|
FloodPoint_sequence FloodPoint_;
|
|
Deckline_sequence Deckline_;
|
|
IncliningExtraWeight_sequence IncliningExtraWeight_;
|
|
IncliningAbsentWeight_sequence IncliningAbsentWeight_;
|
|
IncliningMobileWeight_sequence IncliningMobileWeight_;
|
|
IncliningRelocateWeight_sequence IncliningRelocateWeight_;
|
|
IncliningStatus_sequence IncliningStatus_;
|
|
IncliningDevice_sequence IncliningDevice_;
|
|
IncliningDraft_sequence IncliningDraft_;
|
|
IncliningTank_sequence IncliningTank_;
|
|
IncliningCase_sequence IncliningCase_;
|
|
IncliningRecord_sequence IncliningRecord_;
|
|
Shell_sequence Shell_;
|
|
PartialLoad_sequence PartialLoad_;
|
|
PartialLoadItem_sequence PartialLoadItem_;
|
|
StationLabel_sequence StationLabel_;
|
|
WaterlineLabel_sequence WaterlineLabel_;
|
|
ButtocklineLabel_sequence ButtocklineLabel_;
|
|
PartialLoadWeight_sequence PartialLoadWeight_;
|
|
PartialLoadFreeSurf_sequence PartialLoadFreeSurf_;
|
|
PartialLoadPerson_sequence PartialLoadPerson_;
|
|
PartialLoadBulk_sequence PartialLoadBulk_;
|
|
OilRecover_sequence OilRecover_;
|
|
PartialLoadIce_sequence PartialLoadIce_;
|
|
SuspendLoad_sequence SuspendLoad_;
|
|
Fishing_sequence Fishing_;
|
|
CompExtent_sequence CompExtent_;
|
|
DamRegion_sequence DamRegion_;
|
|
DamCompartmentProb_sequence DamCompartmentProb_;
|
|
DamCaseProb_sequence DamCaseProb_;
|
|
AllowNM_sequence AllowNM_;
|
|
};
|
|
|
|
class LWT: 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);
|
|
|
|
// 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 ();
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Xa_symbol
|
|
//
|
|
typedef ::xml_schema::string Xa_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_symbol_type > Xa_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_symbol_type, char > Xa_symbol_traits;
|
|
|
|
const Xa_symbol_optional&
|
|
Xa_symbol () const;
|
|
|
|
Xa_symbol_optional&
|
|
Xa_symbol ();
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_type& x);
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_optional& x);
|
|
|
|
void
|
|
Xa_symbol (::std::unique_ptr< Xa_symbol_type > p);
|
|
|
|
// Xf_symbol
|
|
//
|
|
typedef ::xml_schema::string Xf_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_symbol_type > Xf_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_symbol_type, char > Xf_symbol_traits;
|
|
|
|
const Xf_symbol_optional&
|
|
Xf_symbol () const;
|
|
|
|
Xf_symbol_optional&
|
|
Xf_symbol ();
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_type& x);
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_optional& x);
|
|
|
|
void
|
|
Xf_symbol (::std::unique_ptr< Xf_symbol_type > p);
|
|
|
|
// Xa
|
|
//
|
|
typedef ::xml_schema::double_ Xa_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_type > Xa_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_type, char, ::xsd::cxx::tree::schema_type::double_ > Xa_traits;
|
|
|
|
const Xa_optional&
|
|
Xa () const;
|
|
|
|
Xa_optional&
|
|
Xa ();
|
|
|
|
void
|
|
Xa (const Xa_type& x);
|
|
|
|
void
|
|
Xa (const Xa_optional& x);
|
|
|
|
// Xf
|
|
//
|
|
typedef ::xml_schema::double_ Xf_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_type > Xf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_type, char, ::xsd::cxx::tree::schema_type::double_ > Xf_traits;
|
|
|
|
const Xf_optional&
|
|
Xf () const;
|
|
|
|
Xf_optional&
|
|
Xf ();
|
|
|
|
void
|
|
Xf (const Xf_type& x);
|
|
|
|
void
|
|
Xf (const Xf_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
LWT (const ID_type&);
|
|
|
|
LWT (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
LWT (const LWT& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual LWT*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
LWT&
|
|
operator= (const LWT& x);
|
|
|
|
virtual
|
|
~LWT ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
G_optional G_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
Xa_symbol_optional Xa_symbol_;
|
|
Xf_symbol_optional Xf_symbol_;
|
|
Xa_optional Xa_;
|
|
Xf_optional Xf_;
|
|
};
|
|
|
|
class ImmersionPoint: 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);
|
|
|
|
// Xsymbol
|
|
//
|
|
typedef ::xml_schema::string Xsymbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xsymbol_type > Xsymbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xsymbol_type, char > Xsymbol_traits;
|
|
|
|
const Xsymbol_optional&
|
|
Xsymbol () const;
|
|
|
|
Xsymbol_optional&
|
|
Xsymbol ();
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_type& x);
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_optional& x);
|
|
|
|
void
|
|
Xsymbol (::std::unique_ptr< Xsymbol_type > p);
|
|
|
|
// X
|
|
//
|
|
typedef ::xml_schema::double_ X_type;
|
|
typedef ::xsd::cxx::tree::optional< X_type > X_optional;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::double_ > X_traits;
|
|
|
|
const X_optional&
|
|
X () const;
|
|
|
|
X_optional&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
void
|
|
X (const X_optional& x);
|
|
|
|
// Y
|
|
//
|
|
typedef ::xml_schema::double_ Y_type;
|
|
typedef ::xsd::cxx::tree::optional< Y_type > Y_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::double_ > Y_traits;
|
|
|
|
const Y_optional&
|
|
Y () const;
|
|
|
|
Y_optional&
|
|
Y ();
|
|
|
|
void
|
|
Y (const Y_type& x);
|
|
|
|
void
|
|
Y (const Y_optional& x);
|
|
|
|
// Z
|
|
//
|
|
typedef ::xml_schema::double_ Z_type;
|
|
typedef ::xsd::cxx::tree::optional< Z_type > Z_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::double_ > Z_traits;
|
|
|
|
const Z_optional&
|
|
Z () const;
|
|
|
|
Z_optional&
|
|
Z ();
|
|
|
|
void
|
|
Z (const Z_type& x);
|
|
|
|
void
|
|
Z (const Z_optional& x);
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
ImmersionPoint (const ID_type&);
|
|
|
|
ImmersionPoint (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ImmersionPoint (const ImmersionPoint& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ImmersionPoint*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ImmersionPoint&
|
|
operator= (const ImmersionPoint& x);
|
|
|
|
virtual
|
|
~ImmersionPoint ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Xsymbol_optional Xsymbol_;
|
|
X_optional X_;
|
|
Y_optional Y_;
|
|
Z_optional Z_;
|
|
Compartment_optional Compartment_;
|
|
};
|
|
|
|
class LimitStaticPoint: 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);
|
|
|
|
// Xsymbol
|
|
//
|
|
typedef ::xml_schema::string Xsymbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xsymbol_type > Xsymbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xsymbol_type, char > Xsymbol_traits;
|
|
|
|
const Xsymbol_optional&
|
|
Xsymbol () const;
|
|
|
|
Xsymbol_optional&
|
|
Xsymbol ();
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_type& x);
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_optional& x);
|
|
|
|
void
|
|
Xsymbol (::std::unique_ptr< Xsymbol_type > p);
|
|
|
|
// X1
|
|
//
|
|
typedef ::xml_schema::double_ X1_type;
|
|
typedef ::xsd::cxx::tree::optional< X1_type > X1_optional;
|
|
typedef ::xsd::cxx::tree::traits< X1_type, char, ::xsd::cxx::tree::schema_type::double_ > X1_traits;
|
|
|
|
const X1_optional&
|
|
X1 () const;
|
|
|
|
X1_optional&
|
|
X1 ();
|
|
|
|
void
|
|
X1 (const X1_type& x);
|
|
|
|
void
|
|
X1 (const X1_optional& x);
|
|
|
|
// Y1
|
|
//
|
|
typedef ::xml_schema::double_ Y1_type;
|
|
typedef ::xsd::cxx::tree::optional< Y1_type > Y1_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y1_type, char, ::xsd::cxx::tree::schema_type::double_ > Y1_traits;
|
|
|
|
const Y1_optional&
|
|
Y1 () const;
|
|
|
|
Y1_optional&
|
|
Y1 ();
|
|
|
|
void
|
|
Y1 (const Y1_type& x);
|
|
|
|
void
|
|
Y1 (const Y1_optional& x);
|
|
|
|
// Z1
|
|
//
|
|
typedef ::xml_schema::double_ Z1_type;
|
|
typedef ::xsd::cxx::tree::optional< Z1_type > Z1_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z1_type, char, ::xsd::cxx::tree::schema_type::double_ > Z1_traits;
|
|
|
|
const Z1_optional&
|
|
Z1 () const;
|
|
|
|
Z1_optional&
|
|
Z1 ();
|
|
|
|
void
|
|
Z1 (const Z1_type& x);
|
|
|
|
void
|
|
Z1 (const Z1_optional& x);
|
|
|
|
// X2
|
|
//
|
|
typedef ::xml_schema::double_ X2_type;
|
|
typedef ::xsd::cxx::tree::optional< X2_type > X2_optional;
|
|
typedef ::xsd::cxx::tree::traits< X2_type, char, ::xsd::cxx::tree::schema_type::double_ > X2_traits;
|
|
|
|
const X2_optional&
|
|
X2 () const;
|
|
|
|
X2_optional&
|
|
X2 ();
|
|
|
|
void
|
|
X2 (const X2_type& x);
|
|
|
|
void
|
|
X2 (const X2_optional& x);
|
|
|
|
static X2_type
|
|
X2_default_value ();
|
|
|
|
// Y2
|
|
//
|
|
typedef ::xml_schema::double_ Y2_type;
|
|
typedef ::xsd::cxx::tree::optional< Y2_type > Y2_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y2_type, char, ::xsd::cxx::tree::schema_type::double_ > Y2_traits;
|
|
|
|
const Y2_optional&
|
|
Y2 () const;
|
|
|
|
Y2_optional&
|
|
Y2 ();
|
|
|
|
void
|
|
Y2 (const Y2_type& x);
|
|
|
|
void
|
|
Y2 (const Y2_optional& x);
|
|
|
|
// Z2
|
|
//
|
|
typedef ::xml_schema::double_ Z2_type;
|
|
typedef ::xsd::cxx::tree::optional< Z2_type > Z2_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z2_type, char, ::xsd::cxx::tree::schema_type::double_ > Z2_traits;
|
|
|
|
const Z2_optional&
|
|
Z2 () const;
|
|
|
|
Z2_optional&
|
|
Z2 ();
|
|
|
|
void
|
|
Z2 (const Z2_type& x);
|
|
|
|
void
|
|
Z2 (const Z2_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
LimitStaticPoint (const ID_type&);
|
|
|
|
LimitStaticPoint (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
LimitStaticPoint (const LimitStaticPoint& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual LimitStaticPoint*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
LimitStaticPoint&
|
|
operator= (const LimitStaticPoint& x);
|
|
|
|
virtual
|
|
~LimitStaticPoint ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Xsymbol_optional Xsymbol_;
|
|
X1_optional X1_;
|
|
Y1_optional Y1_;
|
|
Z1_optional Z1_;
|
|
X2_optional X2_;
|
|
Y2_optional Y2_;
|
|
Z2_optional Z2_;
|
|
};
|
|
|
|
class WindFixed: 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);
|
|
|
|
// 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 ();
|
|
|
|
// As
|
|
//
|
|
typedef ::xml_schema::double_ As_type;
|
|
typedef ::xsd::cxx::tree::optional< As_type > As_optional;
|
|
typedef ::xsd::cxx::tree::traits< As_type, char, ::xsd::cxx::tree::schema_type::double_ > As_traits;
|
|
|
|
const As_optional&
|
|
As () const;
|
|
|
|
As_optional&
|
|
As ();
|
|
|
|
void
|
|
As (const As_type& x);
|
|
|
|
void
|
|
As (const As_optional& x);
|
|
|
|
// Zf
|
|
//
|
|
typedef ::xml_schema::double_ Zf_type;
|
|
typedef ::xsd::cxx::tree::optional< Zf_type > Zf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zf_type, char, ::xsd::cxx::tree::schema_type::double_ > Zf_traits;
|
|
|
|
const Zf_optional&
|
|
Zf () const;
|
|
|
|
Zf_optional&
|
|
Zf ();
|
|
|
|
void
|
|
Zf (const Zf_type& x);
|
|
|
|
void
|
|
Zf (const Zf_optional& x);
|
|
|
|
// FullCoef
|
|
//
|
|
typedef ::xml_schema::double_ FullCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< FullCoef_type > FullCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< FullCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > FullCoef_traits;
|
|
|
|
const FullCoef_optional&
|
|
FullCoef () const;
|
|
|
|
FullCoef_optional&
|
|
FullCoef ();
|
|
|
|
void
|
|
FullCoef (const FullCoef_type& x);
|
|
|
|
void
|
|
FullCoef (const FullCoef_optional& x);
|
|
|
|
static FullCoef_type
|
|
FullCoef_default_value ();
|
|
|
|
// StreamlineCoef
|
|
//
|
|
typedef ::xml_schema::double_ StreamlineCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< StreamlineCoef_type > StreamlineCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< StreamlineCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > StreamlineCoef_traits;
|
|
|
|
const StreamlineCoef_optional&
|
|
StreamlineCoef () const;
|
|
|
|
StreamlineCoef_optional&
|
|
StreamlineCoef ();
|
|
|
|
void
|
|
StreamlineCoef (const StreamlineCoef_type& x);
|
|
|
|
void
|
|
StreamlineCoef (const StreamlineCoef_optional& x);
|
|
|
|
static StreamlineCoef_type
|
|
StreamlineCoef_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
WindFixed (const ID_type&);
|
|
|
|
WindFixed (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
WindFixed (const WindFixed& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual WindFixed*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
WindFixed&
|
|
operator= (const WindFixed& x);
|
|
|
|
virtual
|
|
~WindFixed ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
As_optional As_;
|
|
Zf_optional Zf_;
|
|
FullCoef_optional FullCoef_;
|
|
StreamlineCoef_optional StreamlineCoef_;
|
|
};
|
|
|
|
class Case: 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);
|
|
|
|
// ShipType
|
|
//
|
|
typedef ::xml_schema::int_ ShipType_type;
|
|
typedef ::xsd::cxx::tree::optional< ShipType_type > ShipType_optional;
|
|
typedef ::xsd::cxx::tree::traits< ShipType_type, char > ShipType_traits;
|
|
|
|
const ShipType_optional&
|
|
ShipType () const;
|
|
|
|
ShipType_optional&
|
|
ShipType ();
|
|
|
|
void
|
|
ShipType (const ShipType_type& x);
|
|
|
|
void
|
|
ShipType (const ShipType_optional& x);
|
|
|
|
static ShipType_type
|
|
ShipType_default_value ();
|
|
|
|
// ChildType
|
|
//
|
|
typedef ::xml_schema::int_ ChildType_type;
|
|
typedef ::xsd::cxx::tree::optional< ChildType_type > ChildType_optional;
|
|
typedef ::xsd::cxx::tree::traits< ChildType_type, char > ChildType_traits;
|
|
|
|
const ChildType_optional&
|
|
ChildType () const;
|
|
|
|
ChildType_optional&
|
|
ChildType ();
|
|
|
|
void
|
|
ChildType (const ChildType_type& x);
|
|
|
|
void
|
|
ChildType (const ChildType_optional& x);
|
|
|
|
static ChildType_type
|
|
ChildType_default_value ();
|
|
|
|
// CriteriaFactor
|
|
//
|
|
typedef ::xml_schema::string CriteriaFactor_type;
|
|
typedef ::xsd::cxx::tree::optional< CriteriaFactor_type > CriteriaFactor_optional;
|
|
typedef ::xsd::cxx::tree::traits< CriteriaFactor_type, char > CriteriaFactor_traits;
|
|
|
|
const CriteriaFactor_optional&
|
|
CriteriaFactor () const;
|
|
|
|
CriteriaFactor_optional&
|
|
CriteriaFactor ();
|
|
|
|
void
|
|
CriteriaFactor (const CriteriaFactor_type& x);
|
|
|
|
void
|
|
CriteriaFactor (const CriteriaFactor_optional& x);
|
|
|
|
void
|
|
CriteriaFactor (::std::unique_ptr< CriteriaFactor_type > p);
|
|
|
|
// CheckState
|
|
//
|
|
typedef ::xml_schema::int_ CheckState_type;
|
|
typedef ::xsd::cxx::tree::optional< CheckState_type > CheckState_optional;
|
|
typedef ::xsd::cxx::tree::traits< CheckState_type, char > CheckState_traits;
|
|
|
|
const CheckState_optional&
|
|
CheckState () const;
|
|
|
|
CheckState_optional&
|
|
CheckState ();
|
|
|
|
void
|
|
CheckState (const CheckState_type& x);
|
|
|
|
void
|
|
CheckState (const CheckState_optional& x);
|
|
|
|
static CheckState_type
|
|
CheckState_default_value ();
|
|
|
|
// PartialLoad
|
|
//
|
|
typedef ::xml_schema::string PartialLoad_type;
|
|
typedef ::xsd::cxx::tree::optional< PartialLoad_type > PartialLoad_optional;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoad_type, char > PartialLoad_traits;
|
|
|
|
const PartialLoad_optional&
|
|
PartialLoad () const;
|
|
|
|
PartialLoad_optional&
|
|
PartialLoad ();
|
|
|
|
void
|
|
PartialLoad (const PartialLoad_type& x);
|
|
|
|
void
|
|
PartialLoad (const PartialLoad_optional& x);
|
|
|
|
void
|
|
PartialLoad (::std::unique_ptr< PartialLoad_type > p);
|
|
|
|
// Wind
|
|
//
|
|
typedef ::xml_schema::string Wind_type;
|
|
typedef ::xsd::cxx::tree::optional< Wind_type > Wind_optional;
|
|
typedef ::xsd::cxx::tree::traits< Wind_type, char > Wind_traits;
|
|
|
|
const Wind_optional&
|
|
Wind () const;
|
|
|
|
Wind_optional&
|
|
Wind ();
|
|
|
|
void
|
|
Wind (const Wind_type& x);
|
|
|
|
void
|
|
Wind (const Wind_optional& x);
|
|
|
|
void
|
|
Wind (::std::unique_ptr< Wind_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.
|
|
//
|
|
Case (const ID_type&);
|
|
|
|
Case (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Case (const Case& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Case*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Case&
|
|
operator= (const Case& x);
|
|
|
|
virtual
|
|
~Case ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
ShipType_optional ShipType_;
|
|
ChildType_optional ChildType_;
|
|
CriteriaFactor_optional CriteriaFactor_;
|
|
CheckState_optional CheckState_;
|
|
PartialLoad_optional PartialLoad_;
|
|
Wind_optional Wind_;
|
|
Remark_optional Remark_;
|
|
};
|
|
|
|
class WindNonFixed: 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);
|
|
|
|
// 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 ();
|
|
|
|
// As
|
|
//
|
|
typedef ::xml_schema::double_ As_type;
|
|
typedef ::xsd::cxx::tree::optional< As_type > As_optional;
|
|
typedef ::xsd::cxx::tree::traits< As_type, char, ::xsd::cxx::tree::schema_type::double_ > As_traits;
|
|
|
|
const As_optional&
|
|
As () const;
|
|
|
|
As_optional&
|
|
As ();
|
|
|
|
void
|
|
As (const As_type& x);
|
|
|
|
void
|
|
As (const As_optional& x);
|
|
|
|
// Zf
|
|
//
|
|
typedef ::xml_schema::double_ Zf_type;
|
|
typedef ::xsd::cxx::tree::optional< Zf_type > Zf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zf_type, char, ::xsd::cxx::tree::schema_type::double_ > Zf_traits;
|
|
|
|
const Zf_optional&
|
|
Zf () const;
|
|
|
|
Zf_optional&
|
|
Zf ();
|
|
|
|
void
|
|
Zf (const Zf_type& x);
|
|
|
|
void
|
|
Zf (const Zf_optional& x);
|
|
|
|
// FullCoef
|
|
//
|
|
typedef ::xml_schema::double_ FullCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< FullCoef_type > FullCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< FullCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > FullCoef_traits;
|
|
|
|
const FullCoef_optional&
|
|
FullCoef () const;
|
|
|
|
FullCoef_optional&
|
|
FullCoef ();
|
|
|
|
void
|
|
FullCoef (const FullCoef_type& x);
|
|
|
|
void
|
|
FullCoef (const FullCoef_optional& x);
|
|
|
|
static FullCoef_type
|
|
FullCoef_default_value ();
|
|
|
|
// StreamlineCoef
|
|
//
|
|
typedef ::xml_schema::double_ StreamlineCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< StreamlineCoef_type > StreamlineCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< StreamlineCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > StreamlineCoef_traits;
|
|
|
|
const StreamlineCoef_optional&
|
|
StreamlineCoef () const;
|
|
|
|
StreamlineCoef_optional&
|
|
StreamlineCoef ();
|
|
|
|
void
|
|
StreamlineCoef (const StreamlineCoef_type& x);
|
|
|
|
void
|
|
StreamlineCoef (const StreamlineCoef_optional& x);
|
|
|
|
static StreamlineCoef_type
|
|
StreamlineCoef_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
WindNonFixed (const ID_type&);
|
|
|
|
WindNonFixed (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
WindNonFixed (const WindNonFixed& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual WindNonFixed*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
WindNonFixed&
|
|
operator= (const WindNonFixed& x);
|
|
|
|
virtual
|
|
~WindNonFixed ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
As_optional As_;
|
|
Zf_optional Zf_;
|
|
FullCoef_optional FullCoef_;
|
|
StreamlineCoef_optional StreamlineCoef_;
|
|
};
|
|
|
|
class OtherHeel: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_type > p);
|
|
|
|
// Angle
|
|
//
|
|
typedef ::xml_schema::double_ Angle_type;
|
|
typedef ::xsd::cxx::tree::traits< Angle_type, char, ::xsd::cxx::tree::schema_type::double_ > Angle_traits;
|
|
|
|
const Angle_type&
|
|
Angle () const;
|
|
|
|
Angle_type&
|
|
Angle ();
|
|
|
|
void
|
|
Angle (const Angle_type& x);
|
|
|
|
// M
|
|
//
|
|
typedef ::xml_schema::double_ M_type;
|
|
typedef ::xsd::cxx::tree::optional< M_type > M_optional;
|
|
typedef ::xsd::cxx::tree::traits< M_type, char, ::xsd::cxx::tree::schema_type::double_ > M_traits;
|
|
|
|
const M_optional&
|
|
M () const;
|
|
|
|
M_optional&
|
|
M ();
|
|
|
|
void
|
|
M (const M_type& x);
|
|
|
|
void
|
|
M (const M_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
OtherHeel (const CaseID_type&,
|
|
const Angle_type&);
|
|
|
|
OtherHeel (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
OtherHeel (const OtherHeel& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual OtherHeel*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
OtherHeel&
|
|
operator= (const OtherHeel& x);
|
|
|
|
virtual
|
|
~OtherHeel ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< Angle_type > Angle_;
|
|
M_optional M_;
|
|
};
|
|
|
|
class Pull: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// Tb
|
|
//
|
|
typedef ::xml_schema::double_ Tb_type;
|
|
typedef ::xsd::cxx::tree::optional< Tb_type > Tb_optional;
|
|
typedef ::xsd::cxx::tree::traits< Tb_type, char, ::xsd::cxx::tree::schema_type::double_ > Tb_traits;
|
|
|
|
const Tb_optional&
|
|
Tb () const;
|
|
|
|
Tb_optional&
|
|
Tb ();
|
|
|
|
void
|
|
Tb (const Tb_type& x);
|
|
|
|
void
|
|
Tb (const Tb_optional& x);
|
|
|
|
// Zt
|
|
//
|
|
typedef ::xml_schema::double_ Zt_type;
|
|
typedef ::xsd::cxx::tree::optional< Zt_type > Zt_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zt_type, char, ::xsd::cxx::tree::schema_type::double_ > Zt_traits;
|
|
|
|
const Zt_optional&
|
|
Zt () const;
|
|
|
|
Zt_optional&
|
|
Zt ();
|
|
|
|
void
|
|
Zt (const Zt_type& x);
|
|
|
|
void
|
|
Zt (const Zt_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Pull (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Pull (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Pull (const Pull& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Pull*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Pull&
|
|
operator= (const Pull& x);
|
|
|
|
virtual
|
|
~Pull ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Tb_optional Tb_;
|
|
Zt_optional Zt_;
|
|
};
|
|
|
|
class Jet: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// F
|
|
//
|
|
typedef ::xml_schema::double_ F_type;
|
|
typedef ::xsd::cxx::tree::optional< F_type > F_optional;
|
|
typedef ::xsd::cxx::tree::traits< F_type, char, ::xsd::cxx::tree::schema_type::double_ > F_traits;
|
|
|
|
const F_optional&
|
|
F () const;
|
|
|
|
F_optional&
|
|
F ();
|
|
|
|
void
|
|
F (const F_type& x);
|
|
|
|
void
|
|
F (const F_optional& x);
|
|
|
|
// Z
|
|
//
|
|
typedef ::xml_schema::double_ Z_type;
|
|
typedef ::xsd::cxx::tree::optional< Z_type > Z_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::double_ > Z_traits;
|
|
|
|
const Z_optional&
|
|
Z () const;
|
|
|
|
Z_optional&
|
|
Z ();
|
|
|
|
void
|
|
Z (const Z_type& x);
|
|
|
|
void
|
|
Z (const Z_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Jet (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Jet (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Jet (const Jet& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Jet*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Jet&
|
|
operator= (const Jet& x);
|
|
|
|
virtual
|
|
~Jet ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
F_optional F_;
|
|
Z_optional Z_;
|
|
};
|
|
|
|
class Lift: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// Wx
|
|
//
|
|
typedef ::xml_schema::double_ Wx_type;
|
|
typedef ::xsd::cxx::tree::optional< Wx_type > Wx_optional;
|
|
typedef ::xsd::cxx::tree::traits< Wx_type, char, ::xsd::cxx::tree::schema_type::double_ > Wx_traits;
|
|
|
|
const Wx_optional&
|
|
Wx () const;
|
|
|
|
Wx_optional&
|
|
Wx ();
|
|
|
|
void
|
|
Wx (const Wx_type& x);
|
|
|
|
void
|
|
Wx (const Wx_optional& x);
|
|
|
|
// bx
|
|
//
|
|
typedef ::xml_schema::double_ bx_type;
|
|
typedef ::xsd::cxx::tree::optional< bx_type > bx_optional;
|
|
typedef ::xsd::cxx::tree::traits< bx_type, char, ::xsd::cxx::tree::schema_type::double_ > bx_traits;
|
|
|
|
const bx_optional&
|
|
bx () const;
|
|
|
|
bx_optional&
|
|
bx ();
|
|
|
|
void
|
|
bx (const bx_type& x);
|
|
|
|
void
|
|
bx (const bx_optional& x);
|
|
|
|
// Mi
|
|
//
|
|
typedef ::xml_schema::double_ Mi_type;
|
|
typedef ::xsd::cxx::tree::optional< Mi_type > Mi_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mi_type, char, ::xsd::cxx::tree::schema_type::double_ > Mi_traits;
|
|
|
|
const Mi_optional&
|
|
Mi () const;
|
|
|
|
Mi_optional&
|
|
Mi ();
|
|
|
|
void
|
|
Mi (const Mi_type& x);
|
|
|
|
void
|
|
Mi (const Mi_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Lift (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Lift (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Lift (const Lift& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Lift*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Lift&
|
|
operator= (const Lift& x);
|
|
|
|
virtual
|
|
~Lift ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Wx_optional Wx_;
|
|
bx_optional bx_;
|
|
Mi_optional Mi_;
|
|
};
|
|
|
|
class Sidesway: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// P
|
|
//
|
|
typedef ::xml_schema::double_ P_type;
|
|
typedef ::xsd::cxx::tree::optional< P_type > P_optional;
|
|
typedef ::xsd::cxx::tree::traits< P_type, char, ::xsd::cxx::tree::schema_type::double_ > P_traits;
|
|
|
|
const P_optional&
|
|
P () const;
|
|
|
|
P_optional&
|
|
P ();
|
|
|
|
void
|
|
P (const P_type& x);
|
|
|
|
void
|
|
P (const P_optional& x);
|
|
|
|
// Zh
|
|
//
|
|
typedef ::xml_schema::double_ Zh_type;
|
|
typedef ::xsd::cxx::tree::optional< Zh_type > Zh_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zh_type, char, ::xsd::cxx::tree::schema_type::double_ > Zh_traits;
|
|
|
|
const Zh_optional&
|
|
Zh () const;
|
|
|
|
Zh_optional&
|
|
Zh ();
|
|
|
|
void
|
|
Zh (const Zh_type& x);
|
|
|
|
void
|
|
Zh (const Zh_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Sidesway (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Sidesway (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Sidesway (const Sidesway& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Sidesway*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Sidesway&
|
|
operator= (const Sidesway& x);
|
|
|
|
virtual
|
|
~Sidesway ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
P_optional P_;
|
|
Zh_optional Zh_;
|
|
};
|
|
|
|
class Pile: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// Wd
|
|
//
|
|
typedef ::xml_schema::double_ Wd_type;
|
|
typedef ::xsd::cxx::tree::optional< Wd_type > Wd_optional;
|
|
typedef ::xsd::cxx::tree::traits< Wd_type, char, ::xsd::cxx::tree::schema_type::double_ > Wd_traits;
|
|
|
|
const Wd_optional&
|
|
Wd () const;
|
|
|
|
Wd_optional&
|
|
Wd ();
|
|
|
|
void
|
|
Wd (const Wd_type& x);
|
|
|
|
void
|
|
Wd (const Wd_optional& x);
|
|
|
|
// bd
|
|
//
|
|
typedef ::xml_schema::double_ bd_type;
|
|
typedef ::xsd::cxx::tree::optional< bd_type > bd_optional;
|
|
typedef ::xsd::cxx::tree::traits< bd_type, char, ::xsd::cxx::tree::schema_type::double_ > bd_traits;
|
|
|
|
const bd_optional&
|
|
bd () const;
|
|
|
|
bd_optional&
|
|
bd ();
|
|
|
|
void
|
|
bd (const bd_type& x);
|
|
|
|
void
|
|
bd (const bd_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Pile (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Pile (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Pile (const Pile& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Pile*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Pile&
|
|
operator= (const Pile& x);
|
|
|
|
virtual
|
|
~Pile ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Wd_optional Wd_;
|
|
bd_optional bd_;
|
|
};
|
|
|
|
class MudAsym: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// W
|
|
//
|
|
typedef ::xml_schema::double_ W_type;
|
|
typedef ::xsd::cxx::tree::optional< W_type > W_optional;
|
|
typedef ::xsd::cxx::tree::traits< W_type, char, ::xsd::cxx::tree::schema_type::double_ > W_traits;
|
|
|
|
const W_optional&
|
|
W () const;
|
|
|
|
W_optional&
|
|
W ();
|
|
|
|
void
|
|
W (const W_type& x);
|
|
|
|
void
|
|
W (const W_optional& x);
|
|
|
|
// Y
|
|
//
|
|
typedef ::xml_schema::double_ Y_type;
|
|
typedef ::xsd::cxx::tree::optional< Y_type > Y_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::double_ > Y_traits;
|
|
|
|
const Y_optional&
|
|
Y () const;
|
|
|
|
Y_optional&
|
|
Y ();
|
|
|
|
void
|
|
Y (const Y_type& x);
|
|
|
|
void
|
|
Y (const Y_optional& x);
|
|
|
|
// UnitWeight
|
|
//
|
|
typedef ::xml_schema::double_ UnitWeight_type;
|
|
typedef ::xsd::cxx::tree::optional< UnitWeight_type > UnitWeight_optional;
|
|
typedef ::xsd::cxx::tree::traits< UnitWeight_type, char, ::xsd::cxx::tree::schema_type::double_ > UnitWeight_traits;
|
|
|
|
const UnitWeight_optional&
|
|
UnitWeight () const;
|
|
|
|
UnitWeight_optional&
|
|
UnitWeight ();
|
|
|
|
void
|
|
UnitWeight (const UnitWeight_type& x);
|
|
|
|
void
|
|
UnitWeight (const UnitWeight_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
MudAsym (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
MudAsym (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
MudAsym (const MudAsym& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual MudAsym*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
MudAsym&
|
|
operator= (const MudAsym& x);
|
|
|
|
virtual
|
|
~MudAsym ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
W_optional W_;
|
|
Y_optional Y_;
|
|
UnitWeight_optional UnitWeight_;
|
|
};
|
|
|
|
class Mud: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// Wp
|
|
//
|
|
typedef ::xml_schema::double_ Wp_type;
|
|
typedef ::xsd::cxx::tree::optional< Wp_type > Wp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Wp_type, char, ::xsd::cxx::tree::schema_type::double_ > Wp_traits;
|
|
|
|
const Wp_optional&
|
|
Wp () const;
|
|
|
|
Wp_optional&
|
|
Wp ();
|
|
|
|
void
|
|
Wp (const Wp_type& x);
|
|
|
|
void
|
|
Wp (const Wp_optional& x);
|
|
|
|
// bp
|
|
//
|
|
typedef ::xml_schema::double_ bp_type;
|
|
typedef ::xsd::cxx::tree::optional< bp_type > bp_optional;
|
|
typedef ::xsd::cxx::tree::traits< bp_type, char, ::xsd::cxx::tree::schema_type::double_ > bp_traits;
|
|
|
|
const bp_optional&
|
|
bp () const;
|
|
|
|
bp_optional&
|
|
bp ();
|
|
|
|
void
|
|
bp (const bp_type& x);
|
|
|
|
void
|
|
bp (const bp_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Mud (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Mud (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Mud (const Mud& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Mud*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Mud&
|
|
operator= (const Mud& x);
|
|
|
|
virtual
|
|
~Mud ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Wp_optional Wp_;
|
|
bp_optional bp_;
|
|
};
|
|
|
|
class DamCase: 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);
|
|
|
|
// 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.
|
|
//
|
|
DamCase (const ID_type&);
|
|
|
|
DamCase (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
DamCase (const DamCase& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual DamCase*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
DamCase&
|
|
operator= (const DamCase& x);
|
|
|
|
virtual
|
|
~DamCase ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Remark_optional Remark_;
|
|
};
|
|
|
|
class DamCompartment: 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);
|
|
|
|
// CompartmentIDs
|
|
//
|
|
typedef ::xml_schema::string CompartmentIDs_type;
|
|
typedef ::xsd::cxx::tree::traits< CompartmentIDs_type, char > CompartmentIDs_traits;
|
|
|
|
const CompartmentIDs_type&
|
|
CompartmentIDs () const;
|
|
|
|
CompartmentIDs_type&
|
|
CompartmentIDs ();
|
|
|
|
void
|
|
CompartmentIDs (const CompartmentIDs_type& x);
|
|
|
|
void
|
|
CompartmentIDs (::std::unique_ptr< CompartmentIDs_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
DamCompartment (const ID_type&,
|
|
const CompartmentIDs_type&);
|
|
|
|
DamCompartment (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
DamCompartment (const DamCompartment& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual DamCompartment*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
DamCompartment&
|
|
operator= (const DamCompartment& x);
|
|
|
|
virtual
|
|
~DamCompartment ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
::xsd::cxx::tree::one< CompartmentIDs_type > CompartmentIDs_;
|
|
};
|
|
|
|
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 XLabel: 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);
|
|
|
|
// X
|
|
//
|
|
typedef ::xml_schema::double_ X_type;
|
|
typedef ::xsd::cxx::tree::optional< X_type > X_optional;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::double_ > X_traits;
|
|
|
|
const X_optional&
|
|
X () const;
|
|
|
|
X_optional&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
void
|
|
X (const X_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
XLabel (const ID_type&);
|
|
|
|
XLabel (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
XLabel (const XLabel& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual XLabel*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
XLabel&
|
|
operator= (const XLabel& x);
|
|
|
|
virtual
|
|
~XLabel ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
X_optional X_;
|
|
};
|
|
|
|
class Compartment: 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);
|
|
|
|
// SpaceID
|
|
//
|
|
typedef ::xml_schema::string SpaceID_type;
|
|
typedef ::xsd::cxx::tree::optional< SpaceID_type > SpaceID_optional;
|
|
typedef ::xsd::cxx::tree::traits< SpaceID_type, char > SpaceID_traits;
|
|
|
|
const SpaceID_optional&
|
|
SpaceID () const;
|
|
|
|
SpaceID_optional&
|
|
SpaceID ();
|
|
|
|
void
|
|
SpaceID (const SpaceID_type& x);
|
|
|
|
void
|
|
SpaceID (const SpaceID_optional& x);
|
|
|
|
void
|
|
SpaceID (::std::unique_ptr< SpaceID_type > p);
|
|
|
|
// FloodPoints
|
|
//
|
|
typedef ::xml_schema::string FloodPoints_type;
|
|
typedef ::xsd::cxx::tree::optional< FloodPoints_type > FloodPoints_optional;
|
|
typedef ::xsd::cxx::tree::traits< FloodPoints_type, char > FloodPoints_traits;
|
|
|
|
const FloodPoints_optional&
|
|
FloodPoints () const;
|
|
|
|
FloodPoints_optional&
|
|
FloodPoints ();
|
|
|
|
void
|
|
FloodPoints (const FloodPoints_type& x);
|
|
|
|
void
|
|
FloodPoints (const FloodPoints_optional& x);
|
|
|
|
void
|
|
FloodPoints (::std::unique_ptr< FloodPoints_type > p);
|
|
|
|
// 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 ();
|
|
|
|
// Coef
|
|
//
|
|
typedef ::xml_schema::double_ Coef_type;
|
|
typedef ::xsd::cxx::tree::optional< Coef_type > Coef_optional;
|
|
typedef ::xsd::cxx::tree::traits< Coef_type, char, ::xsd::cxx::tree::schema_type::double_ > Coef_traits;
|
|
|
|
const Coef_optional&
|
|
Coef () const;
|
|
|
|
Coef_optional&
|
|
Coef ();
|
|
|
|
void
|
|
Coef (const Coef_type& x);
|
|
|
|
void
|
|
Coef (const Coef_optional& x);
|
|
|
|
static Coef_type
|
|
Coef_default_value ();
|
|
|
|
// Permeability
|
|
//
|
|
typedef ::xml_schema::double_ Permeability_type;
|
|
typedef ::xsd::cxx::tree::optional< Permeability_type > Permeability_optional;
|
|
typedef ::xsd::cxx::tree::traits< Permeability_type, char, ::xsd::cxx::tree::schema_type::double_ > Permeability_traits;
|
|
|
|
const Permeability_optional&
|
|
Permeability () const;
|
|
|
|
Permeability_optional&
|
|
Permeability ();
|
|
|
|
void
|
|
Permeability (const Permeability_type& x);
|
|
|
|
void
|
|
Permeability (const Permeability_optional& x);
|
|
|
|
static Permeability_type
|
|
Permeability_default_value ();
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// 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.
|
|
//
|
|
Compartment (const ID_type&);
|
|
|
|
Compartment (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Compartment (const Compartment& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Compartment*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Compartment&
|
|
operator= (const Compartment& x);
|
|
|
|
virtual
|
|
~Compartment ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
SpaceID_optional SpaceID_;
|
|
FloodPoints_optional FloodPoints_;
|
|
Type_optional Type_;
|
|
Coef_optional Coef_;
|
|
Permeability_optional Permeability_;
|
|
Density_optional Density_;
|
|
Remark_optional Remark_;
|
|
SID_optional SID_;
|
|
};
|
|
|
|
class FloodPoint: 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);
|
|
|
|
// Xsymbol
|
|
//
|
|
typedef ::xml_schema::string Xsymbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xsymbol_type > Xsymbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xsymbol_type, char > Xsymbol_traits;
|
|
|
|
const Xsymbol_optional&
|
|
Xsymbol () const;
|
|
|
|
Xsymbol_optional&
|
|
Xsymbol ();
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_type& x);
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_optional& x);
|
|
|
|
void
|
|
Xsymbol (::std::unique_ptr< Xsymbol_type > p);
|
|
|
|
// X
|
|
//
|
|
typedef ::xml_schema::double_ X_type;
|
|
typedef ::xsd::cxx::tree::optional< X_type > X_optional;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::double_ > X_traits;
|
|
|
|
const X_optional&
|
|
X () const;
|
|
|
|
X_optional&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
void
|
|
X (const X_optional& x);
|
|
|
|
// Y
|
|
//
|
|
typedef ::xml_schema::double_ Y_type;
|
|
typedef ::xsd::cxx::tree::optional< Y_type > Y_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::double_ > Y_traits;
|
|
|
|
const Y_optional&
|
|
Y () const;
|
|
|
|
Y_optional&
|
|
Y ();
|
|
|
|
void
|
|
Y (const Y_type& x);
|
|
|
|
void
|
|
Y (const Y_optional& x);
|
|
|
|
// Z
|
|
//
|
|
typedef ::xml_schema::double_ Z_type;
|
|
typedef ::xsd::cxx::tree::optional< Z_type > Z_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::double_ > Z_traits;
|
|
|
|
const Z_optional&
|
|
Z () const;
|
|
|
|
Z_optional&
|
|
Z ();
|
|
|
|
void
|
|
Z (const Z_type& x);
|
|
|
|
void
|
|
Z (const Z_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
FloodPoint (const ID_type&);
|
|
|
|
FloodPoint (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
FloodPoint (const FloodPoint& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual FloodPoint*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
FloodPoint&
|
|
operator= (const FloodPoint& x);
|
|
|
|
virtual
|
|
~FloodPoint ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Xsymbol_optional Xsymbol_;
|
|
X_optional X_;
|
|
Y_optional Y_;
|
|
Z_optional Z_;
|
|
};
|
|
|
|
class Deckline: 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);
|
|
|
|
// Xsymbol
|
|
//
|
|
typedef ::xml_schema::string Xsymbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xsymbol_type > Xsymbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xsymbol_type, char > Xsymbol_traits;
|
|
|
|
const Xsymbol_optional&
|
|
Xsymbol () const;
|
|
|
|
Xsymbol_optional&
|
|
Xsymbol ();
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_type& x);
|
|
|
|
void
|
|
Xsymbol (const Xsymbol_optional& x);
|
|
|
|
void
|
|
Xsymbol (::std::unique_ptr< Xsymbol_type > p);
|
|
|
|
// X
|
|
//
|
|
typedef ::xml_schema::double_ X_type;
|
|
typedef ::xsd::cxx::tree::optional< X_type > X_optional;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::double_ > X_traits;
|
|
|
|
const X_optional&
|
|
X () const;
|
|
|
|
X_optional&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
void
|
|
X (const X_optional& x);
|
|
|
|
// Y
|
|
//
|
|
typedef ::xml_schema::double_ Y_type;
|
|
typedef ::xsd::cxx::tree::optional< Y_type > Y_optional;
|
|
typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::double_ > Y_traits;
|
|
|
|
const Y_optional&
|
|
Y () const;
|
|
|
|
Y_optional&
|
|
Y ();
|
|
|
|
void
|
|
Y (const Y_type& x);
|
|
|
|
void
|
|
Y (const Y_optional& x);
|
|
|
|
// Z
|
|
//
|
|
typedef ::xml_schema::double_ Z_type;
|
|
typedef ::xsd::cxx::tree::optional< Z_type > Z_optional;
|
|
typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::double_ > Z_traits;
|
|
|
|
const Z_optional&
|
|
Z () const;
|
|
|
|
Z_optional&
|
|
Z ();
|
|
|
|
void
|
|
Z (const Z_type& x);
|
|
|
|
void
|
|
Z (const Z_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Deckline (const ID_type&);
|
|
|
|
Deckline (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Deckline (const Deckline& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Deckline*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Deckline&
|
|
operator= (const Deckline& x);
|
|
|
|
virtual
|
|
~Deckline ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Xsymbol_optional Xsymbol_;
|
|
X_optional X_;
|
|
Y_optional Y_;
|
|
Z_optional Z_;
|
|
};
|
|
|
|
class IncliningExtraWeight: 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);
|
|
|
|
// 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);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// Ratio
|
|
//
|
|
typedef ::xml_schema::double_ Ratio_type;
|
|
typedef ::xsd::cxx::tree::optional< Ratio_type > Ratio_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ratio_type, char, ::xsd::cxx::tree::schema_type::double_ > Ratio_traits;
|
|
|
|
const Ratio_optional&
|
|
Ratio () const;
|
|
|
|
Ratio_optional&
|
|
Ratio ();
|
|
|
|
void
|
|
Ratio (const Ratio_type& x);
|
|
|
|
void
|
|
Ratio (const Ratio_optional& x);
|
|
|
|
static Ratio_type
|
|
Ratio_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningExtraWeight (const ID_type&);
|
|
|
|
IncliningExtraWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningExtraWeight (const IncliningExtraWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningExtraWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningExtraWeight&
|
|
operator= (const IncliningExtraWeight& x);
|
|
|
|
virtual
|
|
~IncliningExtraWeight ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
G_optional G_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
Compartment_optional Compartment_;
|
|
Density_optional Density_;
|
|
Ratio_optional Ratio_;
|
|
};
|
|
|
|
class IncliningAbsentWeight: 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);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningAbsentWeight (const ID_type&);
|
|
|
|
IncliningAbsentWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningAbsentWeight (const IncliningAbsentWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningAbsentWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningAbsentWeight&
|
|
operator= (const IncliningAbsentWeight& x);
|
|
|
|
virtual
|
|
~IncliningAbsentWeight ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
G_optional G_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
};
|
|
|
|
class IncliningMobileWeight: 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);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_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);
|
|
|
|
// Description
|
|
//
|
|
typedef ::xml_schema::string Description_type;
|
|
typedef ::xsd::cxx::tree::optional< Description_type > Description_optional;
|
|
typedef ::xsd::cxx::tree::traits< Description_type, char > Description_traits;
|
|
|
|
const Description_optional&
|
|
Description () const;
|
|
|
|
Description_optional&
|
|
Description ();
|
|
|
|
void
|
|
Description (const Description_type& x);
|
|
|
|
void
|
|
Description (const Description_optional& x);
|
|
|
|
void
|
|
Description (::std::unique_ptr< Description_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningMobileWeight (const ID_type&);
|
|
|
|
IncliningMobileWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningMobileWeight (const IncliningMobileWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningMobileWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningMobileWeight&
|
|
operator= (const IncliningMobileWeight& x);
|
|
|
|
virtual
|
|
~IncliningMobileWeight ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
G_optional G_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
b_optional b_;
|
|
Description_optional Description_;
|
|
};
|
|
|
|
class IncliningRelocateWeight: 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);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Xg1_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg1_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg1_symbol_type > Xg1_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg1_symbol_type, char > Xg1_symbol_traits;
|
|
|
|
const Xg1_symbol_optional&
|
|
Xg1_symbol () const;
|
|
|
|
Xg1_symbol_optional&
|
|
Xg1_symbol ();
|
|
|
|
void
|
|
Xg1_symbol (const Xg1_symbol_type& x);
|
|
|
|
void
|
|
Xg1_symbol (const Xg1_symbol_optional& x);
|
|
|
|
void
|
|
Xg1_symbol (::std::unique_ptr< Xg1_symbol_type > p);
|
|
|
|
// Xg1
|
|
//
|
|
typedef ::xml_schema::double_ Xg1_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg1_type > Xg1_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg1_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg1_traits;
|
|
|
|
const Xg1_optional&
|
|
Xg1 () const;
|
|
|
|
Xg1_optional&
|
|
Xg1 ();
|
|
|
|
void
|
|
Xg1 (const Xg1_type& x);
|
|
|
|
void
|
|
Xg1 (const Xg1_optional& x);
|
|
|
|
// Yg1
|
|
//
|
|
typedef ::xml_schema::double_ Yg1_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg1_type > Yg1_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg1_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg1_traits;
|
|
|
|
const Yg1_optional&
|
|
Yg1 () const;
|
|
|
|
Yg1_optional&
|
|
Yg1 ();
|
|
|
|
void
|
|
Yg1 (const Yg1_type& x);
|
|
|
|
void
|
|
Yg1 (const Yg1_optional& x);
|
|
|
|
// Zg1
|
|
//
|
|
typedef ::xml_schema::double_ Zg1_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg1_type > Zg1_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg1_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg1_traits;
|
|
|
|
const Zg1_optional&
|
|
Zg1 () const;
|
|
|
|
Zg1_optional&
|
|
Zg1 ();
|
|
|
|
void
|
|
Zg1 (const Zg1_type& x);
|
|
|
|
void
|
|
Zg1 (const Zg1_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningRelocateWeight (const ID_type&);
|
|
|
|
IncliningRelocateWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningRelocateWeight (const IncliningRelocateWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningRelocateWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningRelocateWeight&
|
|
operator= (const IncliningRelocateWeight& x);
|
|
|
|
virtual
|
|
~IncliningRelocateWeight ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
G_optional G_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
Xg1_symbol_optional Xg1_symbol_;
|
|
Xg1_optional Xg1_;
|
|
Yg1_optional Yg1_;
|
|
Zg1_optional Zg1_;
|
|
};
|
|
|
|
class IncliningStatus: 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.
|
|
//
|
|
IncliningStatus (const ParamID_type&);
|
|
|
|
IncliningStatus (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningStatus (const IncliningStatus& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningStatus*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningStatus&
|
|
operator= (const IncliningStatus& x);
|
|
|
|
virtual
|
|
~IncliningStatus ();
|
|
|
|
// 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 IncliningDevice: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// ID
|
|
//
|
|
typedef ::xml_schema::int_ 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);
|
|
|
|
// X
|
|
//
|
|
typedef ::xml_schema::string X_type;
|
|
typedef ::xsd::cxx::tree::optional< X_type > X_optional;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char > X_traits;
|
|
|
|
const X_optional&
|
|
X () const;
|
|
|
|
X_optional&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
void
|
|
X (const X_optional& x);
|
|
|
|
void
|
|
X (::std::unique_ptr< X_type > p);
|
|
|
|
// Param
|
|
//
|
|
typedef ::xml_schema::string Param_type;
|
|
typedef ::xsd::cxx::tree::optional< Param_type > Param_optional;
|
|
typedef ::xsd::cxx::tree::traits< Param_type, char > Param_traits;
|
|
|
|
const Param_optional&
|
|
Param () const;
|
|
|
|
Param_optional&
|
|
Param ();
|
|
|
|
void
|
|
Param (const Param_type& x);
|
|
|
|
void
|
|
Param (const Param_optional& x);
|
|
|
|
void
|
|
Param (::std::unique_ptr< Param_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.
|
|
//
|
|
IncliningDevice (const ID_type&);
|
|
|
|
IncliningDevice (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningDevice (const IncliningDevice& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningDevice*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningDevice&
|
|
operator= (const IncliningDevice& x);
|
|
|
|
virtual
|
|
~IncliningDevice ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
X_optional X_;
|
|
Param_optional Param_;
|
|
Remark_optional Remark_;
|
|
};
|
|
|
|
class IncliningDraft: 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);
|
|
|
|
// Aft
|
|
//
|
|
typedef ::xml_schema::double_ Aft_type;
|
|
typedef ::xsd::cxx::tree::optional< Aft_type > Aft_optional;
|
|
typedef ::xsd::cxx::tree::traits< Aft_type, char, ::xsd::cxx::tree::schema_type::double_ > Aft_traits;
|
|
|
|
const Aft_optional&
|
|
Aft () const;
|
|
|
|
Aft_optional&
|
|
Aft ();
|
|
|
|
void
|
|
Aft (const Aft_type& x);
|
|
|
|
void
|
|
Aft (const Aft_optional& x);
|
|
|
|
// Mid
|
|
//
|
|
typedef ::xml_schema::double_ Mid_type;
|
|
typedef ::xsd::cxx::tree::optional< Mid_type > Mid_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mid_type, char, ::xsd::cxx::tree::schema_type::double_ > Mid_traits;
|
|
|
|
const Mid_optional&
|
|
Mid () const;
|
|
|
|
Mid_optional&
|
|
Mid ();
|
|
|
|
void
|
|
Mid (const Mid_type& x);
|
|
|
|
void
|
|
Mid (const Mid_optional& x);
|
|
|
|
// Bow
|
|
//
|
|
typedef ::xml_schema::double_ Bow_type;
|
|
typedef ::xsd::cxx::tree::optional< Bow_type > Bow_optional;
|
|
typedef ::xsd::cxx::tree::traits< Bow_type, char, ::xsd::cxx::tree::schema_type::double_ > Bow_traits;
|
|
|
|
const Bow_optional&
|
|
Bow () const;
|
|
|
|
Bow_optional&
|
|
Bow ();
|
|
|
|
void
|
|
Bow (const Bow_type& x);
|
|
|
|
void
|
|
Bow (const Bow_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.
|
|
//
|
|
IncliningDraft (const ID_type&);
|
|
|
|
IncliningDraft (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningDraft (const IncliningDraft& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningDraft*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningDraft&
|
|
operator= (const IncliningDraft& x);
|
|
|
|
virtual
|
|
~IncliningDraft ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Aft_optional Aft_;
|
|
Mid_optional Mid_;
|
|
Bow_optional Bow_;
|
|
Remark_optional Remark_;
|
|
};
|
|
|
|
class IncliningTank: 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);
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Ratio
|
|
//
|
|
typedef ::xml_schema::double_ Ratio_type;
|
|
typedef ::xsd::cxx::tree::optional< Ratio_type > Ratio_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ratio_type, char, ::xsd::cxx::tree::schema_type::double_ > Ratio_traits;
|
|
|
|
const Ratio_optional&
|
|
Ratio () const;
|
|
|
|
Ratio_optional&
|
|
Ratio ();
|
|
|
|
void
|
|
Ratio (const Ratio_type& x);
|
|
|
|
void
|
|
Ratio (const Ratio_optional& x);
|
|
|
|
static Ratio_type
|
|
Ratio_default_value ();
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// 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.
|
|
//
|
|
IncliningTank (const ID_type&);
|
|
|
|
IncliningTank (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningTank (const IncliningTank& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningTank*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningTank&
|
|
operator= (const IncliningTank& x);
|
|
|
|
virtual
|
|
~IncliningTank ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Compartment_optional Compartment_;
|
|
G_optional G_;
|
|
Ratio_optional Ratio_;
|
|
Density_optional Density_;
|
|
V_optional V_;
|
|
l_optional l_;
|
|
b_optional b_;
|
|
h_optional h_;
|
|
};
|
|
|
|
class IncliningCase: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// ID
|
|
//
|
|
typedef ::xml_schema::int_ 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);
|
|
|
|
// WeightIDs
|
|
//
|
|
typedef ::xml_schema::string WeightIDs_type;
|
|
typedef ::xsd::cxx::tree::optional< WeightIDs_type > WeightIDs_optional;
|
|
typedef ::xsd::cxx::tree::traits< WeightIDs_type, char > WeightIDs_traits;
|
|
|
|
const WeightIDs_optional&
|
|
WeightIDs () const;
|
|
|
|
WeightIDs_optional&
|
|
WeightIDs ();
|
|
|
|
void
|
|
WeightIDs (const WeightIDs_type& x);
|
|
|
|
void
|
|
WeightIDs (const WeightIDs_optional& x);
|
|
|
|
void
|
|
WeightIDs (::std::unique_ptr< WeightIDs_type > p);
|
|
|
|
// PortWeightIDs
|
|
//
|
|
typedef ::xml_schema::string PortWeightIDs_type;
|
|
typedef ::xsd::cxx::tree::optional< PortWeightIDs_type > PortWeightIDs_optional;
|
|
typedef ::xsd::cxx::tree::traits< PortWeightIDs_type, char > PortWeightIDs_traits;
|
|
|
|
const PortWeightIDs_optional&
|
|
PortWeightIDs () const;
|
|
|
|
PortWeightIDs_optional&
|
|
PortWeightIDs ();
|
|
|
|
void
|
|
PortWeightIDs (const PortWeightIDs_type& x);
|
|
|
|
void
|
|
PortWeightIDs (const PortWeightIDs_optional& x);
|
|
|
|
void
|
|
PortWeightIDs (::std::unique_ptr< PortWeightIDs_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningCase (const ID_type&);
|
|
|
|
IncliningCase (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningCase (const IncliningCase& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningCase*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningCase&
|
|
operator= (const IncliningCase& x);
|
|
|
|
virtual
|
|
~IncliningCase ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
WeightIDs_optional WeightIDs_;
|
|
PortWeightIDs_optional PortWeightIDs_;
|
|
};
|
|
|
|
class IncliningRecord: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// DeviceID
|
|
//
|
|
typedef ::xml_schema::int_ DeviceID_type;
|
|
typedef ::xsd::cxx::tree::traits< DeviceID_type, char > DeviceID_traits;
|
|
|
|
const DeviceID_type&
|
|
DeviceID () const;
|
|
|
|
DeviceID_type&
|
|
DeviceID ();
|
|
|
|
void
|
|
DeviceID (const DeviceID_type& x);
|
|
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::int_ CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
// No1
|
|
//
|
|
typedef ::xml_schema::string No1_type;
|
|
typedef ::xsd::cxx::tree::optional< No1_type > No1_optional;
|
|
typedef ::xsd::cxx::tree::traits< No1_type, char > No1_traits;
|
|
|
|
const No1_optional&
|
|
No1 () const;
|
|
|
|
No1_optional&
|
|
No1 ();
|
|
|
|
void
|
|
No1 (const No1_type& x);
|
|
|
|
void
|
|
No1 (const No1_optional& x);
|
|
|
|
void
|
|
No1 (::std::unique_ptr< No1_type > p);
|
|
|
|
// No2
|
|
//
|
|
typedef ::xml_schema::string No2_type;
|
|
typedef ::xsd::cxx::tree::optional< No2_type > No2_optional;
|
|
typedef ::xsd::cxx::tree::traits< No2_type, char > No2_traits;
|
|
|
|
const No2_optional&
|
|
No2 () const;
|
|
|
|
No2_optional&
|
|
No2 ();
|
|
|
|
void
|
|
No2 (const No2_type& x);
|
|
|
|
void
|
|
No2 (const No2_optional& x);
|
|
|
|
void
|
|
No2 (::std::unique_ptr< No2_type > p);
|
|
|
|
// No3
|
|
//
|
|
typedef ::xml_schema::string No3_type;
|
|
typedef ::xsd::cxx::tree::optional< No3_type > No3_optional;
|
|
typedef ::xsd::cxx::tree::traits< No3_type, char > No3_traits;
|
|
|
|
const No3_optional&
|
|
No3 () const;
|
|
|
|
No3_optional&
|
|
No3 ();
|
|
|
|
void
|
|
No3 (const No3_type& x);
|
|
|
|
void
|
|
No3 (const No3_optional& x);
|
|
|
|
void
|
|
No3 (::std::unique_ptr< No3_type > p);
|
|
|
|
// No4
|
|
//
|
|
typedef ::xml_schema::string No4_type;
|
|
typedef ::xsd::cxx::tree::optional< No4_type > No4_optional;
|
|
typedef ::xsd::cxx::tree::traits< No4_type, char > No4_traits;
|
|
|
|
const No4_optional&
|
|
No4 () const;
|
|
|
|
No4_optional&
|
|
No4 ();
|
|
|
|
void
|
|
No4 (const No4_type& x);
|
|
|
|
void
|
|
No4 (const No4_optional& x);
|
|
|
|
void
|
|
No4 (::std::unique_ptr< No4_type > p);
|
|
|
|
// No5
|
|
//
|
|
typedef ::xml_schema::string No5_type;
|
|
typedef ::xsd::cxx::tree::optional< No5_type > No5_optional;
|
|
typedef ::xsd::cxx::tree::traits< No5_type, char > No5_traits;
|
|
|
|
const No5_optional&
|
|
No5 () const;
|
|
|
|
No5_optional&
|
|
No5 ();
|
|
|
|
void
|
|
No5 (const No5_type& x);
|
|
|
|
void
|
|
No5 (const No5_optional& x);
|
|
|
|
void
|
|
No5 (::std::unique_ptr< No5_type > p);
|
|
|
|
// No6
|
|
//
|
|
typedef ::xml_schema::string No6_type;
|
|
typedef ::xsd::cxx::tree::optional< No6_type > No6_optional;
|
|
typedef ::xsd::cxx::tree::traits< No6_type, char > No6_traits;
|
|
|
|
const No6_optional&
|
|
No6 () const;
|
|
|
|
No6_optional&
|
|
No6 ();
|
|
|
|
void
|
|
No6 (const No6_type& x);
|
|
|
|
void
|
|
No6 (const No6_optional& x);
|
|
|
|
void
|
|
No6 (::std::unique_ptr< No6_type > p);
|
|
|
|
// No7
|
|
//
|
|
typedef ::xml_schema::string No7_type;
|
|
typedef ::xsd::cxx::tree::optional< No7_type > No7_optional;
|
|
typedef ::xsd::cxx::tree::traits< No7_type, char > No7_traits;
|
|
|
|
const No7_optional&
|
|
No7 () const;
|
|
|
|
No7_optional&
|
|
No7 ();
|
|
|
|
void
|
|
No7 (const No7_type& x);
|
|
|
|
void
|
|
No7 (const No7_optional& x);
|
|
|
|
void
|
|
No7 (::std::unique_ptr< No7_type > p);
|
|
|
|
// No8
|
|
//
|
|
typedef ::xml_schema::string No8_type;
|
|
typedef ::xsd::cxx::tree::optional< No8_type > No8_optional;
|
|
typedef ::xsd::cxx::tree::traits< No8_type, char > No8_traits;
|
|
|
|
const No8_optional&
|
|
No8 () const;
|
|
|
|
No8_optional&
|
|
No8 ();
|
|
|
|
void
|
|
No8 (const No8_type& x);
|
|
|
|
void
|
|
No8 (const No8_optional& x);
|
|
|
|
void
|
|
No8 (::std::unique_ptr< No8_type > p);
|
|
|
|
// No9
|
|
//
|
|
typedef ::xml_schema::string No9_type;
|
|
typedef ::xsd::cxx::tree::optional< No9_type > No9_optional;
|
|
typedef ::xsd::cxx::tree::traits< No9_type, char > No9_traits;
|
|
|
|
const No9_optional&
|
|
No9 () const;
|
|
|
|
No9_optional&
|
|
No9 ();
|
|
|
|
void
|
|
No9 (const No9_type& x);
|
|
|
|
void
|
|
No9 (const No9_optional& x);
|
|
|
|
void
|
|
No9 (::std::unique_ptr< No9_type > p);
|
|
|
|
// Avg
|
|
//
|
|
typedef ::xml_schema::string Avg_type;
|
|
typedef ::xsd::cxx::tree::optional< Avg_type > Avg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Avg_type, char > Avg_traits;
|
|
|
|
const Avg_optional&
|
|
Avg () const;
|
|
|
|
Avg_optional&
|
|
Avg ();
|
|
|
|
void
|
|
Avg (const Avg_type& x);
|
|
|
|
void
|
|
Avg (const Avg_optional& x);
|
|
|
|
void
|
|
Avg (::std::unique_ptr< Avg_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
IncliningRecord (const DeviceID_type&,
|
|
const CaseID_type&);
|
|
|
|
IncliningRecord (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
IncliningRecord (const IncliningRecord& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual IncliningRecord*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
IncliningRecord&
|
|
operator= (const IncliningRecord& x);
|
|
|
|
virtual
|
|
~IncliningRecord ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< DeviceID_type > DeviceID_;
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
No1_optional No1_;
|
|
No2_optional No2_;
|
|
No3_optional No3_;
|
|
No4_optional No4_;
|
|
No5_optional No5_;
|
|
No6_optional No6_;
|
|
No7_optional No7_;
|
|
No8_optional No8_;
|
|
No9_optional No9_;
|
|
Avg_optional Avg_;
|
|
};
|
|
|
|
class Shell: 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);
|
|
|
|
// ShellID
|
|
//
|
|
typedef ::xml_schema::string ShellID_type;
|
|
typedef ::xsd::cxx::tree::traits< ShellID_type, char > ShellID_traits;
|
|
|
|
const ShellID_type&
|
|
ShellID () const;
|
|
|
|
ShellID_type&
|
|
ShellID ();
|
|
|
|
void
|
|
ShellID (const ShellID_type& x);
|
|
|
|
void
|
|
ShellID (::std::unique_ptr< ShellID_type > p);
|
|
|
|
// 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 ();
|
|
|
|
// ShellAffect
|
|
//
|
|
typedef ::xml_schema::int_ ShellAffect_type;
|
|
typedef ::xsd::cxx::tree::optional< ShellAffect_type > ShellAffect_optional;
|
|
typedef ::xsd::cxx::tree::traits< ShellAffect_type, char > ShellAffect_traits;
|
|
|
|
const ShellAffect_optional&
|
|
ShellAffect () const;
|
|
|
|
ShellAffect_optional&
|
|
ShellAffect ();
|
|
|
|
void
|
|
ShellAffect (const ShellAffect_type& x);
|
|
|
|
void
|
|
ShellAffect (const ShellAffect_optional& x);
|
|
|
|
static ShellAffect_type
|
|
ShellAffect_default_value ();
|
|
|
|
// AffectCoef
|
|
//
|
|
typedef ::xml_schema::double_ AffectCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< AffectCoef_type > AffectCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< AffectCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > AffectCoef_traits;
|
|
|
|
const AffectCoef_optional&
|
|
AffectCoef () const;
|
|
|
|
AffectCoef_optional&
|
|
AffectCoef ();
|
|
|
|
void
|
|
AffectCoef (const AffectCoef_type& x);
|
|
|
|
void
|
|
AffectCoef (const AffectCoef_optional& x);
|
|
|
|
static AffectCoef_type
|
|
AffectCoef_default_value ();
|
|
|
|
// 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.
|
|
//
|
|
Shell (const ID_type&,
|
|
const ShellID_type&);
|
|
|
|
Shell (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Shell (const Shell& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Shell*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Shell&
|
|
operator= (const Shell& x);
|
|
|
|
virtual
|
|
~Shell ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
::xsd::cxx::tree::one< ShellID_type > ShellID_;
|
|
Type_optional Type_;
|
|
ShellAffect_optional ShellAffect_;
|
|
AffectCoef_optional AffectCoef_;
|
|
Remark_optional Remark_;
|
|
SID_optional SID_;
|
|
};
|
|
|
|
class PartialLoad: 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);
|
|
|
|
// 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.
|
|
//
|
|
PartialLoad (const ID_type&);
|
|
|
|
PartialLoad (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoad (const PartialLoad& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoad*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoad&
|
|
operator= (const PartialLoad& x);
|
|
|
|
virtual
|
|
~PartialLoad ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Remark_optional Remark_;
|
|
};
|
|
|
|
class PartialLoadItem: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// Type
|
|
//
|
|
typedef ::xml_schema::string 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);
|
|
|
|
void
|
|
Type (::std::unique_ptr< Type_type > p);
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Ratio
|
|
//
|
|
typedef ::xml_schema::double_ Ratio_type;
|
|
typedef ::xsd::cxx::tree::optional< Ratio_type > Ratio_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ratio_type, char, ::xsd::cxx::tree::schema_type::double_ > Ratio_traits;
|
|
|
|
const Ratio_optional&
|
|
Ratio () const;
|
|
|
|
Ratio_optional&
|
|
Ratio ();
|
|
|
|
void
|
|
Ratio (const Ratio_type& x);
|
|
|
|
void
|
|
Ratio (const Ratio_optional& x);
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Xa_symbol
|
|
//
|
|
typedef ::xml_schema::string Xa_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_symbol_type > Xa_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_symbol_type, char > Xa_symbol_traits;
|
|
|
|
const Xa_symbol_optional&
|
|
Xa_symbol () const;
|
|
|
|
Xa_symbol_optional&
|
|
Xa_symbol ();
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_type& x);
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_optional& x);
|
|
|
|
void
|
|
Xa_symbol (::std::unique_ptr< Xa_symbol_type > p);
|
|
|
|
// Xf_symbol
|
|
//
|
|
typedef ::xml_schema::string Xf_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_symbol_type > Xf_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_symbol_type, char > Xf_symbol_traits;
|
|
|
|
const Xf_symbol_optional&
|
|
Xf_symbol () const;
|
|
|
|
Xf_symbol_optional&
|
|
Xf_symbol ();
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_type& x);
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_optional& x);
|
|
|
|
void
|
|
Xf_symbol (::std::unique_ptr< Xf_symbol_type > p);
|
|
|
|
// Xa
|
|
//
|
|
typedef ::xml_schema::double_ Xa_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_type > Xa_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_type, char, ::xsd::cxx::tree::schema_type::double_ > Xa_traits;
|
|
|
|
const Xa_optional&
|
|
Xa () const;
|
|
|
|
Xa_optional&
|
|
Xa ();
|
|
|
|
void
|
|
Xa (const Xa_type& x);
|
|
|
|
void
|
|
Xa (const Xa_optional& x);
|
|
|
|
// Xf
|
|
//
|
|
typedef ::xml_schema::double_ Xf_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_type > Xf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_type, char, ::xsd::cxx::tree::schema_type::double_ > Xf_traits;
|
|
|
|
const Xf_optional&
|
|
Xf () const;
|
|
|
|
Xf_optional&
|
|
Xf ();
|
|
|
|
void
|
|
Xf (const Xf_type& x);
|
|
|
|
void
|
|
Xf (const Xf_optional& x);
|
|
|
|
// FreeSurfType
|
|
//
|
|
typedef ::xml_schema::int_ FreeSurfType_type;
|
|
typedef ::xsd::cxx::tree::optional< FreeSurfType_type > FreeSurfType_optional;
|
|
typedef ::xsd::cxx::tree::traits< FreeSurfType_type, char > FreeSurfType_traits;
|
|
|
|
const FreeSurfType_optional&
|
|
FreeSurfType () const;
|
|
|
|
FreeSurfType_optional&
|
|
FreeSurfType ();
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_type& x);
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_optional& x);
|
|
|
|
// 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);
|
|
|
|
// PersonType
|
|
//
|
|
typedef ::xml_schema::int_ PersonType_type;
|
|
typedef ::xsd::cxx::tree::optional< PersonType_type > PersonType_optional;
|
|
typedef ::xsd::cxx::tree::traits< PersonType_type, char > PersonType_traits;
|
|
|
|
const PersonType_optional&
|
|
PersonType () const;
|
|
|
|
PersonType_optional&
|
|
PersonType ();
|
|
|
|
void
|
|
PersonType (const PersonType_type& x);
|
|
|
|
void
|
|
PersonType (const PersonType_optional& x);
|
|
|
|
// Np
|
|
//
|
|
typedef ::xml_schema::double_ Np_type;
|
|
typedef ::xsd::cxx::tree::optional< Np_type > Np_optional;
|
|
typedef ::xsd::cxx::tree::traits< Np_type, char, ::xsd::cxx::tree::schema_type::double_ > Np_traits;
|
|
|
|
const Np_optional&
|
|
Np () const;
|
|
|
|
Np_optional&
|
|
Np ();
|
|
|
|
void
|
|
Np (const Np_type& x);
|
|
|
|
void
|
|
Np (const Np_optional& x);
|
|
|
|
// bp
|
|
//
|
|
typedef ::xml_schema::double_ bp_type;
|
|
typedef ::xsd::cxx::tree::optional< bp_type > bp_optional;
|
|
typedef ::xsd::cxx::tree::traits< bp_type, char, ::xsd::cxx::tree::schema_type::double_ > bp_traits;
|
|
|
|
const bp_optional&
|
|
bp () const;
|
|
|
|
bp_optional&
|
|
bp ();
|
|
|
|
void
|
|
bp (const bp_type& x);
|
|
|
|
void
|
|
bp (const bp_optional& x);
|
|
|
|
// lp
|
|
//
|
|
typedef ::xml_schema::double_ lp_type;
|
|
typedef ::xsd::cxx::tree::optional< lp_type > lp_optional;
|
|
typedef ::xsd::cxx::tree::traits< lp_type, char, ::xsd::cxx::tree::schema_type::double_ > lp_traits;
|
|
|
|
const lp_optional&
|
|
lp () const;
|
|
|
|
lp_optional&
|
|
lp ();
|
|
|
|
void
|
|
lp (const lp_type& x);
|
|
|
|
void
|
|
lp (const lp_optional& x);
|
|
|
|
// Mpy
|
|
//
|
|
typedef ::xml_schema::double_ Mpy_type;
|
|
typedef ::xsd::cxx::tree::optional< Mpy_type > Mpy_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mpy_type, char, ::xsd::cxx::tree::schema_type::double_ > Mpy_traits;
|
|
|
|
const Mpy_optional&
|
|
Mpy () const;
|
|
|
|
Mpy_optional&
|
|
Mpy ();
|
|
|
|
void
|
|
Mpy (const Mpy_type& x);
|
|
|
|
void
|
|
Mpy (const Mpy_optional& x);
|
|
|
|
// Mpz
|
|
//
|
|
typedef ::xml_schema::double_ Mpz_type;
|
|
typedef ::xsd::cxx::tree::optional< Mpz_type > Mpz_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mpz_type, char, ::xsd::cxx::tree::schema_type::double_ > Mpz_traits;
|
|
|
|
const Mpz_optional&
|
|
Mpz () const;
|
|
|
|
Mpz_optional&
|
|
Mpz ();
|
|
|
|
void
|
|
Mpz (const Mpz_type& x);
|
|
|
|
void
|
|
Mpz (const Mpz_optional& x);
|
|
|
|
// Gbulk
|
|
//
|
|
typedef ::xml_schema::double_ Gbulk_type;
|
|
typedef ::xsd::cxx::tree::optional< Gbulk_type > Gbulk_optional;
|
|
typedef ::xsd::cxx::tree::traits< Gbulk_type, char, ::xsd::cxx::tree::schema_type::double_ > Gbulk_traits;
|
|
|
|
const Gbulk_optional&
|
|
Gbulk () const;
|
|
|
|
Gbulk_optional&
|
|
Gbulk ();
|
|
|
|
void
|
|
Gbulk (const Gbulk_type& x);
|
|
|
|
void
|
|
Gbulk (const Gbulk_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadItem (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadItem (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadItem (const PartialLoadItem& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadItem*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadItem&
|
|
operator= (const PartialLoadItem& x);
|
|
|
|
virtual
|
|
~PartialLoadItem ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
Compartment_optional Compartment_;
|
|
G_optional G_;
|
|
Ratio_optional Ratio_;
|
|
Density_optional Density_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
Xa_symbol_optional Xa_symbol_;
|
|
Xf_symbol_optional Xf_symbol_;
|
|
Xa_optional Xa_;
|
|
Xf_optional Xf_;
|
|
FreeSurfType_optional FreeSurfType_;
|
|
V_optional V_;
|
|
l_optional l_;
|
|
b_optional b_;
|
|
h_optional h_;
|
|
PersonType_optional PersonType_;
|
|
Np_optional Np_;
|
|
bp_optional bp_;
|
|
lp_optional lp_;
|
|
Mpy_optional Mpy_;
|
|
Mpz_optional Mpz_;
|
|
Gbulk_optional Gbulk_;
|
|
};
|
|
|
|
class StationLabel: 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);
|
|
|
|
// Pos
|
|
//
|
|
typedef ::xml_schema::double_ Pos_type;
|
|
typedef ::xsd::cxx::tree::optional< Pos_type > Pos_optional;
|
|
typedef ::xsd::cxx::tree::traits< Pos_type, char, ::xsd::cxx::tree::schema_type::double_ > Pos_traits;
|
|
|
|
const Pos_optional&
|
|
Pos () const;
|
|
|
|
Pos_optional&
|
|
Pos ();
|
|
|
|
void
|
|
Pos (const Pos_type& x);
|
|
|
|
void
|
|
Pos (const Pos_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
StationLabel (const ID_type&);
|
|
|
|
StationLabel (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
StationLabel (const StationLabel& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual StationLabel*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
StationLabel&
|
|
operator= (const StationLabel& x);
|
|
|
|
virtual
|
|
~StationLabel ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Pos_optional Pos_;
|
|
};
|
|
|
|
class WaterlineLabel: 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);
|
|
|
|
// Pos
|
|
//
|
|
typedef ::xml_schema::double_ Pos_type;
|
|
typedef ::xsd::cxx::tree::optional< Pos_type > Pos_optional;
|
|
typedef ::xsd::cxx::tree::traits< Pos_type, char, ::xsd::cxx::tree::schema_type::double_ > Pos_traits;
|
|
|
|
const Pos_optional&
|
|
Pos () const;
|
|
|
|
Pos_optional&
|
|
Pos ();
|
|
|
|
void
|
|
Pos (const Pos_type& x);
|
|
|
|
void
|
|
Pos (const Pos_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
WaterlineLabel (const ID_type&);
|
|
|
|
WaterlineLabel (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
WaterlineLabel (const WaterlineLabel& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual WaterlineLabel*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
WaterlineLabel&
|
|
operator= (const WaterlineLabel& x);
|
|
|
|
virtual
|
|
~WaterlineLabel ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Pos_optional Pos_;
|
|
};
|
|
|
|
class ButtocklineLabel: 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);
|
|
|
|
// Pos
|
|
//
|
|
typedef ::xml_schema::double_ Pos_type;
|
|
typedef ::xsd::cxx::tree::optional< Pos_type > Pos_optional;
|
|
typedef ::xsd::cxx::tree::traits< Pos_type, char, ::xsd::cxx::tree::schema_type::double_ > Pos_traits;
|
|
|
|
const Pos_optional&
|
|
Pos () const;
|
|
|
|
Pos_optional&
|
|
Pos ();
|
|
|
|
void
|
|
Pos (const Pos_type& x);
|
|
|
|
void
|
|
Pos (const Pos_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
ButtocklineLabel (const ID_type&);
|
|
|
|
ButtocklineLabel (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ButtocklineLabel (const ButtocklineLabel& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ButtocklineLabel*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ButtocklineLabel&
|
|
operator= (const ButtocklineLabel& x);
|
|
|
|
virtual
|
|
~ButtocklineLabel ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Pos_optional Pos_;
|
|
};
|
|
|
|
class PartialLoadWeight: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// WtType
|
|
//
|
|
typedef ::xml_schema::int_ WtType_type;
|
|
typedef ::xsd::cxx::tree::optional< WtType_type > WtType_optional;
|
|
typedef ::xsd::cxx::tree::traits< WtType_type, char > WtType_traits;
|
|
|
|
const WtType_optional&
|
|
WtType () const;
|
|
|
|
WtType_optional&
|
|
WtType ();
|
|
|
|
void
|
|
WtType (const WtType_type& x);
|
|
|
|
void
|
|
WtType (const WtType_optional& x);
|
|
|
|
static WtType_type
|
|
WtType_default_value ();
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// CompartType
|
|
//
|
|
typedef ::xml_schema::int_ CompartType_type;
|
|
typedef ::xsd::cxx::tree::optional< CompartType_type > CompartType_optional;
|
|
typedef ::xsd::cxx::tree::traits< CompartType_type, char > CompartType_traits;
|
|
|
|
const CompartType_optional&
|
|
CompartType () const;
|
|
|
|
CompartType_optional&
|
|
CompartType ();
|
|
|
|
void
|
|
CompartType (const CompartType_type& x);
|
|
|
|
void
|
|
CompartType (const CompartType_optional& x);
|
|
|
|
static CompartType_type
|
|
CompartType_default_value ();
|
|
|
|
// FreeSurfType
|
|
//
|
|
typedef ::xml_schema::int_ FreeSurfType_type;
|
|
typedef ::xsd::cxx::tree::optional< FreeSurfType_type > FreeSurfType_optional;
|
|
typedef ::xsd::cxx::tree::traits< FreeSurfType_type, char > FreeSurfType_traits;
|
|
|
|
const FreeSurfType_optional&
|
|
FreeSurfType () const;
|
|
|
|
FreeSurfType_optional&
|
|
FreeSurfType ();
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_type& x);
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_optional& x);
|
|
|
|
static FreeSurfType_type
|
|
FreeSurfType_default_value ();
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Ratio
|
|
//
|
|
typedef ::xml_schema::double_ Ratio_type;
|
|
typedef ::xsd::cxx::tree::optional< Ratio_type > Ratio_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ratio_type, char, ::xsd::cxx::tree::schema_type::double_ > Ratio_traits;
|
|
|
|
const Ratio_optional&
|
|
Ratio () const;
|
|
|
|
Ratio_optional&
|
|
Ratio ();
|
|
|
|
void
|
|
Ratio (const Ratio_type& x);
|
|
|
|
void
|
|
Ratio (const Ratio_optional& x);
|
|
|
|
static Ratio_type
|
|
Ratio_default_value ();
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Xa_symbol
|
|
//
|
|
typedef ::xml_schema::string Xa_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_symbol_type > Xa_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_symbol_type, char > Xa_symbol_traits;
|
|
|
|
const Xa_symbol_optional&
|
|
Xa_symbol () const;
|
|
|
|
Xa_symbol_optional&
|
|
Xa_symbol ();
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_type& x);
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_optional& x);
|
|
|
|
void
|
|
Xa_symbol (::std::unique_ptr< Xa_symbol_type > p);
|
|
|
|
// Xf_symbol
|
|
//
|
|
typedef ::xml_schema::string Xf_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_symbol_type > Xf_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_symbol_type, char > Xf_symbol_traits;
|
|
|
|
const Xf_symbol_optional&
|
|
Xf_symbol () const;
|
|
|
|
Xf_symbol_optional&
|
|
Xf_symbol ();
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_type& x);
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_optional& x);
|
|
|
|
void
|
|
Xf_symbol (::std::unique_ptr< Xf_symbol_type > p);
|
|
|
|
// Xa
|
|
//
|
|
typedef ::xml_schema::double_ Xa_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_type > Xa_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_type, char, ::xsd::cxx::tree::schema_type::double_ > Xa_traits;
|
|
|
|
const Xa_optional&
|
|
Xa () const;
|
|
|
|
Xa_optional&
|
|
Xa ();
|
|
|
|
void
|
|
Xa (const Xa_type& x);
|
|
|
|
void
|
|
Xa (const Xa_optional& x);
|
|
|
|
// Xf
|
|
//
|
|
typedef ::xml_schema::double_ Xf_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_type > Xf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_type, char, ::xsd::cxx::tree::schema_type::double_ > Xf_traits;
|
|
|
|
const Xf_optional&
|
|
Xf () const;
|
|
|
|
Xf_optional&
|
|
Xf ();
|
|
|
|
void
|
|
Xf (const Xf_type& x);
|
|
|
|
void
|
|
Xf (const Xf_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadWeight (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadWeight (const PartialLoadWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadWeight&
|
|
operator= (const PartialLoadWeight& x);
|
|
|
|
virtual
|
|
~PartialLoadWeight ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
WtType_optional WtType_;
|
|
Compartment_optional Compartment_;
|
|
CompartType_optional CompartType_;
|
|
FreeSurfType_optional FreeSurfType_;
|
|
G_optional G_;
|
|
Ratio_optional Ratio_;
|
|
Density_optional Density_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
Xa_symbol_optional Xa_symbol_;
|
|
Xf_symbol_optional Xf_symbol_;
|
|
Xa_optional Xa_;
|
|
Xf_optional Xf_;
|
|
};
|
|
|
|
class PartialLoadFreeSurf: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// FreeSurfType
|
|
//
|
|
typedef ::xml_schema::int_ FreeSurfType_type;
|
|
typedef ::xsd::cxx::tree::optional< FreeSurfType_type > FreeSurfType_optional;
|
|
typedef ::xsd::cxx::tree::traits< FreeSurfType_type, char > FreeSurfType_traits;
|
|
|
|
const FreeSurfType_optional&
|
|
FreeSurfType () const;
|
|
|
|
FreeSurfType_optional&
|
|
FreeSurfType ();
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_type& x);
|
|
|
|
void
|
|
FreeSurfType (const FreeSurfType_optional& x);
|
|
|
|
static FreeSurfType_type
|
|
FreeSurfType_default_value ();
|
|
|
|
// Compartment
|
|
//
|
|
typedef ::xml_schema::string Compartment_type;
|
|
typedef ::xsd::cxx::tree::optional< Compartment_type > Compartment_optional;
|
|
typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;
|
|
|
|
const Compartment_optional&
|
|
Compartment () const;
|
|
|
|
Compartment_optional&
|
|
Compartment ();
|
|
|
|
void
|
|
Compartment (const Compartment_type& x);
|
|
|
|
void
|
|
Compartment (const Compartment_optional& x);
|
|
|
|
void
|
|
Compartment (::std::unique_ptr< Compartment_type > p);
|
|
|
|
// G
|
|
//
|
|
typedef ::xml_schema::double_ G_type;
|
|
typedef ::xsd::cxx::tree::optional< G_type > G_optional;
|
|
typedef ::xsd::cxx::tree::traits< G_type, char, ::xsd::cxx::tree::schema_type::double_ > G_traits;
|
|
|
|
const G_optional&
|
|
G () const;
|
|
|
|
G_optional&
|
|
G ();
|
|
|
|
void
|
|
G (const G_type& x);
|
|
|
|
void
|
|
G (const G_optional& x);
|
|
|
|
// Ratio
|
|
//
|
|
typedef ::xml_schema::double_ Ratio_type;
|
|
typedef ::xsd::cxx::tree::optional< Ratio_type > Ratio_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ratio_type, char, ::xsd::cxx::tree::schema_type::double_ > Ratio_traits;
|
|
|
|
const Ratio_optional&
|
|
Ratio () const;
|
|
|
|
Ratio_optional&
|
|
Ratio ();
|
|
|
|
void
|
|
Ratio (const Ratio_type& x);
|
|
|
|
void
|
|
Ratio (const Ratio_optional& x);
|
|
|
|
static Ratio_type
|
|
Ratio_default_value ();
|
|
|
|
// Density
|
|
//
|
|
typedef ::xml_schema::double_ Density_type;
|
|
typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;
|
|
typedef ::xsd::cxx::tree::traits< Density_type, char, ::xsd::cxx::tree::schema_type::double_ > Density_traits;
|
|
|
|
const Density_optional&
|
|
Density () const;
|
|
|
|
Density_optional&
|
|
Density ();
|
|
|
|
void
|
|
Density (const Density_type& x);
|
|
|
|
void
|
|
Density (const Density_optional& x);
|
|
|
|
static Density_type
|
|
Density_default_value ();
|
|
|
|
// 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);
|
|
|
|
static V_type
|
|
V_default_value ();
|
|
|
|
// 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);
|
|
|
|
static l_type
|
|
l_default_value ();
|
|
|
|
// 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);
|
|
|
|
static b_type
|
|
b_default_value ();
|
|
|
|
// 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);
|
|
|
|
static h_type
|
|
h_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadFreeSurf (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadFreeSurf (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadFreeSurf (const PartialLoadFreeSurf& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadFreeSurf*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadFreeSurf&
|
|
operator= (const PartialLoadFreeSurf& x);
|
|
|
|
virtual
|
|
~PartialLoadFreeSurf ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
FreeSurfType_optional FreeSurfType_;
|
|
Compartment_optional Compartment_;
|
|
G_optional G_;
|
|
Ratio_optional Ratio_;
|
|
Density_optional Density_;
|
|
V_optional V_;
|
|
l_optional l_;
|
|
b_optional b_;
|
|
h_optional h_;
|
|
};
|
|
|
|
class PartialLoadPerson: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// PersonType
|
|
//
|
|
typedef ::xml_schema::int_ PersonType_type;
|
|
typedef ::xsd::cxx::tree::optional< PersonType_type > PersonType_optional;
|
|
typedef ::xsd::cxx::tree::traits< PersonType_type, char > PersonType_traits;
|
|
|
|
const PersonType_optional&
|
|
PersonType () const;
|
|
|
|
PersonType_optional&
|
|
PersonType ();
|
|
|
|
void
|
|
PersonType (const PersonType_type& x);
|
|
|
|
void
|
|
PersonType (const PersonType_optional& x);
|
|
|
|
static PersonType_type
|
|
PersonType_default_value ();
|
|
|
|
// Np
|
|
//
|
|
typedef ::xml_schema::double_ Np_type;
|
|
typedef ::xsd::cxx::tree::optional< Np_type > Np_optional;
|
|
typedef ::xsd::cxx::tree::traits< Np_type, char, ::xsd::cxx::tree::schema_type::double_ > Np_traits;
|
|
|
|
const Np_optional&
|
|
Np () const;
|
|
|
|
Np_optional&
|
|
Np ();
|
|
|
|
void
|
|
Np (const Np_type& x);
|
|
|
|
void
|
|
Np (const Np_optional& x);
|
|
|
|
static Np_type
|
|
Np_default_value ();
|
|
|
|
// bp
|
|
//
|
|
typedef ::xml_schema::double_ bp_type;
|
|
typedef ::xsd::cxx::tree::optional< bp_type > bp_optional;
|
|
typedef ::xsd::cxx::tree::traits< bp_type, char, ::xsd::cxx::tree::schema_type::double_ > bp_traits;
|
|
|
|
const bp_optional&
|
|
bp () const;
|
|
|
|
bp_optional&
|
|
bp ();
|
|
|
|
void
|
|
bp (const bp_type& x);
|
|
|
|
void
|
|
bp (const bp_optional& x);
|
|
|
|
static bp_type
|
|
bp_default_value ();
|
|
|
|
// lp
|
|
//
|
|
typedef ::xml_schema::double_ lp_type;
|
|
typedef ::xsd::cxx::tree::optional< lp_type > lp_optional;
|
|
typedef ::xsd::cxx::tree::traits< lp_type, char, ::xsd::cxx::tree::schema_type::double_ > lp_traits;
|
|
|
|
const lp_optional&
|
|
lp () const;
|
|
|
|
lp_optional&
|
|
lp ();
|
|
|
|
void
|
|
lp (const lp_type& x);
|
|
|
|
void
|
|
lp (const lp_optional& x);
|
|
|
|
static lp_type
|
|
lp_default_value ();
|
|
|
|
// Mpy
|
|
//
|
|
typedef ::xml_schema::double_ Mpy_type;
|
|
typedef ::xsd::cxx::tree::optional< Mpy_type > Mpy_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mpy_type, char, ::xsd::cxx::tree::schema_type::double_ > Mpy_traits;
|
|
|
|
const Mpy_optional&
|
|
Mpy () const;
|
|
|
|
Mpy_optional&
|
|
Mpy ();
|
|
|
|
void
|
|
Mpy (const Mpy_type& x);
|
|
|
|
void
|
|
Mpy (const Mpy_optional& x);
|
|
|
|
// Mpz
|
|
//
|
|
typedef ::xml_schema::double_ Mpz_type;
|
|
typedef ::xsd::cxx::tree::optional< Mpz_type > Mpz_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mpz_type, char, ::xsd::cxx::tree::schema_type::double_ > Mpz_traits;
|
|
|
|
const Mpz_optional&
|
|
Mpz () const;
|
|
|
|
Mpz_optional&
|
|
Mpz ();
|
|
|
|
void
|
|
Mpz (const Mpz_type& x);
|
|
|
|
void
|
|
Mpz (const Mpz_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadPerson (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadPerson (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadPerson (const PartialLoadPerson& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadPerson*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadPerson&
|
|
operator= (const PartialLoadPerson& x);
|
|
|
|
virtual
|
|
~PartialLoadPerson ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
PersonType_optional PersonType_;
|
|
Np_optional Np_;
|
|
bp_optional bp_;
|
|
lp_optional lp_;
|
|
Mpy_optional Mpy_;
|
|
Mpz_optional Mpz_;
|
|
};
|
|
|
|
class PartialLoadBulk: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// Gbulk
|
|
//
|
|
typedef ::xml_schema::double_ Gbulk_type;
|
|
typedef ::xsd::cxx::tree::optional< Gbulk_type > Gbulk_optional;
|
|
typedef ::xsd::cxx::tree::traits< Gbulk_type, char, ::xsd::cxx::tree::schema_type::double_ > Gbulk_traits;
|
|
|
|
const Gbulk_optional&
|
|
Gbulk () const;
|
|
|
|
Gbulk_optional&
|
|
Gbulk ();
|
|
|
|
void
|
|
Gbulk (const Gbulk_type& x);
|
|
|
|
void
|
|
Gbulk (const Gbulk_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadBulk (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadBulk (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadBulk (const PartialLoadBulk& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadBulk*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadBulk&
|
|
operator= (const PartialLoadBulk& x);
|
|
|
|
virtual
|
|
~PartialLoadBulk ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Gbulk_optional Gbulk_;
|
|
};
|
|
|
|
class OilRecover: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// Ws
|
|
//
|
|
typedef ::xml_schema::double_ Ws_type;
|
|
typedef ::xsd::cxx::tree::optional< Ws_type > Ws_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ws_type, char, ::xsd::cxx::tree::schema_type::double_ > Ws_traits;
|
|
|
|
const Ws_optional&
|
|
Ws () const;
|
|
|
|
Ws_optional&
|
|
Ws ();
|
|
|
|
void
|
|
Ws (const Ws_type& x);
|
|
|
|
void
|
|
Ws (const Ws_optional& x);
|
|
|
|
// bs
|
|
//
|
|
typedef ::xml_schema::double_ bs_type;
|
|
typedef ::xsd::cxx::tree::optional< bs_type > bs_optional;
|
|
typedef ::xsd::cxx::tree::traits< bs_type, char, ::xsd::cxx::tree::schema_type::double_ > bs_traits;
|
|
|
|
const bs_optional&
|
|
bs () const;
|
|
|
|
bs_optional&
|
|
bs ();
|
|
|
|
void
|
|
bs (const bs_type& x);
|
|
|
|
void
|
|
bs (const bs_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
OilRecover (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
OilRecover (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
OilRecover (const OilRecover& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual OilRecover*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
OilRecover&
|
|
operator= (const OilRecover& x);
|
|
|
|
virtual
|
|
~OilRecover ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Ws_optional Ws_;
|
|
bs_optional bs_;
|
|
};
|
|
|
|
class PartialLoadIce: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// PartialLoadID
|
|
//
|
|
typedef ::xml_schema::string PartialLoadID_type;
|
|
typedef ::xsd::cxx::tree::traits< PartialLoadID_type, char > PartialLoadID_traits;
|
|
|
|
const PartialLoadID_type&
|
|
PartialLoadID () const;
|
|
|
|
PartialLoadID_type&
|
|
PartialLoadID ();
|
|
|
|
void
|
|
PartialLoadID (const PartialLoadID_type& x);
|
|
|
|
void
|
|
PartialLoadID (::std::unique_ptr< PartialLoadID_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);
|
|
|
|
// 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 ();
|
|
|
|
// As
|
|
//
|
|
typedef ::xml_schema::double_ As_type;
|
|
typedef ::xsd::cxx::tree::optional< As_type > As_optional;
|
|
typedef ::xsd::cxx::tree::traits< As_type, char, ::xsd::cxx::tree::schema_type::double_ > As_traits;
|
|
|
|
const As_optional&
|
|
As () const;
|
|
|
|
As_optional&
|
|
As ();
|
|
|
|
void
|
|
As (const As_type& x);
|
|
|
|
void
|
|
As (const As_optional& x);
|
|
|
|
// Wi
|
|
//
|
|
typedef ::xml_schema::double_ Wi_type;
|
|
typedef ::xsd::cxx::tree::optional< Wi_type > Wi_optional;
|
|
typedef ::xsd::cxx::tree::traits< Wi_type, char, ::xsd::cxx::tree::schema_type::double_ > Wi_traits;
|
|
|
|
const Wi_optional&
|
|
Wi () const;
|
|
|
|
Wi_optional&
|
|
Wi ();
|
|
|
|
void
|
|
Wi (const Wi_type& x);
|
|
|
|
void
|
|
Wi (const Wi_optional& x);
|
|
|
|
static Wi_type
|
|
Wi_default_value ();
|
|
|
|
// Xg_symbol
|
|
//
|
|
typedef ::xml_schema::string Xg_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_symbol_type > Xg_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_symbol_type, char > Xg_symbol_traits;
|
|
|
|
const Xg_symbol_optional&
|
|
Xg_symbol () const;
|
|
|
|
Xg_symbol_optional&
|
|
Xg_symbol ();
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_type& x);
|
|
|
|
void
|
|
Xg_symbol (const Xg_symbol_optional& x);
|
|
|
|
void
|
|
Xg_symbol (::std::unique_ptr< Xg_symbol_type > p);
|
|
|
|
// Xg
|
|
//
|
|
typedef ::xml_schema::double_ Xg_type;
|
|
typedef ::xsd::cxx::tree::optional< Xg_type > Xg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xg_type, char, ::xsd::cxx::tree::schema_type::double_ > Xg_traits;
|
|
|
|
const Xg_optional&
|
|
Xg () const;
|
|
|
|
Xg_optional&
|
|
Xg ();
|
|
|
|
void
|
|
Xg (const Xg_type& x);
|
|
|
|
void
|
|
Xg (const Xg_optional& x);
|
|
|
|
// Yg
|
|
//
|
|
typedef ::xml_schema::double_ Yg_type;
|
|
typedef ::xsd::cxx::tree::optional< Yg_type > Yg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yg_type, char, ::xsd::cxx::tree::schema_type::double_ > Yg_traits;
|
|
|
|
const Yg_optional&
|
|
Yg () const;
|
|
|
|
Yg_optional&
|
|
Yg ();
|
|
|
|
void
|
|
Yg (const Yg_type& x);
|
|
|
|
void
|
|
Yg (const Yg_optional& x);
|
|
|
|
// Zg
|
|
//
|
|
typedef ::xml_schema::double_ Zg_type;
|
|
typedef ::xsd::cxx::tree::optional< Zg_type > Zg_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zg_type, char, ::xsd::cxx::tree::schema_type::double_ > Zg_traits;
|
|
|
|
const Zg_optional&
|
|
Zg () const;
|
|
|
|
Zg_optional&
|
|
Zg ();
|
|
|
|
void
|
|
Zg (const Zg_type& x);
|
|
|
|
void
|
|
Zg (const Zg_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
PartialLoadIce (const PartialLoadID_type&,
|
|
const ID_type&);
|
|
|
|
PartialLoadIce (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
PartialLoadIce (const PartialLoadIce& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual PartialLoadIce*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
PartialLoadIce&
|
|
operator= (const PartialLoadIce& x);
|
|
|
|
virtual
|
|
~PartialLoadIce ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< PartialLoadID_type > PartialLoadID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
As_optional As_;
|
|
Wi_optional Wi_;
|
|
Xg_symbol_optional Xg_symbol_;
|
|
Xg_optional Xg_;
|
|
Yg_optional Yg_;
|
|
Zg_optional Zg_;
|
|
};
|
|
|
|
class SuspendLoad: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// p
|
|
//
|
|
typedef ::xml_schema::double_ p_type;
|
|
typedef ::xsd::cxx::tree::optional< p_type > p_optional;
|
|
typedef ::xsd::cxx::tree::traits< p_type, char, ::xsd::cxx::tree::schema_type::double_ > p_traits;
|
|
|
|
const p_optional&
|
|
p () const;
|
|
|
|
p_optional&
|
|
p ();
|
|
|
|
void
|
|
p (const p_type& x);
|
|
|
|
void
|
|
p (const p_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);
|
|
|
|
// Mh
|
|
//
|
|
typedef ::xml_schema::double_ Mh_type;
|
|
typedef ::xsd::cxx::tree::optional< Mh_type > Mh_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mh_type, char, ::xsd::cxx::tree::schema_type::double_ > Mh_traits;
|
|
|
|
const Mh_optional&
|
|
Mh () const;
|
|
|
|
Mh_optional&
|
|
Mh ();
|
|
|
|
void
|
|
Mh (const Mh_type& x);
|
|
|
|
void
|
|
Mh (const Mh_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
SuspendLoad (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
SuspendLoad (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SuspendLoad (const SuspendLoad& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SuspendLoad*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SuspendLoad&
|
|
operator= (const SuspendLoad& x);
|
|
|
|
virtual
|
|
~SuspendLoad ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
p_optional p_;
|
|
l_optional l_;
|
|
Mh_optional Mh_;
|
|
};
|
|
|
|
class Fishing: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CaseID
|
|
//
|
|
typedef ::xml_schema::string CaseID_type;
|
|
typedef ::xsd::cxx::tree::traits< CaseID_type, char > CaseID_traits;
|
|
|
|
const CaseID_type&
|
|
CaseID () const;
|
|
|
|
CaseID_type&
|
|
CaseID ();
|
|
|
|
void
|
|
CaseID (const CaseID_type& x);
|
|
|
|
void
|
|
CaseID (::std::unique_ptr< CaseID_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);
|
|
|
|
// M
|
|
//
|
|
typedef ::xml_schema::double_ M_type;
|
|
typedef ::xsd::cxx::tree::optional< M_type > M_optional;
|
|
typedef ::xsd::cxx::tree::traits< M_type, char, ::xsd::cxx::tree::schema_type::double_ > M_traits;
|
|
|
|
const M_optional&
|
|
M () const;
|
|
|
|
M_optional&
|
|
M ();
|
|
|
|
void
|
|
M (const M_type& x);
|
|
|
|
void
|
|
M (const M_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Fishing (const CaseID_type&,
|
|
const ID_type&);
|
|
|
|
Fishing (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Fishing (const Fishing& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Fishing*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Fishing&
|
|
operator= (const Fishing& x);
|
|
|
|
virtual
|
|
~Fishing ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseID_type > CaseID_;
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
M_optional M_;
|
|
};
|
|
|
|
class CompExtent: 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);
|
|
|
|
// SpaceID
|
|
//
|
|
typedef ::xml_schema::string SpaceID_type;
|
|
typedef ::xsd::cxx::tree::optional< SpaceID_type > SpaceID_optional;
|
|
typedef ::xsd::cxx::tree::traits< SpaceID_type, char > SpaceID_traits;
|
|
|
|
const SpaceID_optional&
|
|
SpaceID () const;
|
|
|
|
SpaceID_optional&
|
|
SpaceID ();
|
|
|
|
void
|
|
SpaceID (const SpaceID_type& x);
|
|
|
|
void
|
|
SpaceID (const SpaceID_optional& x);
|
|
|
|
void
|
|
SpaceID (::std::unique_ptr< SpaceID_type > p);
|
|
|
|
// Xmin
|
|
//
|
|
typedef ::xml_schema::double_ Xmin_type;
|
|
typedef ::xsd::cxx::tree::optional< Xmin_type > Xmin_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xmin_type, char, ::xsd::cxx::tree::schema_type::double_ > Xmin_traits;
|
|
|
|
const Xmin_optional&
|
|
Xmin () const;
|
|
|
|
Xmin_optional&
|
|
Xmin ();
|
|
|
|
void
|
|
Xmin (const Xmin_type& x);
|
|
|
|
void
|
|
Xmin (const Xmin_optional& x);
|
|
|
|
// Xmax
|
|
//
|
|
typedef ::xml_schema::double_ Xmax_type;
|
|
typedef ::xsd::cxx::tree::optional< Xmax_type > Xmax_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xmax_type, char, ::xsd::cxx::tree::schema_type::double_ > Xmax_traits;
|
|
|
|
const Xmax_optional&
|
|
Xmax () const;
|
|
|
|
Xmax_optional&
|
|
Xmax ();
|
|
|
|
void
|
|
Xmax (const Xmax_type& x);
|
|
|
|
void
|
|
Xmax (const Xmax_optional& x);
|
|
|
|
// Ymin
|
|
//
|
|
typedef ::xml_schema::double_ Ymin_type;
|
|
typedef ::xsd::cxx::tree::optional< Ymin_type > Ymin_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ymin_type, char, ::xsd::cxx::tree::schema_type::double_ > Ymin_traits;
|
|
|
|
const Ymin_optional&
|
|
Ymin () const;
|
|
|
|
Ymin_optional&
|
|
Ymin ();
|
|
|
|
void
|
|
Ymin (const Ymin_type& x);
|
|
|
|
void
|
|
Ymin (const Ymin_optional& x);
|
|
|
|
// Ymax
|
|
//
|
|
typedef ::xml_schema::double_ Ymax_type;
|
|
typedef ::xsd::cxx::tree::optional< Ymax_type > Ymax_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ymax_type, char, ::xsd::cxx::tree::schema_type::double_ > Ymax_traits;
|
|
|
|
const Ymax_optional&
|
|
Ymax () const;
|
|
|
|
Ymax_optional&
|
|
Ymax ();
|
|
|
|
void
|
|
Ymax (const Ymax_type& x);
|
|
|
|
void
|
|
Ymax (const Ymax_optional& x);
|
|
|
|
// Zmin
|
|
//
|
|
typedef ::xml_schema::double_ Zmin_type;
|
|
typedef ::xsd::cxx::tree::optional< Zmin_type > Zmin_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zmin_type, char, ::xsd::cxx::tree::schema_type::double_ > Zmin_traits;
|
|
|
|
const Zmin_optional&
|
|
Zmin () const;
|
|
|
|
Zmin_optional&
|
|
Zmin ();
|
|
|
|
void
|
|
Zmin (const Zmin_type& x);
|
|
|
|
void
|
|
Zmin (const Zmin_optional& x);
|
|
|
|
// Zmax
|
|
//
|
|
typedef ::xml_schema::double_ Zmax_type;
|
|
typedef ::xsd::cxx::tree::optional< Zmax_type > Zmax_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zmax_type, char, ::xsd::cxx::tree::schema_type::double_ > Zmax_traits;
|
|
|
|
const Zmax_optional&
|
|
Zmax () const;
|
|
|
|
Zmax_optional&
|
|
Zmax ();
|
|
|
|
void
|
|
Zmax (const Zmax_type& x);
|
|
|
|
void
|
|
Zmax (const Zmax_optional& x);
|
|
|
|
// XRegionID
|
|
//
|
|
typedef ::xml_schema::int_ XRegionID_type;
|
|
typedef ::xsd::cxx::tree::optional< XRegionID_type > XRegionID_optional;
|
|
typedef ::xsd::cxx::tree::traits< XRegionID_type, char > XRegionID_traits;
|
|
|
|
const XRegionID_optional&
|
|
XRegionID () const;
|
|
|
|
XRegionID_optional&
|
|
XRegionID ();
|
|
|
|
void
|
|
XRegionID (const XRegionID_type& x);
|
|
|
|
void
|
|
XRegionID (const XRegionID_optional& x);
|
|
|
|
// YRegionID
|
|
//
|
|
typedef ::xml_schema::int_ YRegionID_type;
|
|
typedef ::xsd::cxx::tree::optional< YRegionID_type > YRegionID_optional;
|
|
typedef ::xsd::cxx::tree::traits< YRegionID_type, char > YRegionID_traits;
|
|
|
|
const YRegionID_optional&
|
|
YRegionID () const;
|
|
|
|
YRegionID_optional&
|
|
YRegionID ();
|
|
|
|
void
|
|
YRegionID (const YRegionID_type& x);
|
|
|
|
void
|
|
YRegionID (const YRegionID_optional& x);
|
|
|
|
// ZRegionID
|
|
//
|
|
typedef ::xml_schema::int_ ZRegionID_type;
|
|
typedef ::xsd::cxx::tree::optional< ZRegionID_type > ZRegionID_optional;
|
|
typedef ::xsd::cxx::tree::traits< ZRegionID_type, char > ZRegionID_traits;
|
|
|
|
const ZRegionID_optional&
|
|
ZRegionID () const;
|
|
|
|
ZRegionID_optional&
|
|
ZRegionID ();
|
|
|
|
void
|
|
ZRegionID (const ZRegionID_type& x);
|
|
|
|
void
|
|
ZRegionID (const ZRegionID_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
CompExtent (const ID_type&);
|
|
|
|
CompExtent (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
CompExtent (const CompExtent& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual CompExtent*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
CompExtent&
|
|
operator= (const CompExtent& x);
|
|
|
|
virtual
|
|
~CompExtent ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
SpaceID_optional SpaceID_;
|
|
Xmin_optional Xmin_;
|
|
Xmax_optional Xmax_;
|
|
Ymin_optional Ymin_;
|
|
Ymax_optional Ymax_;
|
|
Zmin_optional Zmin_;
|
|
Zmax_optional Zmax_;
|
|
XRegionID_optional XRegionID_;
|
|
YRegionID_optional YRegionID_;
|
|
ZRegionID_optional ZRegionID_;
|
|
};
|
|
|
|
class DamRegion: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// ID
|
|
//
|
|
typedef ::xml_schema::int_ 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);
|
|
|
|
// Type
|
|
//
|
|
typedef ::xml_schema::int_ Type_type;
|
|
typedef ::xsd::cxx::tree::traits< Type_type, char > Type_traits;
|
|
|
|
const Type_type&
|
|
Type () const;
|
|
|
|
Type_type&
|
|
Type ();
|
|
|
|
void
|
|
Type (const Type_type& x);
|
|
|
|
static Type_type
|
|
Type_default_value ();
|
|
|
|
// Xa_symbol
|
|
//
|
|
typedef ::xml_schema::string Xa_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_symbol_type > Xa_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_symbol_type, char > Xa_symbol_traits;
|
|
|
|
const Xa_symbol_optional&
|
|
Xa_symbol () const;
|
|
|
|
Xa_symbol_optional&
|
|
Xa_symbol ();
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_type& x);
|
|
|
|
void
|
|
Xa_symbol (const Xa_symbol_optional& x);
|
|
|
|
void
|
|
Xa_symbol (::std::unique_ptr< Xa_symbol_type > p);
|
|
|
|
// Xa
|
|
//
|
|
typedef ::xml_schema::double_ Xa_type;
|
|
typedef ::xsd::cxx::tree::optional< Xa_type > Xa_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xa_type, char, ::xsd::cxx::tree::schema_type::double_ > Xa_traits;
|
|
|
|
const Xa_optional&
|
|
Xa () const;
|
|
|
|
Xa_optional&
|
|
Xa ();
|
|
|
|
void
|
|
Xa (const Xa_type& x);
|
|
|
|
void
|
|
Xa (const Xa_optional& x);
|
|
|
|
// Xf_symbol
|
|
//
|
|
typedef ::xml_schema::string Xf_symbol_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_symbol_type > Xf_symbol_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_symbol_type, char > Xf_symbol_traits;
|
|
|
|
const Xf_symbol_optional&
|
|
Xf_symbol () const;
|
|
|
|
Xf_symbol_optional&
|
|
Xf_symbol ();
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_type& x);
|
|
|
|
void
|
|
Xf_symbol (const Xf_symbol_optional& x);
|
|
|
|
void
|
|
Xf_symbol (::std::unique_ptr< Xf_symbol_type > p);
|
|
|
|
// Xf
|
|
//
|
|
typedef ::xml_schema::double_ Xf_type;
|
|
typedef ::xsd::cxx::tree::optional< Xf_type > Xf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Xf_type, char, ::xsd::cxx::tree::schema_type::double_ > Xf_traits;
|
|
|
|
const Xf_optional&
|
|
Xf () const;
|
|
|
|
Xf_optional&
|
|
Xf ();
|
|
|
|
void
|
|
Xf (const Xf_type& x);
|
|
|
|
void
|
|
Xf (const Xf_optional& x);
|
|
|
|
// Yp
|
|
//
|
|
typedef ::xml_schema::string Yp_type;
|
|
typedef ::xsd::cxx::tree::optional< Yp_type > Yp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Yp_type, char > Yp_traits;
|
|
|
|
const Yp_optional&
|
|
Yp () const;
|
|
|
|
Yp_optional&
|
|
Yp ();
|
|
|
|
void
|
|
Yp (const Yp_type& x);
|
|
|
|
void
|
|
Yp (const Yp_optional& x);
|
|
|
|
void
|
|
Yp (::std::unique_ptr< Yp_type > p);
|
|
|
|
// Zp
|
|
//
|
|
typedef ::xml_schema::string Zp_type;
|
|
typedef ::xsd::cxx::tree::optional< Zp_type > Zp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Zp_type, char > Zp_traits;
|
|
|
|
const Zp_optional&
|
|
Zp () const;
|
|
|
|
Zp_optional&
|
|
Zp ();
|
|
|
|
void
|
|
Zp (const Zp_type& x);
|
|
|
|
void
|
|
Zp (const Zp_optional& x);
|
|
|
|
void
|
|
Zp (::std::unique_ptr< Zp_type > p);
|
|
|
|
// Ymax
|
|
//
|
|
typedef ::xml_schema::double_ Ymax_type;
|
|
typedef ::xsd::cxx::tree::optional< Ymax_type > Ymax_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ymax_type, char, ::xsd::cxx::tree::schema_type::double_ > Ymax_traits;
|
|
|
|
const Ymax_optional&
|
|
Ymax () const;
|
|
|
|
Ymax_optional&
|
|
Ymax ();
|
|
|
|
void
|
|
Ymax (const Ymax_type& x);
|
|
|
|
void
|
|
Ymax (const Ymax_optional& x);
|
|
|
|
// Hmax
|
|
//
|
|
typedef ::xml_schema::double_ Hmax_type;
|
|
typedef ::xsd::cxx::tree::optional< Hmax_type > Hmax_optional;
|
|
typedef ::xsd::cxx::tree::traits< Hmax_type, char, ::xsd::cxx::tree::schema_type::double_ > Hmax_traits;
|
|
|
|
const Hmax_optional&
|
|
Hmax () const;
|
|
|
|
Hmax_optional&
|
|
Hmax ();
|
|
|
|
void
|
|
Hmax (const Hmax_type& x);
|
|
|
|
void
|
|
Hmax (const Hmax_optional& x);
|
|
|
|
// Myp
|
|
//
|
|
typedef ::xml_schema::int_ Myp_type;
|
|
typedef ::xsd::cxx::tree::optional< Myp_type > Myp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Myp_type, char > Myp_traits;
|
|
|
|
const Myp_optional&
|
|
Myp () const;
|
|
|
|
Myp_optional&
|
|
Myp ();
|
|
|
|
void
|
|
Myp (const Myp_type& x);
|
|
|
|
void
|
|
Myp (const Myp_optional& x);
|
|
|
|
// Mzp
|
|
//
|
|
typedef ::xml_schema::int_ Mzp_type;
|
|
typedef ::xsd::cxx::tree::optional< Mzp_type > Mzp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mzp_type, char > Mzp_traits;
|
|
|
|
const Mzp_optional&
|
|
Mzp () const;
|
|
|
|
Mzp_optional&
|
|
Mzp ();
|
|
|
|
void
|
|
Mzp (const Mzp_type& x);
|
|
|
|
void
|
|
Mzp (const Mzp_optional& x);
|
|
|
|
// isNew
|
|
//
|
|
typedef ::xml_schema::boolean isNew_type;
|
|
typedef ::xsd::cxx::tree::optional< isNew_type > isNew_optional;
|
|
typedef ::xsd::cxx::tree::traits< isNew_type, char > isNew_traits;
|
|
|
|
const isNew_optional&
|
|
isNew () const;
|
|
|
|
isNew_optional&
|
|
isNew ();
|
|
|
|
void
|
|
isNew (const isNew_type& x);
|
|
|
|
void
|
|
isNew (const isNew_optional& x);
|
|
|
|
static isNew_type
|
|
isNew_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
DamRegion (const ID_type&,
|
|
const Type_type&);
|
|
|
|
DamRegion (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
DamRegion (const DamRegion& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual DamRegion*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
DamRegion&
|
|
operator= (const DamRegion& x);
|
|
|
|
virtual
|
|
~DamRegion ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
::xsd::cxx::tree::one< Type_type > Type_;
|
|
Xa_symbol_optional Xa_symbol_;
|
|
Xa_optional Xa_;
|
|
Xf_symbol_optional Xf_symbol_;
|
|
Xf_optional Xf_;
|
|
Yp_optional Yp_;
|
|
Zp_optional Zp_;
|
|
Ymax_optional Ymax_;
|
|
Hmax_optional Hmax_;
|
|
Myp_optional Myp_;
|
|
Mzp_optional Mzp_;
|
|
isNew_optional isNew_;
|
|
};
|
|
|
|
class DamCompartmentProb: 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);
|
|
|
|
// CompartmentIDs
|
|
//
|
|
typedef ::xml_schema::string CompartmentIDs_type;
|
|
typedef ::xsd::cxx::tree::traits< CompartmentIDs_type, char > CompartmentIDs_traits;
|
|
|
|
const CompartmentIDs_type&
|
|
CompartmentIDs () const;
|
|
|
|
CompartmentIDs_type&
|
|
CompartmentIDs ();
|
|
|
|
void
|
|
CompartmentIDs (const CompartmentIDs_type& x);
|
|
|
|
void
|
|
CompartmentIDs (::std::unique_ptr< CompartmentIDs_type > p);
|
|
|
|
// x1
|
|
//
|
|
typedef ::xml_schema::double_ x1_type;
|
|
typedef ::xsd::cxx::tree::optional< x1_type > x1_optional;
|
|
typedef ::xsd::cxx::tree::traits< x1_type, char, ::xsd::cxx::tree::schema_type::double_ > x1_traits;
|
|
|
|
const x1_optional&
|
|
x1 () const;
|
|
|
|
x1_optional&
|
|
x1 ();
|
|
|
|
void
|
|
x1 (const x1_type& x);
|
|
|
|
void
|
|
x1 (const x1_optional& x);
|
|
|
|
// x2
|
|
//
|
|
typedef ::xml_schema::double_ x2_type;
|
|
typedef ::xsd::cxx::tree::optional< x2_type > x2_optional;
|
|
typedef ::xsd::cxx::tree::traits< x2_type, char, ::xsd::cxx::tree::schema_type::double_ > x2_traits;
|
|
|
|
const x2_optional&
|
|
x2 () const;
|
|
|
|
x2_optional&
|
|
x2 ();
|
|
|
|
void
|
|
x2 (const x2_type& x);
|
|
|
|
void
|
|
x2 (const x2_optional& x);
|
|
|
|
// b1
|
|
//
|
|
typedef ::xml_schema::double_ b1_type;
|
|
typedef ::xsd::cxx::tree::optional< b1_type > b1_optional;
|
|
typedef ::xsd::cxx::tree::traits< b1_type, char, ::xsd::cxx::tree::schema_type::double_ > b1_traits;
|
|
|
|
const b1_optional&
|
|
b1 () const;
|
|
|
|
b1_optional&
|
|
b1 ();
|
|
|
|
void
|
|
b1 (const b1_type& x);
|
|
|
|
void
|
|
b1 (const b1_optional& x);
|
|
|
|
// b2
|
|
//
|
|
typedef ::xml_schema::double_ b2_type;
|
|
typedef ::xsd::cxx::tree::optional< b2_type > b2_optional;
|
|
typedef ::xsd::cxx::tree::traits< b2_type, char, ::xsd::cxx::tree::schema_type::double_ > b2_traits;
|
|
|
|
const b2_optional&
|
|
b2 () const;
|
|
|
|
b2_optional&
|
|
b2 ();
|
|
|
|
void
|
|
b2 (const b2_type& x);
|
|
|
|
void
|
|
b2 (const b2_optional& x);
|
|
|
|
// H1
|
|
//
|
|
typedef ::xml_schema::double_ H1_type;
|
|
typedef ::xsd::cxx::tree::optional< H1_type > H1_optional;
|
|
typedef ::xsd::cxx::tree::traits< H1_type, char, ::xsd::cxx::tree::schema_type::double_ > H1_traits;
|
|
|
|
const H1_optional&
|
|
H1 () const;
|
|
|
|
H1_optional&
|
|
H1 ();
|
|
|
|
void
|
|
H1 (const H1_type& x);
|
|
|
|
void
|
|
H1 (const H1_optional& x);
|
|
|
|
// H2
|
|
//
|
|
typedef ::xml_schema::double_ H2_type;
|
|
typedef ::xsd::cxx::tree::optional< H2_type > H2_optional;
|
|
typedef ::xsd::cxx::tree::traits< H2_type, char, ::xsd::cxx::tree::schema_type::double_ > H2_traits;
|
|
|
|
const H2_optional&
|
|
H2 () const;
|
|
|
|
H2_optional&
|
|
H2 ();
|
|
|
|
void
|
|
H2 (const H2_type& x);
|
|
|
|
void
|
|
H2 (const H2_optional& x);
|
|
|
|
// Hm
|
|
//
|
|
typedef ::xml_schema::double_ Hm_type;
|
|
typedef ::xsd::cxx::tree::optional< Hm_type > Hm_optional;
|
|
typedef ::xsd::cxx::tree::traits< Hm_type, char, ::xsd::cxx::tree::schema_type::double_ > Hm_traits;
|
|
|
|
const Hm_optional&
|
|
Hm () const;
|
|
|
|
Hm_optional&
|
|
Hm ();
|
|
|
|
void
|
|
Hm (const Hm_type& x);
|
|
|
|
void
|
|
Hm (const Hm_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
DamCompartmentProb (const ID_type&,
|
|
const CompartmentIDs_type&);
|
|
|
|
DamCompartmentProb (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
DamCompartmentProb (const DamCompartmentProb& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual DamCompartmentProb*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
DamCompartmentProb&
|
|
operator= (const DamCompartmentProb& x);
|
|
|
|
virtual
|
|
~DamCompartmentProb ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
::xsd::cxx::tree::one< CompartmentIDs_type > CompartmentIDs_;
|
|
x1_optional x1_;
|
|
x2_optional x2_;
|
|
b1_optional b1_;
|
|
b2_optional b2_;
|
|
H1_optional H1_;
|
|
H2_optional H2_;
|
|
Hm_optional Hm_;
|
|
};
|
|
|
|
class DamCaseProb: 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);
|
|
|
|
// 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 ();
|
|
|
|
// d
|
|
//
|
|
typedef ::xml_schema::double_ d_type;
|
|
typedef ::xsd::cxx::tree::optional< d_type > d_optional;
|
|
typedef ::xsd::cxx::tree::traits< d_type, char, ::xsd::cxx::tree::schema_type::double_ > d_traits;
|
|
|
|
const d_optional&
|
|
d () const;
|
|
|
|
d_optional&
|
|
d ();
|
|
|
|
void
|
|
d (const d_type& x);
|
|
|
|
void
|
|
d (const d_optional& x);
|
|
|
|
// AT
|
|
//
|
|
typedef ::xml_schema::double_ AT_type;
|
|
typedef ::xsd::cxx::tree::optional< AT_type > AT_optional;
|
|
typedef ::xsd::cxx::tree::traits< AT_type, char, ::xsd::cxx::tree::schema_type::double_ > AT_traits;
|
|
|
|
const AT_optional&
|
|
AT () const;
|
|
|
|
AT_optional&
|
|
AT ();
|
|
|
|
void
|
|
AT (const AT_type& x);
|
|
|
|
void
|
|
AT (const AT_optional& x);
|
|
|
|
// GM
|
|
//
|
|
typedef ::xml_schema::double_ GM_type;
|
|
typedef ::xsd::cxx::tree::optional< GM_type > GM_optional;
|
|
typedef ::xsd::cxx::tree::traits< GM_type, char, ::xsd::cxx::tree::schema_type::double_ > GM_traits;
|
|
|
|
const GM_optional&
|
|
GM () const;
|
|
|
|
GM_optional&
|
|
GM ();
|
|
|
|
void
|
|
GM (const GM_type& x);
|
|
|
|
void
|
|
GM (const GM_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
DamCaseProb (const ID_type&);
|
|
|
|
DamCaseProb (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
DamCaseProb (const DamCaseProb& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual DamCaseProb*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
DamCaseProb&
|
|
operator= (const DamCaseProb& x);
|
|
|
|
virtual
|
|
~DamCaseProb ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< ID_type > ID_;
|
|
Type_optional Type_;
|
|
d_optional d_;
|
|
AT_optional AT_;
|
|
GM_optional GM_;
|
|
};
|
|
|
|
class AllowNM: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// X
|
|
//
|
|
typedef ::xml_schema::double_ X_type;
|
|
typedef ::xsd::cxx::tree::traits< X_type, char, ::xsd::cxx::tree::schema_type::double_ > X_traits;
|
|
|
|
const X_type&
|
|
X () const;
|
|
|
|
X_type&
|
|
X ();
|
|
|
|
void
|
|
X (const X_type& x);
|
|
|
|
// Nz
|
|
//
|
|
typedef ::xml_schema::double_ Nz_type;
|
|
typedef ::xsd::cxx::tree::optional< Nz_type > Nz_optional;
|
|
typedef ::xsd::cxx::tree::traits< Nz_type, char, ::xsd::cxx::tree::schema_type::double_ > Nz_traits;
|
|
|
|
const Nz_optional&
|
|
Nz () const;
|
|
|
|
Nz_optional&
|
|
Nz ();
|
|
|
|
void
|
|
Nz (const Nz_type& x);
|
|
|
|
void
|
|
Nz (const Nz_optional& x);
|
|
|
|
// Nf
|
|
//
|
|
typedef ::xml_schema::double_ Nf_type;
|
|
typedef ::xsd::cxx::tree::optional< Nf_type > Nf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Nf_type, char, ::xsd::cxx::tree::schema_type::double_ > Nf_traits;
|
|
|
|
const Nf_optional&
|
|
Nf () const;
|
|
|
|
Nf_optional&
|
|
Nf ();
|
|
|
|
void
|
|
Nf (const Nf_type& x);
|
|
|
|
void
|
|
Nf (const Nf_optional& x);
|
|
|
|
// Mz
|
|
//
|
|
typedef ::xml_schema::double_ Mz_type;
|
|
typedef ::xsd::cxx::tree::optional< Mz_type > Mz_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mz_type, char, ::xsd::cxx::tree::schema_type::double_ > Mz_traits;
|
|
|
|
const Mz_optional&
|
|
Mz () const;
|
|
|
|
Mz_optional&
|
|
Mz ();
|
|
|
|
void
|
|
Mz (const Mz_type& x);
|
|
|
|
void
|
|
Mz (const Mz_optional& x);
|
|
|
|
// Mf
|
|
//
|
|
typedef ::xml_schema::double_ Mf_type;
|
|
typedef ::xsd::cxx::tree::optional< Mf_type > Mf_optional;
|
|
typedef ::xsd::cxx::tree::traits< Mf_type, char, ::xsd::cxx::tree::schema_type::double_ > Mf_traits;
|
|
|
|
const Mf_optional&
|
|
Mf () const;
|
|
|
|
Mf_optional&
|
|
Mf ();
|
|
|
|
void
|
|
Mf (const Mf_type& x);
|
|
|
|
void
|
|
Mf (const Mf_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
AllowNM (const X_type&);
|
|
|
|
AllowNM (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
AllowNM (const AllowNM& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual AllowNM*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
AllowNM&
|
|
operator= (const AllowNM& x);
|
|
|
|
virtual
|
|
~AllowNM ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< X_type > X_;
|
|
Nz_optional Nz_;
|
|
Nf_optional Nf_;
|
|
Mz_optional Mz_;
|
|
Mf_optional Mf_;
|
|
};
|
|
}
|
|
|
|
#include <iosfwd>
|
|
|
|
#include <xercesc/sax/InputSource.hpp>
|
|
#include <xercesc/dom/DOMDocument.hpp>
|
|
#include <xercesc/dom/DOMErrorHandler.hpp>
|
|
|
|
namespace model_ds
|
|
{
|
|
// Parse a URI or a local file.
|
|
//
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (const ::std::string& uri,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (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< ::model_ds::ModelDS >
|
|
ModelDS_ (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< ::model_ds::ModelDS >
|
|
ModelDS_ (::std::istream& is,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::std::istream& is,
|
|
::xml_schema::error_handler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::std::istream& is,
|
|
::xercesc::DOMErrorHandler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::std::istream& is,
|
|
const ::std::string& id,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::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< ::model_ds::ModelDS >
|
|
ModelDS_ (::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< ::model_ds::ModelDS >
|
|
ModelDS_ (::xercesc::InputSource& is,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::xercesc::InputSource& is,
|
|
::xml_schema::error_handler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::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< ::model_ds::ModelDS >
|
|
ModelDS_ (const ::xercesc::DOMDocument& d,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::model_ds::ModelDS >
|
|
ModelDS_ (::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 model_ds
|
|
{
|
|
// Serialize to std::ostream.
|
|
//
|
|
|
|
void
|
|
ModelDS_ (::std::ostream& os,
|
|
const ::model_ds::ModelDS& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
const ::std::string& e = "UTF-8",
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
ModelDS_ (::std::ostream& os,
|
|
const ::model_ds::ModelDS& 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
|
|
ModelDS_ (::std::ostream& os,
|
|
const ::model_ds::ModelDS& 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
|
|
ModelDS_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::model_ds::ModelDS& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
const ::std::string& e = "UTF-8",
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
ModelDS_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::model_ds::ModelDS& 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
|
|
ModelDS_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::model_ds::ModelDS& 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
|
|
ModelDS_ (::xercesc::DOMDocument& d,
|
|
const ::model_ds::ModelDS& x,
|
|
::xml_schema::flags f = 0);
|
|
|
|
// Serialize to a new xercesc::DOMDocument.
|
|
//
|
|
|
|
::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
|
|
ModelDS_ (const ::model_ds::ModelDS& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ModelDS&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const LWT&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ImmersionPoint&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const LimitStaticPoint&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const WindFixed&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Case&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const WindNonFixed&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const OtherHeel&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Pull&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Jet&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Lift&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Sidesway&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Pile&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const MudAsym&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Mud&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const DamCase&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const DamCompartment&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const BInf&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const XLabel&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Compartment&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const FloodPoint&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Deckline&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningExtraWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningAbsentWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningMobileWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningRelocateWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningStatus&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningDevice&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningDraft&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningTank&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningCase&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const IncliningRecord&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Shell&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoad&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadItem&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const StationLabel&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const WaterlineLabel&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ButtocklineLabel&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadFreeSurf&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadPerson&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadBulk&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const OilRecover&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const PartialLoadIce&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SuspendLoad&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Fishing&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const CompExtent&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const DamRegion&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const DamCompartmentProb&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const DamCaseProb&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const AllowNM&);
|
|
}
|
|
|
|
#include <xsd/cxx/post.hxx>
|
|
|
|
// Begin epilogue.
|
|
//
|
|
//
|
|
// End epilogue.
|
|
|
|
#endif // MODEL_DS_HXX
|