9058 lines
200 KiB
C++
9058 lines
200 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 STRENGTH_SET_HXX
|
|
#define STRENGTH_SET_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 strength_set
|
|
{
|
|
class StrengthSet;
|
|
class Section;
|
|
class SecNode;
|
|
class SecPlate;
|
|
class SecOpenroom;
|
|
class SecCloseroom;
|
|
class SecShell;
|
|
class Subnode;
|
|
class Mat;
|
|
class Subgirder;
|
|
class Attach;
|
|
class Girder;
|
|
class Loads;
|
|
class Offset;
|
|
class WL;
|
|
class Bonjean;
|
|
class KL;
|
|
class LoadCase;
|
|
class StWeight;
|
|
class ItemWeight;
|
|
class MTC;
|
|
class LiftedCargo;
|
|
class ChkSubgirder;
|
|
class ChkPlate;
|
|
class ChkLongitudinal;
|
|
class StaticLoad;
|
|
class AllowLoad;
|
|
class AddtionalLoad;
|
|
class ProjectInfo;
|
|
class Pub;
|
|
}
|
|
|
|
|
|
#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 strength_set
|
|
{
|
|
class StrengthSet: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// Section
|
|
//
|
|
typedef ::strength_set::Section Section_type;
|
|
typedef ::xsd::cxx::tree::sequence< Section_type > Section_sequence;
|
|
typedef Section_sequence::iterator Section_iterator;
|
|
typedef Section_sequence::const_iterator Section_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Section_type, char > Section_traits;
|
|
|
|
const Section_sequence&
|
|
Section () const;
|
|
|
|
Section_sequence&
|
|
Section ();
|
|
|
|
void
|
|
Section (const Section_sequence& s);
|
|
|
|
// SecNode
|
|
//
|
|
typedef ::strength_set::SecNode SecNode_type;
|
|
typedef ::xsd::cxx::tree::sequence< SecNode_type > SecNode_sequence;
|
|
typedef SecNode_sequence::iterator SecNode_iterator;
|
|
typedef SecNode_sequence::const_iterator SecNode_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SecNode_type, char > SecNode_traits;
|
|
|
|
const SecNode_sequence&
|
|
SecNode () const;
|
|
|
|
SecNode_sequence&
|
|
SecNode ();
|
|
|
|
void
|
|
SecNode (const SecNode_sequence& s);
|
|
|
|
// SecPlate
|
|
//
|
|
typedef ::strength_set::SecPlate SecPlate_type;
|
|
typedef ::xsd::cxx::tree::sequence< SecPlate_type > SecPlate_sequence;
|
|
typedef SecPlate_sequence::iterator SecPlate_iterator;
|
|
typedef SecPlate_sequence::const_iterator SecPlate_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SecPlate_type, char > SecPlate_traits;
|
|
|
|
const SecPlate_sequence&
|
|
SecPlate () const;
|
|
|
|
SecPlate_sequence&
|
|
SecPlate ();
|
|
|
|
void
|
|
SecPlate (const SecPlate_sequence& s);
|
|
|
|
// SecOpenroom
|
|
//
|
|
typedef ::strength_set::SecOpenroom SecOpenroom_type;
|
|
typedef ::xsd::cxx::tree::sequence< SecOpenroom_type > SecOpenroom_sequence;
|
|
typedef SecOpenroom_sequence::iterator SecOpenroom_iterator;
|
|
typedef SecOpenroom_sequence::const_iterator SecOpenroom_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SecOpenroom_type, char > SecOpenroom_traits;
|
|
|
|
const SecOpenroom_sequence&
|
|
SecOpenroom () const;
|
|
|
|
SecOpenroom_sequence&
|
|
SecOpenroom ();
|
|
|
|
void
|
|
SecOpenroom (const SecOpenroom_sequence& s);
|
|
|
|
// SecCloseroom
|
|
//
|
|
typedef ::strength_set::SecCloseroom SecCloseroom_type;
|
|
typedef ::xsd::cxx::tree::sequence< SecCloseroom_type > SecCloseroom_sequence;
|
|
typedef SecCloseroom_sequence::iterator SecCloseroom_iterator;
|
|
typedef SecCloseroom_sequence::const_iterator SecCloseroom_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SecCloseroom_type, char > SecCloseroom_traits;
|
|
|
|
const SecCloseroom_sequence&
|
|
SecCloseroom () const;
|
|
|
|
SecCloseroom_sequence&
|
|
SecCloseroom ();
|
|
|
|
void
|
|
SecCloseroom (const SecCloseroom_sequence& s);
|
|
|
|
// SecShell
|
|
//
|
|
typedef ::strength_set::SecShell SecShell_type;
|
|
typedef ::xsd::cxx::tree::sequence< SecShell_type > SecShell_sequence;
|
|
typedef SecShell_sequence::iterator SecShell_iterator;
|
|
typedef SecShell_sequence::const_iterator SecShell_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< SecShell_type, char > SecShell_traits;
|
|
|
|
const SecShell_sequence&
|
|
SecShell () const;
|
|
|
|
SecShell_sequence&
|
|
SecShell ();
|
|
|
|
void
|
|
SecShell (const SecShell_sequence& s);
|
|
|
|
// Subnode
|
|
//
|
|
typedef ::strength_set::Subnode Subnode_type;
|
|
typedef ::xsd::cxx::tree::sequence< Subnode_type > Subnode_sequence;
|
|
typedef Subnode_sequence::iterator Subnode_iterator;
|
|
typedef Subnode_sequence::const_iterator Subnode_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Subnode_type, char > Subnode_traits;
|
|
|
|
const Subnode_sequence&
|
|
Subnode () const;
|
|
|
|
Subnode_sequence&
|
|
Subnode ();
|
|
|
|
void
|
|
Subnode (const Subnode_sequence& s);
|
|
|
|
// Mat
|
|
//
|
|
typedef ::strength_set::Mat Mat_type;
|
|
typedef ::xsd::cxx::tree::sequence< Mat_type > Mat_sequence;
|
|
typedef Mat_sequence::iterator Mat_iterator;
|
|
typedef Mat_sequence::const_iterator Mat_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Mat_type, char > Mat_traits;
|
|
|
|
const Mat_sequence&
|
|
Mat () const;
|
|
|
|
Mat_sequence&
|
|
Mat ();
|
|
|
|
void
|
|
Mat (const Mat_sequence& s);
|
|
|
|
// Subgirder
|
|
//
|
|
typedef ::strength_set::Subgirder Subgirder_type;
|
|
typedef ::xsd::cxx::tree::sequence< Subgirder_type > Subgirder_sequence;
|
|
typedef Subgirder_sequence::iterator Subgirder_iterator;
|
|
typedef Subgirder_sequence::const_iterator Subgirder_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Subgirder_type, char > Subgirder_traits;
|
|
|
|
const Subgirder_sequence&
|
|
Subgirder () const;
|
|
|
|
Subgirder_sequence&
|
|
Subgirder ();
|
|
|
|
void
|
|
Subgirder (const Subgirder_sequence& s);
|
|
|
|
// Attach
|
|
//
|
|
typedef ::strength_set::Attach Attach_type;
|
|
typedef ::xsd::cxx::tree::sequence< Attach_type > Attach_sequence;
|
|
typedef Attach_sequence::iterator Attach_iterator;
|
|
typedef Attach_sequence::const_iterator Attach_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Attach_type, char > Attach_traits;
|
|
|
|
const Attach_sequence&
|
|
Attach () const;
|
|
|
|
Attach_sequence&
|
|
Attach ();
|
|
|
|
void
|
|
Attach (const Attach_sequence& s);
|
|
|
|
// Girder
|
|
//
|
|
typedef ::strength_set::Girder Girder_type;
|
|
typedef ::xsd::cxx::tree::sequence< Girder_type > Girder_sequence;
|
|
typedef Girder_sequence::iterator Girder_iterator;
|
|
typedef Girder_sequence::const_iterator Girder_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Girder_type, char > Girder_traits;
|
|
|
|
const Girder_sequence&
|
|
Girder () const;
|
|
|
|
Girder_sequence&
|
|
Girder ();
|
|
|
|
void
|
|
Girder (const Girder_sequence& s);
|
|
|
|
// Loads
|
|
//
|
|
typedef ::strength_set::Loads Loads_type;
|
|
typedef ::xsd::cxx::tree::sequence< Loads_type > Loads_sequence;
|
|
typedef Loads_sequence::iterator Loads_iterator;
|
|
typedef Loads_sequence::const_iterator Loads_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Loads_type, char > Loads_traits;
|
|
|
|
const Loads_sequence&
|
|
Loads () const;
|
|
|
|
Loads_sequence&
|
|
Loads ();
|
|
|
|
void
|
|
Loads (const Loads_sequence& s);
|
|
|
|
// Offset
|
|
//
|
|
typedef ::strength_set::Offset Offset_type;
|
|
typedef ::xsd::cxx::tree::sequence< Offset_type > Offset_sequence;
|
|
typedef Offset_sequence::iterator Offset_iterator;
|
|
typedef Offset_sequence::const_iterator Offset_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Offset_type, char > Offset_traits;
|
|
|
|
const Offset_sequence&
|
|
Offset () const;
|
|
|
|
Offset_sequence&
|
|
Offset ();
|
|
|
|
void
|
|
Offset (const Offset_sequence& s);
|
|
|
|
// WL
|
|
//
|
|
typedef ::strength_set::WL WL_type;
|
|
typedef ::xsd::cxx::tree::sequence< WL_type > WL_sequence;
|
|
typedef WL_sequence::iterator WL_iterator;
|
|
typedef WL_sequence::const_iterator WL_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< WL_type, char > WL_traits;
|
|
|
|
const WL_sequence&
|
|
WL () const;
|
|
|
|
WL_sequence&
|
|
WL ();
|
|
|
|
void
|
|
WL (const WL_sequence& s);
|
|
|
|
// Bonjean
|
|
//
|
|
typedef ::strength_set::Bonjean Bonjean_type;
|
|
typedef ::xsd::cxx::tree::sequence< Bonjean_type > Bonjean_sequence;
|
|
typedef Bonjean_sequence::iterator Bonjean_iterator;
|
|
typedef Bonjean_sequence::const_iterator Bonjean_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Bonjean_type, char > Bonjean_traits;
|
|
|
|
const Bonjean_sequence&
|
|
Bonjean () const;
|
|
|
|
Bonjean_sequence&
|
|
Bonjean ();
|
|
|
|
void
|
|
Bonjean (const Bonjean_sequence& s);
|
|
|
|
// KL
|
|
//
|
|
typedef ::strength_set::KL KL_type;
|
|
typedef ::xsd::cxx::tree::sequence< KL_type > KL_sequence;
|
|
typedef KL_sequence::iterator KL_iterator;
|
|
typedef KL_sequence::const_iterator KL_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< KL_type, char > KL_traits;
|
|
|
|
const KL_sequence&
|
|
KL () const;
|
|
|
|
KL_sequence&
|
|
KL ();
|
|
|
|
void
|
|
KL (const KL_sequence& s);
|
|
|
|
// LoadCase
|
|
//
|
|
typedef ::strength_set::LoadCase LoadCase_type;
|
|
typedef ::xsd::cxx::tree::sequence< LoadCase_type > LoadCase_sequence;
|
|
typedef LoadCase_sequence::iterator LoadCase_iterator;
|
|
typedef LoadCase_sequence::const_iterator LoadCase_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< LoadCase_type, char > LoadCase_traits;
|
|
|
|
const LoadCase_sequence&
|
|
LoadCase () const;
|
|
|
|
LoadCase_sequence&
|
|
LoadCase ();
|
|
|
|
void
|
|
LoadCase (const LoadCase_sequence& s);
|
|
|
|
// StWeight
|
|
//
|
|
typedef ::strength_set::StWeight StWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< StWeight_type > StWeight_sequence;
|
|
typedef StWeight_sequence::iterator StWeight_iterator;
|
|
typedef StWeight_sequence::const_iterator StWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< StWeight_type, char > StWeight_traits;
|
|
|
|
const StWeight_sequence&
|
|
StWeight () const;
|
|
|
|
StWeight_sequence&
|
|
StWeight ();
|
|
|
|
void
|
|
StWeight (const StWeight_sequence& s);
|
|
|
|
// ItemWeight
|
|
//
|
|
typedef ::strength_set::ItemWeight ItemWeight_type;
|
|
typedef ::xsd::cxx::tree::sequence< ItemWeight_type > ItemWeight_sequence;
|
|
typedef ItemWeight_sequence::iterator ItemWeight_iterator;
|
|
typedef ItemWeight_sequence::const_iterator ItemWeight_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ItemWeight_type, char > ItemWeight_traits;
|
|
|
|
const ItemWeight_sequence&
|
|
ItemWeight () const;
|
|
|
|
ItemWeight_sequence&
|
|
ItemWeight ();
|
|
|
|
void
|
|
ItemWeight (const ItemWeight_sequence& s);
|
|
|
|
// MTC
|
|
//
|
|
typedef ::strength_set::MTC MTC_type;
|
|
typedef ::xsd::cxx::tree::sequence< MTC_type > MTC_sequence;
|
|
typedef MTC_sequence::iterator MTC_iterator;
|
|
typedef MTC_sequence::const_iterator MTC_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< MTC_type, char > MTC_traits;
|
|
|
|
const MTC_sequence&
|
|
MTC () const;
|
|
|
|
MTC_sequence&
|
|
MTC ();
|
|
|
|
void
|
|
MTC (const MTC_sequence& s);
|
|
|
|
// LiftedCargo
|
|
//
|
|
typedef ::strength_set::LiftedCargo LiftedCargo_type;
|
|
typedef ::xsd::cxx::tree::sequence< LiftedCargo_type > LiftedCargo_sequence;
|
|
typedef LiftedCargo_sequence::iterator LiftedCargo_iterator;
|
|
typedef LiftedCargo_sequence::const_iterator LiftedCargo_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< LiftedCargo_type, char > LiftedCargo_traits;
|
|
|
|
const LiftedCargo_sequence&
|
|
LiftedCargo () const;
|
|
|
|
LiftedCargo_sequence&
|
|
LiftedCargo ();
|
|
|
|
void
|
|
LiftedCargo (const LiftedCargo_sequence& s);
|
|
|
|
// ChkSubgirder
|
|
//
|
|
typedef ::strength_set::ChkSubgirder ChkSubgirder_type;
|
|
typedef ::xsd::cxx::tree::sequence< ChkSubgirder_type > ChkSubgirder_sequence;
|
|
typedef ChkSubgirder_sequence::iterator ChkSubgirder_iterator;
|
|
typedef ChkSubgirder_sequence::const_iterator ChkSubgirder_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ChkSubgirder_type, char > ChkSubgirder_traits;
|
|
|
|
const ChkSubgirder_sequence&
|
|
ChkSubgirder () const;
|
|
|
|
ChkSubgirder_sequence&
|
|
ChkSubgirder ();
|
|
|
|
void
|
|
ChkSubgirder (const ChkSubgirder_sequence& s);
|
|
|
|
// ChkPlate
|
|
//
|
|
typedef ::strength_set::ChkPlate ChkPlate_type;
|
|
typedef ::xsd::cxx::tree::sequence< ChkPlate_type > ChkPlate_sequence;
|
|
typedef ChkPlate_sequence::iterator ChkPlate_iterator;
|
|
typedef ChkPlate_sequence::const_iterator ChkPlate_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ChkPlate_type, char > ChkPlate_traits;
|
|
|
|
const ChkPlate_sequence&
|
|
ChkPlate () const;
|
|
|
|
ChkPlate_sequence&
|
|
ChkPlate ();
|
|
|
|
void
|
|
ChkPlate (const ChkPlate_sequence& s);
|
|
|
|
// ChkLongitudinal
|
|
//
|
|
typedef ::strength_set::ChkLongitudinal ChkLongitudinal_type;
|
|
typedef ::xsd::cxx::tree::sequence< ChkLongitudinal_type > ChkLongitudinal_sequence;
|
|
typedef ChkLongitudinal_sequence::iterator ChkLongitudinal_iterator;
|
|
typedef ChkLongitudinal_sequence::const_iterator ChkLongitudinal_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ChkLongitudinal_type, char > ChkLongitudinal_traits;
|
|
|
|
const ChkLongitudinal_sequence&
|
|
ChkLongitudinal () const;
|
|
|
|
ChkLongitudinal_sequence&
|
|
ChkLongitudinal ();
|
|
|
|
void
|
|
ChkLongitudinal (const ChkLongitudinal_sequence& s);
|
|
|
|
// StaticLoad
|
|
//
|
|
typedef ::strength_set::StaticLoad StaticLoad_type;
|
|
typedef ::xsd::cxx::tree::sequence< StaticLoad_type > StaticLoad_sequence;
|
|
typedef StaticLoad_sequence::iterator StaticLoad_iterator;
|
|
typedef StaticLoad_sequence::const_iterator StaticLoad_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< StaticLoad_type, char > StaticLoad_traits;
|
|
|
|
const StaticLoad_sequence&
|
|
StaticLoad () const;
|
|
|
|
StaticLoad_sequence&
|
|
StaticLoad ();
|
|
|
|
void
|
|
StaticLoad (const StaticLoad_sequence& s);
|
|
|
|
// AllowLoad
|
|
//
|
|
typedef ::strength_set::AllowLoad AllowLoad_type;
|
|
typedef ::xsd::cxx::tree::sequence< AllowLoad_type > AllowLoad_sequence;
|
|
typedef AllowLoad_sequence::iterator AllowLoad_iterator;
|
|
typedef AllowLoad_sequence::const_iterator AllowLoad_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< AllowLoad_type, char > AllowLoad_traits;
|
|
|
|
const AllowLoad_sequence&
|
|
AllowLoad () const;
|
|
|
|
AllowLoad_sequence&
|
|
AllowLoad ();
|
|
|
|
void
|
|
AllowLoad (const AllowLoad_sequence& s);
|
|
|
|
// AddtionalLoad
|
|
//
|
|
typedef ::strength_set::AddtionalLoad AddtionalLoad_type;
|
|
typedef ::xsd::cxx::tree::sequence< AddtionalLoad_type > AddtionalLoad_sequence;
|
|
typedef AddtionalLoad_sequence::iterator AddtionalLoad_iterator;
|
|
typedef AddtionalLoad_sequence::const_iterator AddtionalLoad_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< AddtionalLoad_type, char > AddtionalLoad_traits;
|
|
|
|
const AddtionalLoad_sequence&
|
|
AddtionalLoad () const;
|
|
|
|
AddtionalLoad_sequence&
|
|
AddtionalLoad ();
|
|
|
|
void
|
|
AddtionalLoad (const AddtionalLoad_sequence& s);
|
|
|
|
// ProjectInfo
|
|
//
|
|
typedef ::strength_set::ProjectInfo ProjectInfo_type;
|
|
typedef ::xsd::cxx::tree::sequence< ProjectInfo_type > ProjectInfo_sequence;
|
|
typedef ProjectInfo_sequence::iterator ProjectInfo_iterator;
|
|
typedef ProjectInfo_sequence::const_iterator ProjectInfo_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< ProjectInfo_type, char > ProjectInfo_traits;
|
|
|
|
const ProjectInfo_sequence&
|
|
ProjectInfo () const;
|
|
|
|
ProjectInfo_sequence&
|
|
ProjectInfo ();
|
|
|
|
void
|
|
ProjectInfo (const ProjectInfo_sequence& s);
|
|
|
|
// Pub
|
|
//
|
|
typedef ::strength_set::Pub Pub_type;
|
|
typedef ::xsd::cxx::tree::sequence< Pub_type > Pub_sequence;
|
|
typedef Pub_sequence::iterator Pub_iterator;
|
|
typedef Pub_sequence::const_iterator Pub_const_iterator;
|
|
typedef ::xsd::cxx::tree::traits< Pub_type, char > Pub_traits;
|
|
|
|
const Pub_sequence&
|
|
Pub () const;
|
|
|
|
Pub_sequence&
|
|
Pub ();
|
|
|
|
void
|
|
Pub (const Pub_sequence& s);
|
|
|
|
// Constructors.
|
|
//
|
|
StrengthSet ();
|
|
|
|
StrengthSet (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
StrengthSet (const StrengthSet& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual StrengthSet*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
StrengthSet&
|
|
operator= (const StrengthSet& x);
|
|
|
|
virtual
|
|
~StrengthSet ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
Section_sequence Section_;
|
|
SecNode_sequence SecNode_;
|
|
SecPlate_sequence SecPlate_;
|
|
SecOpenroom_sequence SecOpenroom_;
|
|
SecCloseroom_sequence SecCloseroom_;
|
|
SecShell_sequence SecShell_;
|
|
Subnode_sequence Subnode_;
|
|
Mat_sequence Mat_;
|
|
Subgirder_sequence Subgirder_;
|
|
Attach_sequence Attach_;
|
|
Girder_sequence Girder_;
|
|
Loads_sequence Loads_;
|
|
Offset_sequence Offset_;
|
|
WL_sequence WL_;
|
|
Bonjean_sequence Bonjean_;
|
|
KL_sequence KL_;
|
|
LoadCase_sequence LoadCase_;
|
|
StWeight_sequence StWeight_;
|
|
ItemWeight_sequence ItemWeight_;
|
|
MTC_sequence MTC_;
|
|
LiftedCargo_sequence LiftedCargo_;
|
|
ChkSubgirder_sequence ChkSubgirder_;
|
|
ChkPlate_sequence ChkPlate_;
|
|
ChkLongitudinal_sequence ChkLongitudinal_;
|
|
StaticLoad_sequence StaticLoad_;
|
|
AllowLoad_sequence AllowLoad_;
|
|
AddtionalLoad_sequence AddtionalLoad_;
|
|
ProjectInfo_sequence ProjectInfo_;
|
|
Pub_sequence Pub_;
|
|
};
|
|
|
|
class Section: 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);
|
|
|
|
// DeckNode
|
|
//
|
|
typedef ::xml_schema::int_ DeckNode_type;
|
|
typedef ::xsd::cxx::tree::traits< DeckNode_type, char > DeckNode_traits;
|
|
|
|
const DeckNode_type&
|
|
DeckNode () const;
|
|
|
|
DeckNode_type&
|
|
DeckNode ();
|
|
|
|
void
|
|
DeckNode (const DeckNode_type& x);
|
|
|
|
static DeckNode_type
|
|
DeckNode_default_value ();
|
|
|
|
// OrgPlate
|
|
//
|
|
typedef ::xml_schema::int_ OrgPlate_type;
|
|
typedef ::xsd::cxx::tree::traits< OrgPlate_type, char > OrgPlate_traits;
|
|
|
|
const OrgPlate_type&
|
|
OrgPlate () const;
|
|
|
|
OrgPlate_type&
|
|
OrgPlate ();
|
|
|
|
void
|
|
OrgPlate (const OrgPlate_type& x);
|
|
|
|
static OrgPlate_type
|
|
OrgPlate_default_value ();
|
|
|
|
// DeckPlate
|
|
//
|
|
typedef ::xml_schema::int_ DeckPlate_type;
|
|
typedef ::xsd::cxx::tree::traits< DeckPlate_type, char > DeckPlate_traits;
|
|
|
|
const DeckPlate_type&
|
|
DeckPlate () const;
|
|
|
|
DeckPlate_type&
|
|
DeckPlate ();
|
|
|
|
void
|
|
DeckPlate (const DeckPlate_type& x);
|
|
|
|
static DeckPlate_type
|
|
DeckPlate_default_value ();
|
|
|
|
// BilgePlate
|
|
//
|
|
typedef ::xml_schema::int_ BilgePlate_type;
|
|
typedef ::xsd::cxx::tree::traits< BilgePlate_type, char > BilgePlate_traits;
|
|
|
|
const BilgePlate_type&
|
|
BilgePlate () const;
|
|
|
|
BilgePlate_type&
|
|
BilgePlate ();
|
|
|
|
void
|
|
BilgePlate (const BilgePlate_type& x);
|
|
|
|
static BilgePlate_type
|
|
BilgePlate_default_value ();
|
|
|
|
// OpenSec
|
|
//
|
|
typedef ::xml_schema::boolean OpenSec_type;
|
|
typedef ::xsd::cxx::tree::optional< OpenSec_type > OpenSec_optional;
|
|
typedef ::xsd::cxx::tree::traits< OpenSec_type, char > OpenSec_traits;
|
|
|
|
const OpenSec_optional&
|
|
OpenSec () const;
|
|
|
|
OpenSec_optional&
|
|
OpenSec ();
|
|
|
|
void
|
|
OpenSec (const OpenSec_type& x);
|
|
|
|
void
|
|
OpenSec (const OpenSec_optional& x);
|
|
|
|
static OpenSec_type
|
|
OpenSec_default_value ();
|
|
|
|
// StructureSecId
|
|
//
|
|
typedef ::xml_schema::long_ StructureSecId_type;
|
|
typedef ::xsd::cxx::tree::optional< StructureSecId_type > StructureSecId_optional;
|
|
typedef ::xsd::cxx::tree::traits< StructureSecId_type, char > StructureSecId_traits;
|
|
|
|
const StructureSecId_optional&
|
|
StructureSecId () const;
|
|
|
|
StructureSecId_optional&
|
|
StructureSecId ();
|
|
|
|
void
|
|
StructureSecId (const StructureSecId_type& x);
|
|
|
|
void
|
|
StructureSecId (const StructureSecId_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
Section (const Id_type&,
|
|
const DeckNode_type&,
|
|
const OrgPlate_type&,
|
|
const DeckPlate_type&,
|
|
const BilgePlate_type&);
|
|
|
|
Section (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Section (const Section& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Section*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Section&
|
|
operator= (const Section& x);
|
|
|
|
virtual
|
|
~Section ();
|
|
|
|
// 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< DeckNode_type > DeckNode_;
|
|
::xsd::cxx::tree::one< OrgPlate_type > OrgPlate_;
|
|
::xsd::cxx::tree::one< DeckPlate_type > DeckPlate_;
|
|
::xsd::cxx::tree::one< BilgePlate_type > BilgePlate_;
|
|
OpenSec_optional OpenSec_;
|
|
StructureSecId_optional StructureSecId_;
|
|
};
|
|
|
|
class SecNode: 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);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
// GenCode
|
|
//
|
|
typedef ::xml_schema::int_ GenCode_type;
|
|
typedef ::xsd::cxx::tree::optional< GenCode_type > GenCode_optional;
|
|
typedef ::xsd::cxx::tree::traits< GenCode_type, char > GenCode_traits;
|
|
|
|
const GenCode_optional&
|
|
GenCode () const;
|
|
|
|
GenCode_optional&
|
|
GenCode ();
|
|
|
|
void
|
|
GenCode (const GenCode_type& x);
|
|
|
|
void
|
|
GenCode (const GenCode_optional& x);
|
|
|
|
static GenCode_type
|
|
GenCode_default_value ();
|
|
|
|
// Y
|
|
//
|
|
typedef ::xml_schema::double_ Y_type;
|
|
typedef ::xsd::cxx::tree::traits< Y_type, char, ::xsd::cxx::tree::schema_type::double_ > Y_traits;
|
|
|
|
const Y_type&
|
|
Y () const;
|
|
|
|
Y_type&
|
|
Y ();
|
|
|
|
void
|
|
Y (const Y_type& x);
|
|
|
|
// Z
|
|
//
|
|
typedef ::xml_schema::double_ Z_type;
|
|
typedef ::xsd::cxx::tree::traits< Z_type, char, ::xsd::cxx::tree::schema_type::double_ > Z_traits;
|
|
|
|
const Z_type&
|
|
Z () const;
|
|
|
|
Z_type&
|
|
Z ();
|
|
|
|
void
|
|
Z (const Z_type& x);
|
|
|
|
// A
|
|
//
|
|
typedef ::xml_schema::double_ A_type;
|
|
typedef ::xsd::cxx::tree::traits< A_type, char, ::xsd::cxx::tree::schema_type::double_ > A_traits;
|
|
|
|
const A_type&
|
|
A () const;
|
|
|
|
A_type&
|
|
A ();
|
|
|
|
void
|
|
A (const A_type& x);
|
|
|
|
static A_type
|
|
A_default_value ();
|
|
|
|
// StructureNodeId
|
|
//
|
|
typedef ::xml_schema::long_ StructureNodeId_type;
|
|
typedef ::xsd::cxx::tree::optional< StructureNodeId_type > StructureNodeId_optional;
|
|
typedef ::xsd::cxx::tree::traits< StructureNodeId_type, char > StructureNodeId_traits;
|
|
|
|
const StructureNodeId_optional&
|
|
StructureNodeId () const;
|
|
|
|
StructureNodeId_optional&
|
|
StructureNodeId ();
|
|
|
|
void
|
|
StructureNodeId (const StructureNodeId_type& x);
|
|
|
|
void
|
|
StructureNodeId (const StructureNodeId_optional& x);
|
|
|
|
// StructureStiffenerId
|
|
//
|
|
typedef ::xml_schema::long_ StructureStiffenerId_type;
|
|
typedef ::xsd::cxx::tree::optional< StructureStiffenerId_type > StructureStiffenerId_optional;
|
|
typedef ::xsd::cxx::tree::traits< StructureStiffenerId_type, char > StructureStiffenerId_traits;
|
|
|
|
const StructureStiffenerId_optional&
|
|
StructureStiffenerId () const;
|
|
|
|
StructureStiffenerId_optional&
|
|
StructureStiffenerId ();
|
|
|
|
void
|
|
StructureStiffenerId (const StructureStiffenerId_type& x);
|
|
|
|
void
|
|
StructureStiffenerId (const StructureStiffenerId_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
SecNode (const Id_type&,
|
|
const SecId_type&,
|
|
const Y_type&,
|
|
const Z_type&,
|
|
const A_type&);
|
|
|
|
SecNode (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SecNode (const SecNode& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SecNode*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SecNode&
|
|
operator= (const SecNode& x);
|
|
|
|
virtual
|
|
~SecNode ();
|
|
|
|
// 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< SecId_type > SecId_;
|
|
GenCode_optional GenCode_;
|
|
::xsd::cxx::tree::one< Y_type > Y_;
|
|
::xsd::cxx::tree::one< Z_type > Z_;
|
|
::xsd::cxx::tree::one< A_type > A_;
|
|
StructureNodeId_optional StructureNodeId_;
|
|
StructureStiffenerId_optional StructureStiffenerId_;
|
|
};
|
|
|
|
class SecPlate: 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);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
// GenCode
|
|
//
|
|
typedef ::xml_schema::int_ GenCode_type;
|
|
typedef ::xsd::cxx::tree::optional< GenCode_type > GenCode_optional;
|
|
typedef ::xsd::cxx::tree::traits< GenCode_type, char > GenCode_traits;
|
|
|
|
const GenCode_optional&
|
|
GenCode () const;
|
|
|
|
GenCode_optional&
|
|
GenCode ();
|
|
|
|
void
|
|
GenCode (const GenCode_type& x);
|
|
|
|
void
|
|
GenCode (const GenCode_optional& x);
|
|
|
|
static GenCode_type
|
|
GenCode_default_value ();
|
|
|
|
// Node1
|
|
//
|
|
typedef ::xml_schema::int_ Node1_type;
|
|
typedef ::xsd::cxx::tree::traits< Node1_type, char > Node1_traits;
|
|
|
|
const Node1_type&
|
|
Node1 () const;
|
|
|
|
Node1_type&
|
|
Node1 ();
|
|
|
|
void
|
|
Node1 (const Node1_type& x);
|
|
|
|
// Node2
|
|
//
|
|
typedef ::xml_schema::int_ Node2_type;
|
|
typedef ::xsd::cxx::tree::traits< Node2_type, char > Node2_traits;
|
|
|
|
const Node2_type&
|
|
Node2 () const;
|
|
|
|
Node2_type&
|
|
Node2 ();
|
|
|
|
void
|
|
Node2 (const Node2_type& x);
|
|
|
|
// T
|
|
//
|
|
typedef ::xml_schema::double_ T_type;
|
|
typedef ::xsd::cxx::tree::traits< T_type, char, ::xsd::cxx::tree::schema_type::double_ > T_traits;
|
|
|
|
const T_type&
|
|
T () const;
|
|
|
|
T_type&
|
|
T ();
|
|
|
|
void
|
|
T (const T_type& x);
|
|
|
|
static T_type
|
|
T_default_value ();
|
|
|
|
// CloseToOpen
|
|
//
|
|
typedef ::xml_schema::int_ CloseToOpen_type;
|
|
typedef ::xsd::cxx::tree::traits< CloseToOpen_type, char > CloseToOpen_traits;
|
|
|
|
const CloseToOpen_type&
|
|
CloseToOpen () const;
|
|
|
|
CloseToOpen_type&
|
|
CloseToOpen ();
|
|
|
|
void
|
|
CloseToOpen (const CloseToOpen_type& x);
|
|
|
|
static CloseToOpen_type
|
|
CloseToOpen_default_value ();
|
|
|
|
// StructurePlateId
|
|
//
|
|
typedef ::xml_schema::long_ StructurePlateId_type;
|
|
typedef ::xsd::cxx::tree::optional< StructurePlateId_type > StructurePlateId_optional;
|
|
typedef ::xsd::cxx::tree::traits< StructurePlateId_type, char > StructurePlateId_traits;
|
|
|
|
const StructurePlateId_optional&
|
|
StructurePlateId () const;
|
|
|
|
StructurePlateId_optional&
|
|
StructurePlateId ();
|
|
|
|
void
|
|
StructurePlateId (const StructurePlateId_type& x);
|
|
|
|
void
|
|
StructurePlateId (const StructurePlateId_optional& x);
|
|
|
|
// StructureStiffenerId
|
|
//
|
|
typedef ::xml_schema::long_ StructureStiffenerId_type;
|
|
typedef ::xsd::cxx::tree::optional< StructureStiffenerId_type > StructureStiffenerId_optional;
|
|
typedef ::xsd::cxx::tree::traits< StructureStiffenerId_type, char > StructureStiffenerId_traits;
|
|
|
|
const StructureStiffenerId_optional&
|
|
StructureStiffenerId () const;
|
|
|
|
StructureStiffenerId_optional&
|
|
StructureStiffenerId ();
|
|
|
|
void
|
|
StructureStiffenerId (const StructureStiffenerId_type& x);
|
|
|
|
void
|
|
StructureStiffenerId (const StructureStiffenerId_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
SecPlate (const Id_type&,
|
|
const SecId_type&,
|
|
const Node1_type&,
|
|
const Node2_type&,
|
|
const T_type&,
|
|
const CloseToOpen_type&);
|
|
|
|
SecPlate (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SecPlate (const SecPlate& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SecPlate*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SecPlate&
|
|
operator= (const SecPlate& x);
|
|
|
|
virtual
|
|
~SecPlate ();
|
|
|
|
// 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< SecId_type > SecId_;
|
|
GenCode_optional GenCode_;
|
|
::xsd::cxx::tree::one< Node1_type > Node1_;
|
|
::xsd::cxx::tree::one< Node2_type > Node2_;
|
|
::xsd::cxx::tree::one< T_type > T_;
|
|
::xsd::cxx::tree::one< CloseToOpen_type > CloseToOpen_;
|
|
StructurePlateId_optional StructurePlateId_;
|
|
StructureStiffenerId_optional StructureStiffenerId_;
|
|
};
|
|
|
|
class SecOpenroom: 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);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
// PlateCount
|
|
//
|
|
typedef ::xml_schema::int_ PlateCount_type;
|
|
typedef ::xsd::cxx::tree::traits< PlateCount_type, char > PlateCount_traits;
|
|
|
|
const PlateCount_type&
|
|
PlateCount () const;
|
|
|
|
PlateCount_type&
|
|
PlateCount ();
|
|
|
|
void
|
|
PlateCount (const PlateCount_type& x);
|
|
|
|
static PlateCount_type
|
|
PlateCount_default_value ();
|
|
|
|
// LinkList
|
|
//
|
|
typedef ::xml_schema::string LinkList_type;
|
|
typedef ::xsd::cxx::tree::traits< LinkList_type, char > LinkList_traits;
|
|
|
|
const LinkList_type&
|
|
LinkList () const;
|
|
|
|
LinkList_type&
|
|
LinkList ();
|
|
|
|
void
|
|
LinkList (const LinkList_type& x);
|
|
|
|
void
|
|
LinkList (::std::unique_ptr< LinkList_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
SecOpenroom (const Id_type&,
|
|
const SecId_type&,
|
|
const PlateCount_type&,
|
|
const LinkList_type&);
|
|
|
|
SecOpenroom (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SecOpenroom (const SecOpenroom& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SecOpenroom*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SecOpenroom&
|
|
operator= (const SecOpenroom& x);
|
|
|
|
virtual
|
|
~SecOpenroom ();
|
|
|
|
// 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< SecId_type > SecId_;
|
|
::xsd::cxx::tree::one< PlateCount_type > PlateCount_;
|
|
::xsd::cxx::tree::one< LinkList_type > LinkList_;
|
|
};
|
|
|
|
class SecCloseroom: 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);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
// PlateCount
|
|
//
|
|
typedef ::xml_schema::int_ PlateCount_type;
|
|
typedef ::xsd::cxx::tree::optional< PlateCount_type > PlateCount_optional;
|
|
typedef ::xsd::cxx::tree::traits< PlateCount_type, char > PlateCount_traits;
|
|
|
|
const PlateCount_optional&
|
|
PlateCount () const;
|
|
|
|
PlateCount_optional&
|
|
PlateCount ();
|
|
|
|
void
|
|
PlateCount (const PlateCount_type& x);
|
|
|
|
void
|
|
PlateCount (const PlateCount_optional& x);
|
|
|
|
static PlateCount_type
|
|
PlateCount_default_value ();
|
|
|
|
// LinkList
|
|
//
|
|
typedef ::xml_schema::string LinkList_type;
|
|
typedef ::xsd::cxx::tree::traits< LinkList_type, char > LinkList_traits;
|
|
|
|
const LinkList_type&
|
|
LinkList () const;
|
|
|
|
LinkList_type&
|
|
LinkList ();
|
|
|
|
void
|
|
LinkList (const LinkList_type& x);
|
|
|
|
void
|
|
LinkList (::std::unique_ptr< LinkList_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
SecCloseroom (const Id_type&,
|
|
const SecId_type&,
|
|
const LinkList_type&);
|
|
|
|
SecCloseroom (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SecCloseroom (const SecCloseroom& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SecCloseroom*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SecCloseroom&
|
|
operator= (const SecCloseroom& x);
|
|
|
|
virtual
|
|
~SecCloseroom ();
|
|
|
|
// 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< SecId_type > SecId_;
|
|
PlateCount_optional PlateCount_;
|
|
::xsd::cxx::tree::one< LinkList_type > LinkList_;
|
|
};
|
|
|
|
class SecShell: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
// 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);
|
|
|
|
// Constructors.
|
|
//
|
|
SecShell (const SecId_type&,
|
|
const Id_type&);
|
|
|
|
SecShell (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
SecShell (const SecShell& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual SecShell*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
SecShell&
|
|
operator= (const SecShell& x);
|
|
|
|
virtual
|
|
~SecShell ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< SecId_type > SecId_;
|
|
::xsd::cxx::tree::one< Id_type > Id_;
|
|
};
|
|
|
|
class Subnode: 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::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);
|
|
|
|
static X_type
|
|
X_default_value ();
|
|
|
|
// Ux
|
|
//
|
|
typedef ::xml_schema::boolean Ux_type;
|
|
typedef ::xsd::cxx::tree::traits< Ux_type, char > Ux_traits;
|
|
|
|
const Ux_type&
|
|
Ux () const;
|
|
|
|
Ux_type&
|
|
Ux ();
|
|
|
|
void
|
|
Ux (const Ux_type& x);
|
|
|
|
static Ux_type
|
|
Ux_default_value ();
|
|
|
|
// Uy
|
|
//
|
|
typedef ::xml_schema::boolean Uy_type;
|
|
typedef ::xsd::cxx::tree::traits< Uy_type, char > Uy_traits;
|
|
|
|
const Uy_type&
|
|
Uy () const;
|
|
|
|
Uy_type&
|
|
Uy ();
|
|
|
|
void
|
|
Uy (const Uy_type& x);
|
|
|
|
static Uy_type
|
|
Uy_default_value ();
|
|
|
|
// Uz
|
|
//
|
|
typedef ::xml_schema::boolean Uz_type;
|
|
typedef ::xsd::cxx::tree::traits< Uz_type, char > Uz_traits;
|
|
|
|
const Uz_type&
|
|
Uz () const;
|
|
|
|
Uz_type&
|
|
Uz ();
|
|
|
|
void
|
|
Uz (const Uz_type& x);
|
|
|
|
static Uz_type
|
|
Uz_default_value ();
|
|
|
|
// Rx
|
|
//
|
|
typedef ::xml_schema::boolean Rx_type;
|
|
typedef ::xsd::cxx::tree::traits< Rx_type, char > Rx_traits;
|
|
|
|
const Rx_type&
|
|
Rx () const;
|
|
|
|
Rx_type&
|
|
Rx ();
|
|
|
|
void
|
|
Rx (const Rx_type& x);
|
|
|
|
static Rx_type
|
|
Rx_default_value ();
|
|
|
|
// Ry
|
|
//
|
|
typedef ::xml_schema::boolean Ry_type;
|
|
typedef ::xsd::cxx::tree::traits< Ry_type, char > Ry_traits;
|
|
|
|
const Ry_type&
|
|
Ry () const;
|
|
|
|
Ry_type&
|
|
Ry ();
|
|
|
|
void
|
|
Ry (const Ry_type& x);
|
|
|
|
static Ry_type
|
|
Ry_default_value ();
|
|
|
|
// Rz
|
|
//
|
|
typedef ::xml_schema::boolean Rz_type;
|
|
typedef ::xsd::cxx::tree::traits< Rz_type, char > Rz_traits;
|
|
|
|
const Rz_type&
|
|
Rz () const;
|
|
|
|
Rz_type&
|
|
Rz ();
|
|
|
|
void
|
|
Rz (const Rz_type& x);
|
|
|
|
static Rz_type
|
|
Rz_default_value ();
|
|
|
|
// Wx
|
|
//
|
|
typedef ::xml_schema::boolean Wx_type;
|
|
typedef ::xsd::cxx::tree::traits< Wx_type, char > Wx_traits;
|
|
|
|
const Wx_type&
|
|
Wx () const;
|
|
|
|
Wx_type&
|
|
Wx ();
|
|
|
|
void
|
|
Wx (const Wx_type& x);
|
|
|
|
static Wx_type
|
|
Wx_default_value ();
|
|
|
|
// Fr
|
|
//
|
|
typedef ::xml_schema::int_ Fr_type;
|
|
typedef ::xsd::cxx::tree::optional< Fr_type > Fr_optional;
|
|
typedef ::xsd::cxx::tree::traits< Fr_type, char > Fr_traits;
|
|
|
|
const Fr_optional&
|
|
Fr () const;
|
|
|
|
Fr_optional&
|
|
Fr ();
|
|
|
|
void
|
|
Fr (const Fr_type& x);
|
|
|
|
void
|
|
Fr (const Fr_optional& x);
|
|
|
|
static Fr_type
|
|
Fr_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Subnode (const Id_type&,
|
|
const X_type&,
|
|
const Ux_type&,
|
|
const Uy_type&,
|
|
const Uz_type&,
|
|
const Rx_type&,
|
|
const Ry_type&,
|
|
const Rz_type&,
|
|
const Wx_type&);
|
|
|
|
Subnode (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Subnode (const Subnode& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Subnode*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Subnode&
|
|
operator= (const Subnode& x);
|
|
|
|
virtual
|
|
~Subnode ();
|
|
|
|
// 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< X_type > X_;
|
|
::xsd::cxx::tree::one< Ux_type > Ux_;
|
|
::xsd::cxx::tree::one< Uy_type > Uy_;
|
|
::xsd::cxx::tree::one< Uz_type > Uz_;
|
|
::xsd::cxx::tree::one< Rx_type > Rx_;
|
|
::xsd::cxx::tree::one< Ry_type > Ry_;
|
|
::xsd::cxx::tree::one< Rz_type > Rz_;
|
|
::xsd::cxx::tree::one< Wx_type > Wx_;
|
|
Fr_optional Fr_;
|
|
};
|
|
|
|
class Mat: 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);
|
|
|
|
// E
|
|
//
|
|
typedef ::xml_schema::double_ E_type;
|
|
typedef ::xsd::cxx::tree::traits< E_type, char, ::xsd::cxx::tree::schema_type::double_ > E_traits;
|
|
|
|
const E_type&
|
|
E () const;
|
|
|
|
E_type&
|
|
E ();
|
|
|
|
void
|
|
E (const E_type& x);
|
|
|
|
static E_type
|
|
E_default_value ();
|
|
|
|
// Mu
|
|
//
|
|
typedef ::xml_schema::double_ Mu_type;
|
|
typedef ::xsd::cxx::tree::traits< Mu_type, char, ::xsd::cxx::tree::schema_type::double_ > Mu_traits;
|
|
|
|
const Mu_type&
|
|
Mu () const;
|
|
|
|
Mu_type&
|
|
Mu ();
|
|
|
|
void
|
|
Mu (const Mu_type& x);
|
|
|
|
static Mu_type
|
|
Mu_default_value ();
|
|
|
|
// Ro
|
|
//
|
|
typedef ::xml_schema::double_ Ro_type;
|
|
typedef ::xsd::cxx::tree::traits< Ro_type, char, ::xsd::cxx::tree::schema_type::double_ > Ro_traits;
|
|
|
|
const Ro_type&
|
|
Ro () const;
|
|
|
|
Ro_type&
|
|
Ro ();
|
|
|
|
void
|
|
Ro (const Ro_type& x);
|
|
|
|
static Ro_type
|
|
Ro_default_value ();
|
|
|
|
// ReH
|
|
//
|
|
typedef ::xml_schema::double_ ReH_type;
|
|
typedef ::xsd::cxx::tree::traits< ReH_type, char, ::xsd::cxx::tree::schema_type::double_ > ReH_traits;
|
|
|
|
const ReH_type&
|
|
ReH () const;
|
|
|
|
ReH_type&
|
|
ReH ();
|
|
|
|
void
|
|
ReH (const ReH_type& x);
|
|
|
|
static ReH_type
|
|
ReH_default_value ();
|
|
|
|
// K
|
|
//
|
|
typedef ::xml_schema::double_ K_type;
|
|
typedef ::xsd::cxx::tree::traits< K_type, char, ::xsd::cxx::tree::schema_type::double_ > K_traits;
|
|
|
|
const K_type&
|
|
K () const;
|
|
|
|
K_type&
|
|
K ();
|
|
|
|
void
|
|
K (const K_type& x);
|
|
|
|
static K_type
|
|
K_default_value ();
|
|
|
|
// ReHd
|
|
//
|
|
typedef ::xml_schema::double_ ReHd_type;
|
|
typedef ::xsd::cxx::tree::optional< ReHd_type > ReHd_optional;
|
|
typedef ::xsd::cxx::tree::traits< ReHd_type, char, ::xsd::cxx::tree::schema_type::double_ > ReHd_traits;
|
|
|
|
const ReHd_optional&
|
|
ReHd () const;
|
|
|
|
ReHd_optional&
|
|
ReHd ();
|
|
|
|
void
|
|
ReHd (const ReHd_type& x);
|
|
|
|
void
|
|
ReHd (const ReHd_optional& x);
|
|
|
|
static ReHd_type
|
|
ReHd_default_value ();
|
|
|
|
// Kd
|
|
//
|
|
typedef ::xml_schema::double_ Kd_type;
|
|
typedef ::xsd::cxx::tree::optional< Kd_type > Kd_optional;
|
|
typedef ::xsd::cxx::tree::traits< Kd_type, char, ::xsd::cxx::tree::schema_type::double_ > Kd_traits;
|
|
|
|
const Kd_optional&
|
|
Kd () const;
|
|
|
|
Kd_optional&
|
|
Kd ();
|
|
|
|
void
|
|
Kd (const Kd_type& x);
|
|
|
|
void
|
|
Kd (const Kd_optional& x);
|
|
|
|
static Kd_type
|
|
Kd_default_value ();
|
|
|
|
// ReHb
|
|
//
|
|
typedef ::xml_schema::double_ ReHb_type;
|
|
typedef ::xsd::cxx::tree::optional< ReHb_type > ReHb_optional;
|
|
typedef ::xsd::cxx::tree::traits< ReHb_type, char, ::xsd::cxx::tree::schema_type::double_ > ReHb_traits;
|
|
|
|
const ReHb_optional&
|
|
ReHb () const;
|
|
|
|
ReHb_optional&
|
|
ReHb ();
|
|
|
|
void
|
|
ReHb (const ReHb_type& x);
|
|
|
|
void
|
|
ReHb (const ReHb_optional& x);
|
|
|
|
static ReHb_type
|
|
ReHb_default_value ();
|
|
|
|
// Kb
|
|
//
|
|
typedef ::xml_schema::double_ Kb_type;
|
|
typedef ::xsd::cxx::tree::optional< Kb_type > Kb_optional;
|
|
typedef ::xsd::cxx::tree::traits< Kb_type, char, ::xsd::cxx::tree::schema_type::double_ > Kb_traits;
|
|
|
|
const Kb_optional&
|
|
Kb () const;
|
|
|
|
Kb_optional&
|
|
Kb ();
|
|
|
|
void
|
|
Kb (const Kb_type& x);
|
|
|
|
void
|
|
Kb (const Kb_optional& x);
|
|
|
|
static Kb_type
|
|
Kb_default_value ();
|
|
|
|
// ReHh
|
|
//
|
|
typedef ::xml_schema::double_ ReHh_type;
|
|
typedef ::xsd::cxx::tree::optional< ReHh_type > ReHh_optional;
|
|
typedef ::xsd::cxx::tree::traits< ReHh_type, char, ::xsd::cxx::tree::schema_type::double_ > ReHh_traits;
|
|
|
|
const ReHh_optional&
|
|
ReHh () const;
|
|
|
|
ReHh_optional&
|
|
ReHh ();
|
|
|
|
void
|
|
ReHh (const ReHh_type& x);
|
|
|
|
void
|
|
ReHh (const ReHh_optional& x);
|
|
|
|
static ReHh_type
|
|
ReHh_default_value ();
|
|
|
|
// Kh
|
|
//
|
|
typedef ::xml_schema::double_ Kh_type;
|
|
typedef ::xsd::cxx::tree::optional< Kh_type > Kh_optional;
|
|
typedef ::xsd::cxx::tree::traits< Kh_type, char, ::xsd::cxx::tree::schema_type::double_ > Kh_traits;
|
|
|
|
const Kh_optional&
|
|
Kh () const;
|
|
|
|
Kh_optional&
|
|
Kh ();
|
|
|
|
void
|
|
Kh (const Kh_type& x);
|
|
|
|
void
|
|
Kh (const Kh_optional& x);
|
|
|
|
static Kh_type
|
|
Kh_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Mat (const Id_type&,
|
|
const E_type&,
|
|
const Mu_type&,
|
|
const Ro_type&,
|
|
const ReH_type&,
|
|
const K_type&);
|
|
|
|
Mat (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Mat (const Mat& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Mat*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Mat&
|
|
operator= (const Mat& x);
|
|
|
|
virtual
|
|
~Mat ();
|
|
|
|
// 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< E_type > E_;
|
|
::xsd::cxx::tree::one< Mu_type > Mu_;
|
|
::xsd::cxx::tree::one< Ro_type > Ro_;
|
|
::xsd::cxx::tree::one< ReH_type > ReH_;
|
|
::xsd::cxx::tree::one< K_type > K_;
|
|
ReHd_optional ReHd_;
|
|
Kd_optional Kd_;
|
|
ReHb_optional ReHb_;
|
|
Kb_optional Kb_;
|
|
ReHh_optional ReHh_;
|
|
Kh_optional Kh_;
|
|
};
|
|
|
|
class Subgirder: 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);
|
|
|
|
// NodeI
|
|
//
|
|
typedef ::xml_schema::int_ NodeI_type;
|
|
typedef ::xsd::cxx::tree::traits< NodeI_type, char > NodeI_traits;
|
|
|
|
const NodeI_type&
|
|
NodeI () const;
|
|
|
|
NodeI_type&
|
|
NodeI ();
|
|
|
|
void
|
|
NodeI (const NodeI_type& x);
|
|
|
|
static NodeI_type
|
|
NodeI_default_value ();
|
|
|
|
// NodeJ
|
|
//
|
|
typedef ::xml_schema::int_ NodeJ_type;
|
|
typedef ::xsd::cxx::tree::traits< NodeJ_type, char > NodeJ_traits;
|
|
|
|
const NodeJ_type&
|
|
NodeJ () const;
|
|
|
|
NodeJ_type&
|
|
NodeJ ();
|
|
|
|
void
|
|
NodeJ (const NodeJ_type& x);
|
|
|
|
static NodeJ_type
|
|
NodeJ_default_value ();
|
|
|
|
// NextSecId
|
|
//
|
|
typedef ::xml_schema::int_ NextSecId_type;
|
|
typedef ::xsd::cxx::tree::traits< NextSecId_type, char > NextSecId_traits;
|
|
|
|
const NextSecId_type&
|
|
NextSecId () const;
|
|
|
|
NextSecId_type&
|
|
NextSecId ();
|
|
|
|
void
|
|
NextSecId (const NextSecId_type& x);
|
|
|
|
static NextSecId_type
|
|
NextSecId_default_value ();
|
|
|
|
// MatId
|
|
//
|
|
typedef ::xml_schema::int_ MatId_type;
|
|
typedef ::xsd::cxx::tree::optional< MatId_type > MatId_optional;
|
|
typedef ::xsd::cxx::tree::traits< MatId_type, char > MatId_traits;
|
|
|
|
const MatId_optional&
|
|
MatId () const;
|
|
|
|
MatId_optional&
|
|
MatId ();
|
|
|
|
void
|
|
MatId (const MatId_type& x);
|
|
|
|
void
|
|
MatId (const MatId_optional& x);
|
|
|
|
static MatId_type
|
|
MatId_default_value ();
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_type&
|
|
SecId () const;
|
|
|
|
SecId_type&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
static SecId_type
|
|
SecId_default_value ();
|
|
|
|
// Sym
|
|
//
|
|
typedef ::xml_schema::boolean Sym_type;
|
|
typedef ::xsd::cxx::tree::traits< Sym_type, char > Sym_traits;
|
|
|
|
const Sym_type&
|
|
Sym () const;
|
|
|
|
Sym_type&
|
|
Sym ();
|
|
|
|
void
|
|
Sym (const Sym_type& x);
|
|
|
|
static Sym_type
|
|
Sym_default_value ();
|
|
|
|
// AttachId
|
|
//
|
|
typedef ::xml_schema::int_ AttachId_type;
|
|
typedef ::xsd::cxx::tree::traits< AttachId_type, char > AttachId_traits;
|
|
|
|
const AttachId_type&
|
|
AttachId () const;
|
|
|
|
AttachId_type&
|
|
AttachId ();
|
|
|
|
void
|
|
AttachId (const AttachId_type& x);
|
|
|
|
static AttachId_type
|
|
AttachId_default_value ();
|
|
|
|
// Fd
|
|
//
|
|
typedef ::xml_schema::double_ Fd_type;
|
|
typedef ::xsd::cxx::tree::optional< Fd_type > Fd_optional;
|
|
typedef ::xsd::cxx::tree::traits< Fd_type, char, ::xsd::cxx::tree::schema_type::double_ > Fd_traits;
|
|
|
|
const Fd_optional&
|
|
Fd () const;
|
|
|
|
Fd_optional&
|
|
Fd ();
|
|
|
|
void
|
|
Fd (const Fd_type& x);
|
|
|
|
void
|
|
Fd (const Fd_optional& x);
|
|
|
|
static Fd_type
|
|
Fd_default_value ();
|
|
|
|
// Fb
|
|
//
|
|
typedef ::xml_schema::double_ Fb_type;
|
|
typedef ::xsd::cxx::tree::optional< Fb_type > Fb_optional;
|
|
typedef ::xsd::cxx::tree::traits< Fb_type, char, ::xsd::cxx::tree::schema_type::double_ > Fb_traits;
|
|
|
|
const Fb_optional&
|
|
Fb () const;
|
|
|
|
Fb_optional&
|
|
Fb ();
|
|
|
|
void
|
|
Fb (const Fb_type& x);
|
|
|
|
void
|
|
Fb (const Fb_optional& x);
|
|
|
|
static Fb_type
|
|
Fb_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Subgirder (const Id_type&,
|
|
const NodeI_type&,
|
|
const NodeJ_type&,
|
|
const NextSecId_type&,
|
|
const SecId_type&,
|
|
const Sym_type&,
|
|
const AttachId_type&);
|
|
|
|
Subgirder (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Subgirder (const Subgirder& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Subgirder*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Subgirder&
|
|
operator= (const Subgirder& x);
|
|
|
|
virtual
|
|
~Subgirder ();
|
|
|
|
// 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< NodeI_type > NodeI_;
|
|
::xsd::cxx::tree::one< NodeJ_type > NodeJ_;
|
|
::xsd::cxx::tree::one< NextSecId_type > NextSecId_;
|
|
MatId_optional MatId_;
|
|
::xsd::cxx::tree::one< SecId_type > SecId_;
|
|
::xsd::cxx::tree::one< Sym_type > Sym_;
|
|
::xsd::cxx::tree::one< AttachId_type > AttachId_;
|
|
Fd_optional Fd_;
|
|
Fb_optional Fb_;
|
|
};
|
|
|
|
class Attach: 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::string 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);
|
|
|
|
void
|
|
Type (::std::unique_ptr< Type_type > p);
|
|
|
|
static const Type_type&
|
|
Type_default_value ();
|
|
|
|
// SecNodeId
|
|
//
|
|
typedef ::xml_schema::int_ SecNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< SecNodeId_type, char > SecNodeId_traits;
|
|
|
|
const SecNodeId_type&
|
|
SecNodeId () const;
|
|
|
|
SecNodeId_type&
|
|
SecNodeId ();
|
|
|
|
void
|
|
SecNodeId (const SecNodeId_type& x);
|
|
|
|
static SecNodeId_type
|
|
SecNodeId_default_value ();
|
|
|
|
// Width
|
|
//
|
|
typedef ::xml_schema::double_ Width_type;
|
|
typedef ::xsd::cxx::tree::traits< Width_type, char, ::xsd::cxx::tree::schema_type::double_ > Width_traits;
|
|
|
|
const Width_type&
|
|
Width () const;
|
|
|
|
Width_type&
|
|
Width ();
|
|
|
|
void
|
|
Width (const Width_type& x);
|
|
|
|
static Width_type
|
|
Width_default_value ();
|
|
|
|
// Height
|
|
//
|
|
typedef ::xml_schema::double_ Height_type;
|
|
typedef ::xsd::cxx::tree::traits< Height_type, char, ::xsd::cxx::tree::schema_type::double_ > Height_traits;
|
|
|
|
const Height_type&
|
|
Height () const;
|
|
|
|
Height_type&
|
|
Height ();
|
|
|
|
void
|
|
Height (const Height_type& x);
|
|
|
|
static Height_type
|
|
Height_default_value ();
|
|
|
|
// T
|
|
//
|
|
typedef ::xml_schema::double_ T_type;
|
|
typedef ::xsd::cxx::tree::traits< T_type, char, ::xsd::cxx::tree::schema_type::double_ > T_traits;
|
|
|
|
const T_type&
|
|
T () const;
|
|
|
|
T_type&
|
|
T ();
|
|
|
|
void
|
|
T (const T_type& x);
|
|
|
|
static T_type
|
|
T_default_value ();
|
|
|
|
// Tw
|
|
//
|
|
typedef ::xml_schema::double_ Tw_type;
|
|
typedef ::xsd::cxx::tree::traits< Tw_type, char, ::xsd::cxx::tree::schema_type::double_ > Tw_traits;
|
|
|
|
const Tw_type&
|
|
Tw () const;
|
|
|
|
Tw_type&
|
|
Tw ();
|
|
|
|
void
|
|
Tw (const Tw_type& x);
|
|
|
|
static Tw_type
|
|
Tw_default_value ();
|
|
|
|
// Len
|
|
//
|
|
typedef ::xml_schema::double_ Len_type;
|
|
typedef ::xsd::cxx::tree::traits< Len_type, char, ::xsd::cxx::tree::schema_type::double_ > Len_traits;
|
|
|
|
const Len_type&
|
|
Len () const;
|
|
|
|
Len_type&
|
|
Len ();
|
|
|
|
void
|
|
Len (const Len_type& x);
|
|
|
|
static Len_type
|
|
Len_default_value ();
|
|
|
|
// DistI
|
|
//
|
|
typedef ::xml_schema::double_ DistI_type;
|
|
typedef ::xsd::cxx::tree::traits< DistI_type, char, ::xsd::cxx::tree::schema_type::double_ > DistI_traits;
|
|
|
|
const DistI_type&
|
|
DistI () const;
|
|
|
|
DistI_type&
|
|
DistI ();
|
|
|
|
void
|
|
DistI (const DistI_type& x);
|
|
|
|
static DistI_type
|
|
DistI_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Attach (const Id_type&,
|
|
const Type_type&,
|
|
const SecNodeId_type&,
|
|
const Width_type&,
|
|
const Height_type&,
|
|
const T_type&,
|
|
const Tw_type&,
|
|
const Len_type&,
|
|
const DistI_type&);
|
|
|
|
Attach (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Attach (const Attach& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Attach*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Attach&
|
|
operator= (const Attach& x);
|
|
|
|
virtual
|
|
~Attach ();
|
|
|
|
// 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_;
|
|
static const Type_type Type_default_value_;
|
|
::xsd::cxx::tree::one< SecNodeId_type > SecNodeId_;
|
|
::xsd::cxx::tree::one< Width_type > Width_;
|
|
::xsd::cxx::tree::one< Height_type > Height_;
|
|
::xsd::cxx::tree::one< T_type > T_;
|
|
::xsd::cxx::tree::one< Tw_type > Tw_;
|
|
::xsd::cxx::tree::one< Len_type > Len_;
|
|
::xsd::cxx::tree::one< DistI_type > DistI_;
|
|
};
|
|
|
|
class Girder: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// SubgirderCount
|
|
//
|
|
typedef ::xml_schema::int_ SubgirderCount_type;
|
|
typedef ::xsd::cxx::tree::traits< SubgirderCount_type, char > SubgirderCount_traits;
|
|
|
|
const SubgirderCount_type&
|
|
SubgirderCount () const;
|
|
|
|
SubgirderCount_type&
|
|
SubgirderCount ();
|
|
|
|
void
|
|
SubgirderCount (const SubgirderCount_type& x);
|
|
|
|
static SubgirderCount_type
|
|
SubgirderCount_default_value ();
|
|
|
|
// SecShearCorrect
|
|
//
|
|
typedef ::xml_schema::boolean SecShearCorrect_type;
|
|
typedef ::xsd::cxx::tree::traits< SecShearCorrect_type, char > SecShearCorrect_traits;
|
|
|
|
const SecShearCorrect_type&
|
|
SecShearCorrect () const;
|
|
|
|
SecShearCorrect_type&
|
|
SecShearCorrect ();
|
|
|
|
void
|
|
SecShearCorrect (const SecShearCorrect_type& x);
|
|
|
|
static SecShearCorrect_type
|
|
SecShearCorrect_default_value ();
|
|
|
|
// BhAftNodeId
|
|
//
|
|
typedef ::xml_schema::int_ BhAftNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< BhAftNodeId_type, char > BhAftNodeId_traits;
|
|
|
|
const BhAftNodeId_type&
|
|
BhAftNodeId () const;
|
|
|
|
BhAftNodeId_type&
|
|
BhAftNodeId ();
|
|
|
|
void
|
|
BhAftNodeId (const BhAftNodeId_type& x);
|
|
|
|
static BhAftNodeId_type
|
|
BhAftNodeId_default_value ();
|
|
|
|
// BhForNodeId
|
|
//
|
|
typedef ::xml_schema::int_ BhForNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< BhForNodeId_type, char > BhForNodeId_traits;
|
|
|
|
const BhForNodeId_type&
|
|
BhForNodeId () const;
|
|
|
|
BhForNodeId_type&
|
|
BhForNodeId ();
|
|
|
|
void
|
|
BhForNodeId (const BhForNodeId_type& x);
|
|
|
|
static BhForNodeId_type
|
|
BhForNodeId_default_value ();
|
|
|
|
// HatchAftNodeId
|
|
//
|
|
typedef ::xml_schema::int_ HatchAftNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< HatchAftNodeId_type, char > HatchAftNodeId_traits;
|
|
|
|
const HatchAftNodeId_type&
|
|
HatchAftNodeId () const;
|
|
|
|
HatchAftNodeId_type&
|
|
HatchAftNodeId ();
|
|
|
|
void
|
|
HatchAftNodeId (const HatchAftNodeId_type& x);
|
|
|
|
static HatchAftNodeId_type
|
|
HatchAftNodeId_default_value ();
|
|
|
|
// HatchForNodeId
|
|
//
|
|
typedef ::xml_schema::int_ HatchForNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< HatchForNodeId_type, char > HatchForNodeId_traits;
|
|
|
|
const HatchForNodeId_type&
|
|
HatchForNodeId () const;
|
|
|
|
HatchForNodeId_type&
|
|
HatchForNodeId ();
|
|
|
|
void
|
|
HatchForNodeId (const HatchForNodeId_type& x);
|
|
|
|
static HatchForNodeId_type
|
|
HatchForNodeId_default_value ();
|
|
|
|
// OpenAftNodeId
|
|
//
|
|
typedef ::xml_schema::int_ OpenAftNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< OpenAftNodeId_type, char > OpenAftNodeId_traits;
|
|
|
|
const OpenAftNodeId_type&
|
|
OpenAftNodeId () const;
|
|
|
|
OpenAftNodeId_type&
|
|
OpenAftNodeId ();
|
|
|
|
void
|
|
OpenAftNodeId (const OpenAftNodeId_type& x);
|
|
|
|
static OpenAftNodeId_type
|
|
OpenAftNodeId_default_value ();
|
|
|
|
// OpenForNodeId
|
|
//
|
|
typedef ::xml_schema::int_ OpenForNodeId_type;
|
|
typedef ::xsd::cxx::tree::traits< OpenForNodeId_type, char > OpenForNodeId_traits;
|
|
|
|
const OpenForNodeId_type&
|
|
OpenForNodeId () const;
|
|
|
|
OpenForNodeId_type&
|
|
OpenForNodeId ();
|
|
|
|
void
|
|
OpenForNodeId (const OpenForNodeId_type& x);
|
|
|
|
static OpenForNodeId_type
|
|
OpenForNodeId_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Girder (const SubgirderCount_type&,
|
|
const SecShearCorrect_type&,
|
|
const BhAftNodeId_type&,
|
|
const BhForNodeId_type&,
|
|
const HatchAftNodeId_type&,
|
|
const HatchForNodeId_type&,
|
|
const OpenAftNodeId_type&,
|
|
const OpenForNodeId_type&);
|
|
|
|
Girder (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Girder (const Girder& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Girder*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Girder&
|
|
operator= (const Girder& x);
|
|
|
|
virtual
|
|
~Girder ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< SubgirderCount_type > SubgirderCount_;
|
|
::xsd::cxx::tree::one< SecShearCorrect_type > SecShearCorrect_;
|
|
::xsd::cxx::tree::one< BhAftNodeId_type > BhAftNodeId_;
|
|
::xsd::cxx::tree::one< BhForNodeId_type > BhForNodeId_;
|
|
::xsd::cxx::tree::one< HatchAftNodeId_type > HatchAftNodeId_;
|
|
::xsd::cxx::tree::one< HatchForNodeId_type > HatchForNodeId_;
|
|
::xsd::cxx::tree::one< OpenAftNodeId_type > OpenAftNodeId_;
|
|
::xsd::cxx::tree::one< OpenForNodeId_type > OpenForNodeId_;
|
|
};
|
|
|
|
class Loads: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// BuoyType
|
|
//
|
|
typedef ::xml_schema::string BuoyType_type;
|
|
typedef ::xsd::cxx::tree::traits< BuoyType_type, char > BuoyType_traits;
|
|
|
|
const BuoyType_type&
|
|
BuoyType () const;
|
|
|
|
BuoyType_type&
|
|
BuoyType ();
|
|
|
|
void
|
|
BuoyType (const BuoyType_type& x);
|
|
|
|
void
|
|
BuoyType (::std::unique_ptr< BuoyType_type > p);
|
|
|
|
// WeightType
|
|
//
|
|
typedef ::xml_schema::string WeightType_type;
|
|
typedef ::xsd::cxx::tree::traits< WeightType_type, char > WeightType_traits;
|
|
|
|
const WeightType_type&
|
|
WeightType () const;
|
|
|
|
WeightType_type&
|
|
WeightType ();
|
|
|
|
void
|
|
WeightType (const WeightType_type& x);
|
|
|
|
void
|
|
WeightType (::std::unique_ptr< WeightType_type > p);
|
|
|
|
// Zs
|
|
//
|
|
typedef ::xml_schema::double_ Zs_type;
|
|
typedef ::xsd::cxx::tree::traits< Zs_type, char, ::xsd::cxx::tree::schema_type::double_ > Zs_traits;
|
|
|
|
const Zs_type&
|
|
Zs () const;
|
|
|
|
Zs_type&
|
|
Zs ();
|
|
|
|
void
|
|
Zs (const Zs_type& x);
|
|
|
|
// StaticLoadExist
|
|
//
|
|
typedef ::xml_schema::boolean StaticLoadExist_type;
|
|
typedef ::xsd::cxx::tree::optional< StaticLoadExist_type > StaticLoadExist_optional;
|
|
typedef ::xsd::cxx::tree::traits< StaticLoadExist_type, char > StaticLoadExist_traits;
|
|
|
|
const StaticLoadExist_optional&
|
|
StaticLoadExist () const;
|
|
|
|
StaticLoadExist_optional&
|
|
StaticLoadExist ();
|
|
|
|
void
|
|
StaticLoadExist (const StaticLoadExist_type& x);
|
|
|
|
void
|
|
StaticLoadExist (const StaticLoadExist_optional& x);
|
|
|
|
static StaticLoadExist_type
|
|
StaticLoadExist_default_value ();
|
|
|
|
// AddtionalWaveLoadCustom
|
|
//
|
|
typedef ::xml_schema::boolean AddtionalWaveLoadCustom_type;
|
|
typedef ::xsd::cxx::tree::optional< AddtionalWaveLoadCustom_type > AddtionalWaveLoadCustom_optional;
|
|
typedef ::xsd::cxx::tree::traits< AddtionalWaveLoadCustom_type, char > AddtionalWaveLoadCustom_traits;
|
|
|
|
const AddtionalWaveLoadCustom_optional&
|
|
AddtionalWaveLoadCustom () const;
|
|
|
|
AddtionalWaveLoadCustom_optional&
|
|
AddtionalWaveLoadCustom ();
|
|
|
|
void
|
|
AddtionalWaveLoadCustom (const AddtionalWaveLoadCustom_type& x);
|
|
|
|
void
|
|
AddtionalWaveLoadCustom (const AddtionalWaveLoadCustom_optional& x);
|
|
|
|
static AddtionalWaveLoadCustom_type
|
|
AddtionalWaveLoadCustom_default_value ();
|
|
|
|
// AddtionalCargoLoadCustom
|
|
//
|
|
typedef ::xml_schema::boolean AddtionalCargoLoadCustom_type;
|
|
typedef ::xsd::cxx::tree::optional< AddtionalCargoLoadCustom_type > AddtionalCargoLoadCustom_optional;
|
|
typedef ::xsd::cxx::tree::traits< AddtionalCargoLoadCustom_type, char > AddtionalCargoLoadCustom_traits;
|
|
|
|
const AddtionalCargoLoadCustom_optional&
|
|
AddtionalCargoLoadCustom () const;
|
|
|
|
AddtionalCargoLoadCustom_optional&
|
|
AddtionalCargoLoadCustom ();
|
|
|
|
void
|
|
AddtionalCargoLoadCustom (const AddtionalCargoLoadCustom_type& x);
|
|
|
|
void
|
|
AddtionalCargoLoadCustom (const AddtionalCargoLoadCustom_optional& x);
|
|
|
|
static AddtionalCargoLoadCustom_type
|
|
AddtionalCargoLoadCustom_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Loads (const BuoyType_type&,
|
|
const WeightType_type&,
|
|
const Zs_type&);
|
|
|
|
Loads (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Loads (const Loads& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Loads*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Loads&
|
|
operator= (const Loads& x);
|
|
|
|
virtual
|
|
~Loads ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< BuoyType_type > BuoyType_;
|
|
::xsd::cxx::tree::one< WeightType_type > WeightType_;
|
|
::xsd::cxx::tree::one< Zs_type > Zs_;
|
|
StaticLoadExist_optional StaticLoadExist_;
|
|
AddtionalWaveLoadCustom_optional AddtionalWaveLoadCustom_;
|
|
AddtionalCargoLoadCustom_optional AddtionalCargoLoadCustom_;
|
|
};
|
|
|
|
class Offset: 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);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Offset (const Id_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
Offset (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Offset (const Offset& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Offset*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Offset&
|
|
operator= (const Offset& x);
|
|
|
|
virtual
|
|
~Offset ();
|
|
|
|
// 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< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class WL: 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);
|
|
|
|
// Height
|
|
//
|
|
typedef ::xml_schema::double_ Height_type;
|
|
typedef ::xsd::cxx::tree::optional< Height_type > Height_optional;
|
|
typedef ::xsd::cxx::tree::traits< Height_type, char, ::xsd::cxx::tree::schema_type::double_ > Height_traits;
|
|
|
|
const Height_optional&
|
|
Height () const;
|
|
|
|
Height_optional&
|
|
Height ();
|
|
|
|
void
|
|
Height (const Height_type& x);
|
|
|
|
void
|
|
Height (const Height_optional& x);
|
|
|
|
static Height_type
|
|
Height_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
WL (const Id_type&);
|
|
|
|
WL (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
WL (const WL& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual WL*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
WL&
|
|
operator= (const WL& x);
|
|
|
|
virtual
|
|
~WL ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< Id_type > Id_;
|
|
Height_optional Height_;
|
|
};
|
|
|
|
class Bonjean: 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);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Bonjean (const Id_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
Bonjean (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Bonjean (const Bonjean& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Bonjean*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Bonjean&
|
|
operator= (const Bonjean& x);
|
|
|
|
virtual
|
|
~Bonjean ();
|
|
|
|
// 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< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class KL: 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);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
KL (const Id_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
KL (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
KL (const KL& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual KL*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
KL&
|
|
operator= (const KL& x);
|
|
|
|
virtual
|
|
~KL ();
|
|
|
|
// 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< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class LoadCase: 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::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);
|
|
|
|
static const Type_type&
|
|
Type_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
LoadCase (const Id_type&);
|
|
|
|
LoadCase (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
LoadCase (const LoadCase& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual LoadCase*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
LoadCase&
|
|
operator= (const LoadCase& x);
|
|
|
|
virtual
|
|
~LoadCase ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< Id_type > Id_;
|
|
Type_optional Type_;
|
|
static const Type_type Type_default_value_;
|
|
};
|
|
|
|
class StWeight: 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);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
StWeight (const CaseId_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&);
|
|
|
|
StWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
StWeight (const StWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual StWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
StWeight&
|
|
operator= (const StWeight& x);
|
|
|
|
virtual
|
|
~StWeight ();
|
|
|
|
// 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< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
};
|
|
|
|
class ItemWeight: 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);
|
|
|
|
// Name
|
|
//
|
|
typedef ::xml_schema::string Name_type;
|
|
typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
|
|
|
|
const Name_type&
|
|
Name () const;
|
|
|
|
Name_type&
|
|
Name ();
|
|
|
|
void
|
|
Name (const Name_type& x);
|
|
|
|
void
|
|
Name (::std::unique_ptr< Name_type > p);
|
|
|
|
// Weight
|
|
//
|
|
typedef ::xml_schema::double_ Weight_type;
|
|
typedef ::xsd::cxx::tree::optional< Weight_type > Weight_optional;
|
|
typedef ::xsd::cxx::tree::traits< Weight_type, char, ::xsd::cxx::tree::schema_type::double_ > Weight_traits;
|
|
|
|
const Weight_optional&
|
|
Weight () const;
|
|
|
|
Weight_optional&
|
|
Weight ();
|
|
|
|
void
|
|
Weight (const Weight_type& x);
|
|
|
|
void
|
|
Weight (const Weight_optional& x);
|
|
|
|
static Weight_type
|
|
Weight_default_value ();
|
|
|
|
// X0
|
|
//
|
|
typedef ::xml_schema::double_ X0_type;
|
|
typedef ::xsd::cxx::tree::optional< X0_type > X0_optional;
|
|
typedef ::xsd::cxx::tree::traits< X0_type, char, ::xsd::cxx::tree::schema_type::double_ > X0_traits;
|
|
|
|
const X0_optional&
|
|
X0 () const;
|
|
|
|
X0_optional&
|
|
X0 ();
|
|
|
|
void
|
|
X0 (const X0_type& x);
|
|
|
|
void
|
|
X0 (const X0_optional& x);
|
|
|
|
static X0_type
|
|
X0_default_value ();
|
|
|
|
// 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);
|
|
|
|
static X1_type
|
|
X1_default_value ();
|
|
|
|
// 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);
|
|
|
|
static Xg_type
|
|
Xg_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
ItemWeight (const CaseId_type&,
|
|
const Name_type&);
|
|
|
|
ItemWeight (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ItemWeight (const ItemWeight& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ItemWeight*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ItemWeight&
|
|
operator= (const ItemWeight& x);
|
|
|
|
virtual
|
|
~ItemWeight ();
|
|
|
|
// 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< Name_type > Name_;
|
|
Weight_optional Weight_;
|
|
X0_optional X0_;
|
|
X1_optional X1_;
|
|
Xg_optional Xg_;
|
|
};
|
|
|
|
class MTC: 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);
|
|
|
|
// 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);
|
|
|
|
static const 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);
|
|
|
|
static G_type
|
|
G_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 ();
|
|
|
|
// Ns
|
|
//
|
|
typedef ::xml_schema::int_ Ns_type;
|
|
typedef ::xsd::cxx::tree::optional< Ns_type > Ns_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ns_type, char > Ns_traits;
|
|
|
|
const Ns_optional&
|
|
Ns () const;
|
|
|
|
Ns_optional&
|
|
Ns ();
|
|
|
|
void
|
|
Ns (const Ns_type& x);
|
|
|
|
void
|
|
Ns (const Ns_optional& x);
|
|
|
|
static Ns_type
|
|
Ns_default_value ();
|
|
|
|
// Nt
|
|
//
|
|
typedef ::xml_schema::int_ Nt_type;
|
|
typedef ::xsd::cxx::tree::optional< Nt_type > Nt_optional;
|
|
typedef ::xsd::cxx::tree::traits< Nt_type, char > Nt_traits;
|
|
|
|
const Nt_optional&
|
|
Nt () const;
|
|
|
|
Nt_optional&
|
|
Nt ();
|
|
|
|
void
|
|
Nt (const Nt_type& x);
|
|
|
|
void
|
|
Nt (const Nt_optional& x);
|
|
|
|
static Nt_type
|
|
Nt_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
MTC (const CaseId_type&);
|
|
|
|
MTC (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
MTC (const MTC& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual MTC*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
MTC&
|
|
operator= (const MTC& x);
|
|
|
|
virtual
|
|
~MTC ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseId_type > CaseId_;
|
|
Type_optional Type_;
|
|
static const Type_type Type_default_value_;
|
|
G_optional G_;
|
|
b_optional b_;
|
|
Ns_optional Ns_;
|
|
Nt_optional Nt_;
|
|
};
|
|
|
|
class LiftedCargo: 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);
|
|
|
|
// 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);
|
|
|
|
static G_type
|
|
G_default_value ();
|
|
|
|
// a
|
|
//
|
|
typedef ::xml_schema::double_ a_type;
|
|
typedef ::xsd::cxx::tree::optional< a_type > a_optional;
|
|
typedef ::xsd::cxx::tree::traits< a_type, char, ::xsd::cxx::tree::schema_type::double_ > a_traits;
|
|
|
|
const a_optional&
|
|
a () const;
|
|
|
|
a_optional&
|
|
a ();
|
|
|
|
void
|
|
a (const a_type& x);
|
|
|
|
void
|
|
a (const a_optional& x);
|
|
|
|
static a_type
|
|
a_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 ();
|
|
|
|
// Hd
|
|
//
|
|
typedef ::xml_schema::double_ Hd_type;
|
|
typedef ::xsd::cxx::tree::optional< Hd_type > Hd_optional;
|
|
typedef ::xsd::cxx::tree::traits< Hd_type, char, ::xsd::cxx::tree::schema_type::double_ > Hd_traits;
|
|
|
|
const Hd_optional&
|
|
Hd () const;
|
|
|
|
Hd_optional&
|
|
Hd ();
|
|
|
|
void
|
|
Hd (const Hd_type& x);
|
|
|
|
void
|
|
Hd (const Hd_optional& x);
|
|
|
|
static Hd_type
|
|
Hd_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
LiftedCargo (const CaseId_type&);
|
|
|
|
LiftedCargo (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
LiftedCargo (const LiftedCargo& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual LiftedCargo*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
LiftedCargo&
|
|
operator= (const LiftedCargo& x);
|
|
|
|
virtual
|
|
~LiftedCargo ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< CaseId_type > CaseId_;
|
|
G_optional G_;
|
|
a_optional a_;
|
|
b_optional b_;
|
|
Hd_optional Hd_;
|
|
};
|
|
|
|
class ChkSubgirder: 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);
|
|
|
|
// Frame
|
|
//
|
|
typedef ::xml_schema::string Frame_type;
|
|
typedef ::xsd::cxx::tree::optional< Frame_type > Frame_optional;
|
|
typedef ::xsd::cxx::tree::traits< Frame_type, char > Frame_traits;
|
|
|
|
const Frame_optional&
|
|
Frame () const;
|
|
|
|
Frame_optional&
|
|
Frame ();
|
|
|
|
void
|
|
Frame (const Frame_type& x);
|
|
|
|
void
|
|
Frame (const Frame_optional& x);
|
|
|
|
void
|
|
Frame (::std::unique_ptr< Frame_type > p);
|
|
|
|
// Feature
|
|
//
|
|
typedef ::xml_schema::string Feature_type;
|
|
typedef ::xsd::cxx::tree::traits< Feature_type, char > Feature_traits;
|
|
|
|
const Feature_type&
|
|
Feature () const;
|
|
|
|
Feature_type&
|
|
Feature ();
|
|
|
|
void
|
|
Feature (const Feature_type& x);
|
|
|
|
void
|
|
Feature (::std::unique_ptr< Feature_type > p);
|
|
|
|
static const Feature_type&
|
|
Feature_default_value ();
|
|
|
|
// Tos
|
|
//
|
|
typedef ::xml_schema::double_ Tos_type;
|
|
typedef ::xsd::cxx::tree::traits< Tos_type, char, ::xsd::cxx::tree::schema_type::double_ > Tos_traits;
|
|
|
|
const Tos_type&
|
|
Tos () const;
|
|
|
|
Tos_type&
|
|
Tos ();
|
|
|
|
void
|
|
Tos (const Tos_type& x);
|
|
|
|
static Tos_type
|
|
Tos_default_value ();
|
|
|
|
// Tis
|
|
//
|
|
typedef ::xml_schema::double_ Tis_type;
|
|
typedef ::xsd::cxx::tree::traits< Tis_type, char, ::xsd::cxx::tree::schema_type::double_ > Tis_traits;
|
|
|
|
const Tis_type&
|
|
Tis () const;
|
|
|
|
Tis_type&
|
|
Tis ();
|
|
|
|
void
|
|
Tis (const Tis_type& x);
|
|
|
|
static Tis_type
|
|
Tis_default_value ();
|
|
|
|
// Tcs
|
|
//
|
|
typedef ::xml_schema::double_ Tcs_type;
|
|
typedef ::xsd::cxx::tree::traits< Tcs_type, char, ::xsd::cxx::tree::schema_type::double_ > Tcs_traits;
|
|
|
|
const Tcs_type&
|
|
Tcs () const;
|
|
|
|
Tcs_type&
|
|
Tcs ();
|
|
|
|
void
|
|
Tcs (const Tcs_type& x);
|
|
|
|
static Tcs_type
|
|
Tcs_default_value ();
|
|
|
|
// B
|
|
//
|
|
typedef ::xml_schema::double_ B_type;
|
|
typedef ::xsd::cxx::tree::traits< B_type, char, ::xsd::cxx::tree::schema_type::double_ > B_traits;
|
|
|
|
const B_type&
|
|
B () const;
|
|
|
|
B_type&
|
|
B ();
|
|
|
|
void
|
|
B (const B_type& x);
|
|
|
|
static B_type
|
|
B_default_value ();
|
|
|
|
// TosId
|
|
//
|
|
typedef ::xml_schema::int_ TosId_type;
|
|
typedef ::xsd::cxx::tree::optional< TosId_type > TosId_optional;
|
|
typedef ::xsd::cxx::tree::traits< TosId_type, char > TosId_traits;
|
|
|
|
const TosId_optional&
|
|
TosId () const;
|
|
|
|
TosId_optional&
|
|
TosId ();
|
|
|
|
void
|
|
TosId (const TosId_type& x);
|
|
|
|
void
|
|
TosId (const TosId_optional& x);
|
|
|
|
// TisId
|
|
//
|
|
typedef ::xml_schema::int_ TisId_type;
|
|
typedef ::xsd::cxx::tree::optional< TisId_type > TisId_optional;
|
|
typedef ::xsd::cxx::tree::traits< TisId_type, char > TisId_traits;
|
|
|
|
const TisId_optional&
|
|
TisId () const;
|
|
|
|
TisId_optional&
|
|
TisId ();
|
|
|
|
void
|
|
TisId (const TisId_type& x);
|
|
|
|
void
|
|
TisId (const TisId_optional& x);
|
|
|
|
// TcsId
|
|
//
|
|
typedef ::xml_schema::int_ TcsId_type;
|
|
typedef ::xsd::cxx::tree::optional< TcsId_type > TcsId_optional;
|
|
typedef ::xsd::cxx::tree::traits< TcsId_type, char > TcsId_traits;
|
|
|
|
const TcsId_optional&
|
|
TcsId () const;
|
|
|
|
TcsId_optional&
|
|
TcsId ();
|
|
|
|
void
|
|
TcsId (const TcsId_type& x);
|
|
|
|
void
|
|
TcsId (const TcsId_optional& x);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::optional< SecId_type > SecId_optional;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_optional&
|
|
SecId () const;
|
|
|
|
SecId_optional&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
void
|
|
SecId (const SecId_optional& x);
|
|
|
|
// A1
|
|
//
|
|
typedef ::xml_schema::double_ A1_type;
|
|
typedef ::xsd::cxx::tree::optional< A1_type > A1_optional;
|
|
typedef ::xsd::cxx::tree::traits< A1_type, char, ::xsd::cxx::tree::schema_type::double_ > A1_traits;
|
|
|
|
const A1_optional&
|
|
A1 () const;
|
|
|
|
A1_optional&
|
|
A1 ();
|
|
|
|
void
|
|
A1 (const A1_type& x);
|
|
|
|
void
|
|
A1 (const A1_optional& x);
|
|
|
|
static A1_type
|
|
A1_default_value ();
|
|
|
|
// A2
|
|
//
|
|
typedef ::xml_schema::double_ A2_type;
|
|
typedef ::xsd::cxx::tree::optional< A2_type > A2_optional;
|
|
typedef ::xsd::cxx::tree::traits< A2_type, char, ::xsd::cxx::tree::schema_type::double_ > A2_traits;
|
|
|
|
const A2_optional&
|
|
A2 () const;
|
|
|
|
A2_optional&
|
|
A2 ();
|
|
|
|
void
|
|
A2 (const A2_type& x);
|
|
|
|
void
|
|
A2 (const A2_optional& x);
|
|
|
|
static A2_type
|
|
A2_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);
|
|
|
|
static D_type
|
|
D_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
ChkSubgirder (const Id_type&,
|
|
const Feature_type&,
|
|
const Tos_type&,
|
|
const Tis_type&,
|
|
const Tcs_type&,
|
|
const B_type&);
|
|
|
|
ChkSubgirder (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ChkSubgirder (const ChkSubgirder& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ChkSubgirder*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ChkSubgirder&
|
|
operator= (const ChkSubgirder& x);
|
|
|
|
virtual
|
|
~ChkSubgirder ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
::xsd::cxx::tree::one< Id_type > Id_;
|
|
Frame_optional Frame_;
|
|
::xsd::cxx::tree::one< Feature_type > Feature_;
|
|
static const Feature_type Feature_default_value_;
|
|
::xsd::cxx::tree::one< Tos_type > Tos_;
|
|
::xsd::cxx::tree::one< Tis_type > Tis_;
|
|
::xsd::cxx::tree::one< Tcs_type > Tcs_;
|
|
::xsd::cxx::tree::one< B_type > B_;
|
|
TosId_optional TosId_;
|
|
TisId_optional TisId_;
|
|
TcsId_optional TcsId_;
|
|
SecId_optional SecId_;
|
|
A1_optional A1_;
|
|
A2_optional A2_;
|
|
D_optional D_;
|
|
};
|
|
|
|
class ChkPlate: 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);
|
|
|
|
// Name
|
|
//
|
|
typedef ::xml_schema::string Name_type;
|
|
typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
|
|
|
|
const Name_type&
|
|
Name () const;
|
|
|
|
Name_type&
|
|
Name ();
|
|
|
|
void
|
|
Name (const Name_type& x);
|
|
|
|
void
|
|
Name (::std::unique_ptr< Name_type > p);
|
|
|
|
// 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);
|
|
|
|
static Z_type
|
|
Z_default_value ();
|
|
|
|
// 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);
|
|
|
|
// T
|
|
//
|
|
typedef ::xml_schema::double_ T_type;
|
|
typedef ::xsd::cxx::tree::traits< T_type, char, ::xsd::cxx::tree::schema_type::double_ > T_traits;
|
|
|
|
const T_type&
|
|
T () const;
|
|
|
|
T_type&
|
|
T ();
|
|
|
|
void
|
|
T (const T_type& x);
|
|
|
|
static T_type
|
|
T_default_value ();
|
|
|
|
// Lx
|
|
//
|
|
typedef ::xml_schema::double_ Lx_type;
|
|
typedef ::xsd::cxx::tree::traits< Lx_type, char, ::xsd::cxx::tree::schema_type::double_ > Lx_traits;
|
|
|
|
const Lx_type&
|
|
Lx () const;
|
|
|
|
Lx_type&
|
|
Lx ();
|
|
|
|
void
|
|
Lx (const Lx_type& x);
|
|
|
|
static Lx_type
|
|
Lx_default_value ();
|
|
|
|
// Ly
|
|
//
|
|
typedef ::xml_schema::double_ Ly_type;
|
|
typedef ::xsd::cxx::tree::optional< Ly_type > Ly_optional;
|
|
typedef ::xsd::cxx::tree::traits< Ly_type, char, ::xsd::cxx::tree::schema_type::double_ > Ly_traits;
|
|
|
|
const Ly_optional&
|
|
Ly () const;
|
|
|
|
Ly_optional&
|
|
Ly ();
|
|
|
|
void
|
|
Ly (const Ly_type& x);
|
|
|
|
void
|
|
Ly (const Ly_optional& x);
|
|
|
|
static Ly_type
|
|
Ly_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 ();
|
|
|
|
// K
|
|
//
|
|
typedef ::xml_schema::double_ K_type;
|
|
typedef ::xsd::cxx::tree::optional< K_type > K_optional;
|
|
typedef ::xsd::cxx::tree::traits< K_type, char, ::xsd::cxx::tree::schema_type::double_ > K_traits;
|
|
|
|
const K_optional&
|
|
K () const;
|
|
|
|
K_optional&
|
|
K ();
|
|
|
|
void
|
|
K (const K_type& x);
|
|
|
|
void
|
|
K (const K_optional& x);
|
|
|
|
static K_type
|
|
K_default_value ();
|
|
|
|
// TypeMat
|
|
//
|
|
typedef ::xml_schema::string TypeMat_type;
|
|
typedef ::xsd::cxx::tree::optional< TypeMat_type > TypeMat_optional;
|
|
typedef ::xsd::cxx::tree::traits< TypeMat_type, char > TypeMat_traits;
|
|
|
|
const TypeMat_optional&
|
|
TypeMat () const;
|
|
|
|
TypeMat_optional&
|
|
TypeMat ();
|
|
|
|
void
|
|
TypeMat (const TypeMat_type& x);
|
|
|
|
void
|
|
TypeMat (const TypeMat_optional& x);
|
|
|
|
void
|
|
TypeMat (::std::unique_ptr< TypeMat_type > p);
|
|
|
|
static const TypeMat_type&
|
|
TypeMat_default_value ();
|
|
|
|
// Kmat
|
|
//
|
|
typedef ::xml_schema::double_ Kmat_type;
|
|
typedef ::xsd::cxx::tree::traits< Kmat_type, char, ::xsd::cxx::tree::schema_type::double_ > Kmat_traits;
|
|
|
|
const Kmat_type&
|
|
Kmat () const;
|
|
|
|
Kmat_type&
|
|
Kmat ();
|
|
|
|
void
|
|
Kmat (const Kmat_type& x);
|
|
|
|
static Kmat_type
|
|
Kmat_default_value ();
|
|
|
|
// ReH
|
|
//
|
|
typedef ::xml_schema::double_ ReH_type;
|
|
typedef ::xsd::cxx::tree::traits< ReH_type, char, ::xsd::cxx::tree::schema_type::double_ > ReH_traits;
|
|
|
|
const ReH_type&
|
|
ReH () const;
|
|
|
|
ReH_type&
|
|
ReH ();
|
|
|
|
void
|
|
ReH (const ReH_type& x);
|
|
|
|
static ReH_type
|
|
ReH_default_value ();
|
|
|
|
// nBeam
|
|
//
|
|
typedef ::xml_schema::int_ nBeam_type;
|
|
typedef ::xsd::cxx::tree::optional< nBeam_type > nBeam_optional;
|
|
typedef ::xsd::cxx::tree::traits< nBeam_type, char > nBeam_traits;
|
|
|
|
const nBeam_optional&
|
|
nBeam () const;
|
|
|
|
nBeam_optional&
|
|
nBeam ();
|
|
|
|
void
|
|
nBeam (const nBeam_type& x);
|
|
|
|
void
|
|
nBeam (const nBeam_optional& x);
|
|
|
|
// u0
|
|
//
|
|
typedef ::xml_schema::double_ u0_type;
|
|
typedef ::xsd::cxx::tree::optional< u0_type > u0_optional;
|
|
typedef ::xsd::cxx::tree::traits< u0_type, char, ::xsd::cxx::tree::schema_type::double_ > u0_traits;
|
|
|
|
const u0_optional&
|
|
u0 () const;
|
|
|
|
u0_optional&
|
|
u0 ();
|
|
|
|
void
|
|
u0 (const u0_type& x);
|
|
|
|
void
|
|
u0 (const u0_optional& x);
|
|
|
|
// ModelBeam
|
|
//
|
|
typedef ::xml_schema::string ModelBeam_type;
|
|
typedef ::xsd::cxx::tree::optional< ModelBeam_type > ModelBeam_optional;
|
|
typedef ::xsd::cxx::tree::traits< ModelBeam_type, char > ModelBeam_traits;
|
|
|
|
const ModelBeam_optional&
|
|
ModelBeam () const;
|
|
|
|
ModelBeam_optional&
|
|
ModelBeam ();
|
|
|
|
void
|
|
ModelBeam (const ModelBeam_type& x);
|
|
|
|
void
|
|
ModelBeam (const ModelBeam_optional& x);
|
|
|
|
void
|
|
ModelBeam (::std::unique_ptr< ModelBeam_type > p);
|
|
|
|
// IBeam
|
|
//
|
|
typedef ::xml_schema::double_ IBeam_type;
|
|
typedef ::xsd::cxx::tree::optional< IBeam_type > IBeam_optional;
|
|
typedef ::xsd::cxx::tree::traits< IBeam_type, char, ::xsd::cxx::tree::schema_type::double_ > IBeam_traits;
|
|
|
|
const IBeam_optional&
|
|
IBeam () const;
|
|
|
|
IBeam_optional&
|
|
IBeam ();
|
|
|
|
void
|
|
IBeam (const IBeam_type& x);
|
|
|
|
void
|
|
IBeam (const IBeam_optional& x);
|
|
|
|
// SecPlateId
|
|
//
|
|
typedef ::xml_schema::int_ SecPlateId_type;
|
|
typedef ::xsd::cxx::tree::optional< SecPlateId_type > SecPlateId_optional;
|
|
typedef ::xsd::cxx::tree::traits< SecPlateId_type, char > SecPlateId_traits;
|
|
|
|
const SecPlateId_optional&
|
|
SecPlateId () const;
|
|
|
|
SecPlateId_optional&
|
|
SecPlateId ();
|
|
|
|
void
|
|
SecPlateId (const SecPlateId_type& x);
|
|
|
|
void
|
|
SecPlateId (const SecPlateId_optional& x);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::optional< SecId_type > SecId_optional;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_optional&
|
|
SecId () const;
|
|
|
|
SecId_optional&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
void
|
|
SecId (const SecId_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
ChkPlate (const Id_type&,
|
|
const Name_type&,
|
|
const T_type&,
|
|
const Lx_type&,
|
|
const Kmat_type&,
|
|
const ReH_type&);
|
|
|
|
ChkPlate (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ChkPlate (const ChkPlate& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ChkPlate*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ChkPlate&
|
|
operator= (const ChkPlate& x);
|
|
|
|
virtual
|
|
~ChkPlate ();
|
|
|
|
// 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< Name_type > Name_;
|
|
Z_optional Z_;
|
|
Type_optional Type_;
|
|
::xsd::cxx::tree::one< T_type > T_;
|
|
::xsd::cxx::tree::one< Lx_type > Lx_;
|
|
Ly_optional Ly_;
|
|
H_optional H_;
|
|
K_optional K_;
|
|
TypeMat_optional TypeMat_;
|
|
static const TypeMat_type TypeMat_default_value_;
|
|
::xsd::cxx::tree::one< Kmat_type > Kmat_;
|
|
::xsd::cxx::tree::one< ReH_type > ReH_;
|
|
nBeam_optional nBeam_;
|
|
u0_optional u0_;
|
|
ModelBeam_optional ModelBeam_;
|
|
IBeam_optional IBeam_;
|
|
SecPlateId_optional SecPlateId_;
|
|
SecId_optional SecId_;
|
|
};
|
|
|
|
class ChkLongitudinal: 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);
|
|
|
|
// Name
|
|
//
|
|
typedef ::xml_schema::string Name_type;
|
|
typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
|
|
|
|
const Name_type&
|
|
Name () const;
|
|
|
|
Name_type&
|
|
Name ();
|
|
|
|
void
|
|
Name (const Name_type& x);
|
|
|
|
void
|
|
Name (::std::unique_ptr< Name_type > p);
|
|
|
|
// 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);
|
|
|
|
static Z_type
|
|
Z_default_value ();
|
|
|
|
// Model
|
|
//
|
|
typedef ::xml_schema::string Model_type;
|
|
typedef ::xsd::cxx::tree::optional< Model_type > Model_optional;
|
|
typedef ::xsd::cxx::tree::traits< Model_type, char > Model_traits;
|
|
|
|
const Model_optional&
|
|
Model () const;
|
|
|
|
Model_optional&
|
|
Model ();
|
|
|
|
void
|
|
Model (const Model_type& x);
|
|
|
|
void
|
|
Model (const Model_optional& x);
|
|
|
|
void
|
|
Model (::std::unique_ptr< Model_type > p);
|
|
|
|
// L
|
|
//
|
|
typedef ::xml_schema::double_ L_type;
|
|
typedef ::xsd::cxx::tree::traits< L_type, char, ::xsd::cxx::tree::schema_type::double_ > L_traits;
|
|
|
|
const L_type&
|
|
L () const;
|
|
|
|
L_type&
|
|
L ();
|
|
|
|
void
|
|
L (const L_type& x);
|
|
|
|
static L_type
|
|
L_default_value ();
|
|
|
|
// A
|
|
//
|
|
typedef ::xml_schema::double_ A_type;
|
|
typedef ::xsd::cxx::tree::traits< A_type, char, ::xsd::cxx::tree::schema_type::double_ > A_traits;
|
|
|
|
const A_type&
|
|
A () const;
|
|
|
|
A_type&
|
|
A ();
|
|
|
|
void
|
|
A (const A_type& x);
|
|
|
|
static A_type
|
|
A_default_value ();
|
|
|
|
// I
|
|
//
|
|
typedef ::xml_schema::double_ I_type;
|
|
typedef ::xsd::cxx::tree::traits< I_type, char, ::xsd::cxx::tree::schema_type::double_ > I_traits;
|
|
|
|
const I_type&
|
|
I () const;
|
|
|
|
I_type&
|
|
I ();
|
|
|
|
void
|
|
I (const I_type& x);
|
|
|
|
static I_type
|
|
I_default_value ();
|
|
|
|
// RoomType
|
|
//
|
|
typedef ::xml_schema::string RoomType_type;
|
|
typedef ::xsd::cxx::tree::optional< RoomType_type > RoomType_optional;
|
|
typedef ::xsd::cxx::tree::traits< RoomType_type, char > RoomType_traits;
|
|
|
|
const RoomType_optional&
|
|
RoomType () const;
|
|
|
|
RoomType_optional&
|
|
RoomType ();
|
|
|
|
void
|
|
RoomType (const RoomType_type& x);
|
|
|
|
void
|
|
RoomType (const RoomType_optional& x);
|
|
|
|
void
|
|
RoomType (::std::unique_ptr< RoomType_type > p);
|
|
|
|
// AttachedPlate
|
|
//
|
|
typedef ::xml_schema::string AttachedPlate_type;
|
|
typedef ::xsd::cxx::tree::optional< AttachedPlate_type > AttachedPlate_optional;
|
|
typedef ::xsd::cxx::tree::traits< AttachedPlate_type, char > AttachedPlate_traits;
|
|
|
|
const AttachedPlate_optional&
|
|
AttachedPlate () const;
|
|
|
|
AttachedPlate_optional&
|
|
AttachedPlate ();
|
|
|
|
void
|
|
AttachedPlate (const AttachedPlate_type& x);
|
|
|
|
void
|
|
AttachedPlate (const AttachedPlate_optional& x);
|
|
|
|
void
|
|
AttachedPlate (::std::unique_ptr< AttachedPlate_type > p);
|
|
|
|
// TypeMat
|
|
//
|
|
typedef ::xml_schema::string TypeMat_type;
|
|
typedef ::xsd::cxx::tree::optional< TypeMat_type > TypeMat_optional;
|
|
typedef ::xsd::cxx::tree::traits< TypeMat_type, char > TypeMat_traits;
|
|
|
|
const TypeMat_optional&
|
|
TypeMat () const;
|
|
|
|
TypeMat_optional&
|
|
TypeMat ();
|
|
|
|
void
|
|
TypeMat (const TypeMat_type& x);
|
|
|
|
void
|
|
TypeMat (const TypeMat_optional& x);
|
|
|
|
void
|
|
TypeMat (::std::unique_ptr< TypeMat_type > p);
|
|
|
|
static const TypeMat_type&
|
|
TypeMat_default_value ();
|
|
|
|
// Kmat
|
|
//
|
|
typedef ::xml_schema::double_ Kmat_type;
|
|
typedef ::xsd::cxx::tree::traits< Kmat_type, char, ::xsd::cxx::tree::schema_type::double_ > Kmat_traits;
|
|
|
|
const Kmat_type&
|
|
Kmat () const;
|
|
|
|
Kmat_type&
|
|
Kmat ();
|
|
|
|
void
|
|
Kmat (const Kmat_type& x);
|
|
|
|
static Kmat_type
|
|
Kmat_default_value ();
|
|
|
|
// ReH
|
|
//
|
|
typedef ::xml_schema::double_ ReH_type;
|
|
typedef ::xsd::cxx::tree::traits< ReH_type, char, ::xsd::cxx::tree::schema_type::double_ > ReH_traits;
|
|
|
|
const ReH_type&
|
|
ReH () const;
|
|
|
|
ReH_type&
|
|
ReH ();
|
|
|
|
void
|
|
ReH (const ReH_type& x);
|
|
|
|
static ReH_type
|
|
ReH_default_value ();
|
|
|
|
// SecNodeId
|
|
//
|
|
typedef ::xml_schema::int_ SecNodeId_type;
|
|
typedef ::xsd::cxx::tree::optional< SecNodeId_type > SecNodeId_optional;
|
|
typedef ::xsd::cxx::tree::traits< SecNodeId_type, char > SecNodeId_traits;
|
|
|
|
const SecNodeId_optional&
|
|
SecNodeId () const;
|
|
|
|
SecNodeId_optional&
|
|
SecNodeId ();
|
|
|
|
void
|
|
SecNodeId (const SecNodeId_type& x);
|
|
|
|
void
|
|
SecNodeId (const SecNodeId_optional& x);
|
|
|
|
// SecId
|
|
//
|
|
typedef ::xml_schema::int_ SecId_type;
|
|
typedef ::xsd::cxx::tree::optional< SecId_type > SecId_optional;
|
|
typedef ::xsd::cxx::tree::traits< SecId_type, char > SecId_traits;
|
|
|
|
const SecId_optional&
|
|
SecId () const;
|
|
|
|
SecId_optional&
|
|
SecId ();
|
|
|
|
void
|
|
SecId (const SecId_type& x);
|
|
|
|
void
|
|
SecId (const SecId_optional& x);
|
|
|
|
// Constructors.
|
|
//
|
|
ChkLongitudinal (const Id_type&,
|
|
const Name_type&,
|
|
const L_type&,
|
|
const A_type&,
|
|
const I_type&,
|
|
const Kmat_type&,
|
|
const ReH_type&);
|
|
|
|
ChkLongitudinal (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ChkLongitudinal (const ChkLongitudinal& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ChkLongitudinal*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ChkLongitudinal&
|
|
operator= (const ChkLongitudinal& x);
|
|
|
|
virtual
|
|
~ChkLongitudinal ();
|
|
|
|
// 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< Name_type > Name_;
|
|
Z_optional Z_;
|
|
Model_optional Model_;
|
|
::xsd::cxx::tree::one< L_type > L_;
|
|
::xsd::cxx::tree::one< A_type > A_;
|
|
::xsd::cxx::tree::one< I_type > I_;
|
|
RoomType_optional RoomType_;
|
|
AttachedPlate_optional AttachedPlate_;
|
|
TypeMat_optional TypeMat_;
|
|
static const TypeMat_type TypeMat_default_value_;
|
|
::xsd::cxx::tree::one< Kmat_type > Kmat_;
|
|
::xsd::cxx::tree::one< ReH_type > ReH_;
|
|
SecNodeId_optional SecNodeId_;
|
|
SecId_optional SecId_;
|
|
};
|
|
|
|
class StaticLoad: 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);
|
|
|
|
// Type
|
|
//
|
|
typedef ::xml_schema::string 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);
|
|
|
|
void
|
|
Type (::std::unique_ptr< Type_type > p);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
StaticLoad (const CaseId_type&,
|
|
const Type_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
StaticLoad (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
StaticLoad (const StaticLoad& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual StaticLoad*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
StaticLoad&
|
|
operator= (const StaticLoad& x);
|
|
|
|
virtual
|
|
~StaticLoad ();
|
|
|
|
// 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< Type_type > Type_;
|
|
::xsd::cxx::tree::one< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class AllowLoad: 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);
|
|
|
|
// Type
|
|
//
|
|
typedef ::xml_schema::string 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);
|
|
|
|
void
|
|
Type (::std::unique_ptr< Type_type > p);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
AllowLoad (const CaseId_type&,
|
|
const Type_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
AllowLoad (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
AllowLoad (const AllowLoad& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual AllowLoad*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
AllowLoad&
|
|
operator= (const AllowLoad& x);
|
|
|
|
virtual
|
|
~AllowLoad ();
|
|
|
|
// 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< Type_type > Type_;
|
|
::xsd::cxx::tree::one< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class AddtionalLoad: 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);
|
|
|
|
// St0
|
|
//
|
|
typedef ::xml_schema::double_ St0_type;
|
|
typedef ::xsd::cxx::tree::traits< St0_type, char, ::xsd::cxx::tree::schema_type::double_ > St0_traits;
|
|
|
|
const St0_type&
|
|
St0 () const;
|
|
|
|
St0_type&
|
|
St0 ();
|
|
|
|
void
|
|
St0 (const St0_type& x);
|
|
|
|
static St0_type
|
|
St0_default_value ();
|
|
|
|
// St1
|
|
//
|
|
typedef ::xml_schema::double_ St1_type;
|
|
typedef ::xsd::cxx::tree::traits< St1_type, char, ::xsd::cxx::tree::schema_type::double_ > St1_traits;
|
|
|
|
const St1_type&
|
|
St1 () const;
|
|
|
|
St1_type&
|
|
St1 ();
|
|
|
|
void
|
|
St1 (const St1_type& x);
|
|
|
|
static St1_type
|
|
St1_default_value ();
|
|
|
|
// St2
|
|
//
|
|
typedef ::xml_schema::double_ St2_type;
|
|
typedef ::xsd::cxx::tree::traits< St2_type, char, ::xsd::cxx::tree::schema_type::double_ > St2_traits;
|
|
|
|
const St2_type&
|
|
St2 () const;
|
|
|
|
St2_type&
|
|
St2 ();
|
|
|
|
void
|
|
St2 (const St2_type& x);
|
|
|
|
static St2_type
|
|
St2_default_value ();
|
|
|
|
// St3
|
|
//
|
|
typedef ::xml_schema::double_ St3_type;
|
|
typedef ::xsd::cxx::tree::traits< St3_type, char, ::xsd::cxx::tree::schema_type::double_ > St3_traits;
|
|
|
|
const St3_type&
|
|
St3 () const;
|
|
|
|
St3_type&
|
|
St3 ();
|
|
|
|
void
|
|
St3 (const St3_type& x);
|
|
|
|
static St3_type
|
|
St3_default_value ();
|
|
|
|
// St4
|
|
//
|
|
typedef ::xml_schema::double_ St4_type;
|
|
typedef ::xsd::cxx::tree::traits< St4_type, char, ::xsd::cxx::tree::schema_type::double_ > St4_traits;
|
|
|
|
const St4_type&
|
|
St4 () const;
|
|
|
|
St4_type&
|
|
St4 ();
|
|
|
|
void
|
|
St4 (const St4_type& x);
|
|
|
|
static St4_type
|
|
St4_default_value ();
|
|
|
|
// St5
|
|
//
|
|
typedef ::xml_schema::double_ St5_type;
|
|
typedef ::xsd::cxx::tree::traits< St5_type, char, ::xsd::cxx::tree::schema_type::double_ > St5_traits;
|
|
|
|
const St5_type&
|
|
St5 () const;
|
|
|
|
St5_type&
|
|
St5 ();
|
|
|
|
void
|
|
St5 (const St5_type& x);
|
|
|
|
static St5_type
|
|
St5_default_value ();
|
|
|
|
// St6
|
|
//
|
|
typedef ::xml_schema::double_ St6_type;
|
|
typedef ::xsd::cxx::tree::traits< St6_type, char, ::xsd::cxx::tree::schema_type::double_ > St6_traits;
|
|
|
|
const St6_type&
|
|
St6 () const;
|
|
|
|
St6_type&
|
|
St6 ();
|
|
|
|
void
|
|
St6 (const St6_type& x);
|
|
|
|
static St6_type
|
|
St6_default_value ();
|
|
|
|
// St7
|
|
//
|
|
typedef ::xml_schema::double_ St7_type;
|
|
typedef ::xsd::cxx::tree::traits< St7_type, char, ::xsd::cxx::tree::schema_type::double_ > St7_traits;
|
|
|
|
const St7_type&
|
|
St7 () const;
|
|
|
|
St7_type&
|
|
St7 ();
|
|
|
|
void
|
|
St7 (const St7_type& x);
|
|
|
|
static St7_type
|
|
St7_default_value ();
|
|
|
|
// St8
|
|
//
|
|
typedef ::xml_schema::double_ St8_type;
|
|
typedef ::xsd::cxx::tree::traits< St8_type, char, ::xsd::cxx::tree::schema_type::double_ > St8_traits;
|
|
|
|
const St8_type&
|
|
St8 () const;
|
|
|
|
St8_type&
|
|
St8 ();
|
|
|
|
void
|
|
St8 (const St8_type& x);
|
|
|
|
static St8_type
|
|
St8_default_value ();
|
|
|
|
// St9
|
|
//
|
|
typedef ::xml_schema::double_ St9_type;
|
|
typedef ::xsd::cxx::tree::traits< St9_type, char, ::xsd::cxx::tree::schema_type::double_ > St9_traits;
|
|
|
|
const St9_type&
|
|
St9 () const;
|
|
|
|
St9_type&
|
|
St9 ();
|
|
|
|
void
|
|
St9 (const St9_type& x);
|
|
|
|
static St9_type
|
|
St9_default_value ();
|
|
|
|
// St10
|
|
//
|
|
typedef ::xml_schema::double_ St10_type;
|
|
typedef ::xsd::cxx::tree::traits< St10_type, char, ::xsd::cxx::tree::schema_type::double_ > St10_traits;
|
|
|
|
const St10_type&
|
|
St10 () const;
|
|
|
|
St10_type&
|
|
St10 ();
|
|
|
|
void
|
|
St10 (const St10_type& x);
|
|
|
|
static St10_type
|
|
St10_default_value ();
|
|
|
|
// St11
|
|
//
|
|
typedef ::xml_schema::double_ St11_type;
|
|
typedef ::xsd::cxx::tree::traits< St11_type, char, ::xsd::cxx::tree::schema_type::double_ > St11_traits;
|
|
|
|
const St11_type&
|
|
St11 () const;
|
|
|
|
St11_type&
|
|
St11 ();
|
|
|
|
void
|
|
St11 (const St11_type& x);
|
|
|
|
static St11_type
|
|
St11_default_value ();
|
|
|
|
// St12
|
|
//
|
|
typedef ::xml_schema::double_ St12_type;
|
|
typedef ::xsd::cxx::tree::traits< St12_type, char, ::xsd::cxx::tree::schema_type::double_ > St12_traits;
|
|
|
|
const St12_type&
|
|
St12 () const;
|
|
|
|
St12_type&
|
|
St12 ();
|
|
|
|
void
|
|
St12 (const St12_type& x);
|
|
|
|
static St12_type
|
|
St12_default_value ();
|
|
|
|
// St13
|
|
//
|
|
typedef ::xml_schema::double_ St13_type;
|
|
typedef ::xsd::cxx::tree::traits< St13_type, char, ::xsd::cxx::tree::schema_type::double_ > St13_traits;
|
|
|
|
const St13_type&
|
|
St13 () const;
|
|
|
|
St13_type&
|
|
St13 ();
|
|
|
|
void
|
|
St13 (const St13_type& x);
|
|
|
|
static St13_type
|
|
St13_default_value ();
|
|
|
|
// St14
|
|
//
|
|
typedef ::xml_schema::double_ St14_type;
|
|
typedef ::xsd::cxx::tree::traits< St14_type, char, ::xsd::cxx::tree::schema_type::double_ > St14_traits;
|
|
|
|
const St14_type&
|
|
St14 () const;
|
|
|
|
St14_type&
|
|
St14 ();
|
|
|
|
void
|
|
St14 (const St14_type& x);
|
|
|
|
static St14_type
|
|
St14_default_value ();
|
|
|
|
// St15
|
|
//
|
|
typedef ::xml_schema::double_ St15_type;
|
|
typedef ::xsd::cxx::tree::traits< St15_type, char, ::xsd::cxx::tree::schema_type::double_ > St15_traits;
|
|
|
|
const St15_type&
|
|
St15 () const;
|
|
|
|
St15_type&
|
|
St15 ();
|
|
|
|
void
|
|
St15 (const St15_type& x);
|
|
|
|
static St15_type
|
|
St15_default_value ();
|
|
|
|
// St16
|
|
//
|
|
typedef ::xml_schema::double_ St16_type;
|
|
typedef ::xsd::cxx::tree::traits< St16_type, char, ::xsd::cxx::tree::schema_type::double_ > St16_traits;
|
|
|
|
const St16_type&
|
|
St16 () const;
|
|
|
|
St16_type&
|
|
St16 ();
|
|
|
|
void
|
|
St16 (const St16_type& x);
|
|
|
|
static St16_type
|
|
St16_default_value ();
|
|
|
|
// St17
|
|
//
|
|
typedef ::xml_schema::double_ St17_type;
|
|
typedef ::xsd::cxx::tree::traits< St17_type, char, ::xsd::cxx::tree::schema_type::double_ > St17_traits;
|
|
|
|
const St17_type&
|
|
St17 () const;
|
|
|
|
St17_type&
|
|
St17 ();
|
|
|
|
void
|
|
St17 (const St17_type& x);
|
|
|
|
static St17_type
|
|
St17_default_value ();
|
|
|
|
// St18
|
|
//
|
|
typedef ::xml_schema::double_ St18_type;
|
|
typedef ::xsd::cxx::tree::traits< St18_type, char, ::xsd::cxx::tree::schema_type::double_ > St18_traits;
|
|
|
|
const St18_type&
|
|
St18 () const;
|
|
|
|
St18_type&
|
|
St18 ();
|
|
|
|
void
|
|
St18 (const St18_type& x);
|
|
|
|
static St18_type
|
|
St18_default_value ();
|
|
|
|
// St19
|
|
//
|
|
typedef ::xml_schema::double_ St19_type;
|
|
typedef ::xsd::cxx::tree::traits< St19_type, char, ::xsd::cxx::tree::schema_type::double_ > St19_traits;
|
|
|
|
const St19_type&
|
|
St19 () const;
|
|
|
|
St19_type&
|
|
St19 ();
|
|
|
|
void
|
|
St19 (const St19_type& x);
|
|
|
|
static St19_type
|
|
St19_default_value ();
|
|
|
|
// St20
|
|
//
|
|
typedef ::xml_schema::double_ St20_type;
|
|
typedef ::xsd::cxx::tree::traits< St20_type, char, ::xsd::cxx::tree::schema_type::double_ > St20_traits;
|
|
|
|
const St20_type&
|
|
St20 () const;
|
|
|
|
St20_type&
|
|
St20 ();
|
|
|
|
void
|
|
St20 (const St20_type& x);
|
|
|
|
static St20_type
|
|
St20_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
AddtionalLoad (const CaseId_type&,
|
|
const St0_type&,
|
|
const St1_type&,
|
|
const St2_type&,
|
|
const St3_type&,
|
|
const St4_type&,
|
|
const St5_type&,
|
|
const St6_type&,
|
|
const St7_type&,
|
|
const St8_type&,
|
|
const St9_type&,
|
|
const St10_type&,
|
|
const St11_type&,
|
|
const St12_type&,
|
|
const St13_type&,
|
|
const St14_type&,
|
|
const St15_type&,
|
|
const St16_type&,
|
|
const St17_type&,
|
|
const St18_type&,
|
|
const St19_type&,
|
|
const St20_type&);
|
|
|
|
AddtionalLoad (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
AddtionalLoad (const AddtionalLoad& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual AddtionalLoad*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
AddtionalLoad&
|
|
operator= (const AddtionalLoad& x);
|
|
|
|
virtual
|
|
~AddtionalLoad ();
|
|
|
|
// 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< St0_type > St0_;
|
|
::xsd::cxx::tree::one< St1_type > St1_;
|
|
::xsd::cxx::tree::one< St2_type > St2_;
|
|
::xsd::cxx::tree::one< St3_type > St3_;
|
|
::xsd::cxx::tree::one< St4_type > St4_;
|
|
::xsd::cxx::tree::one< St5_type > St5_;
|
|
::xsd::cxx::tree::one< St6_type > St6_;
|
|
::xsd::cxx::tree::one< St7_type > St7_;
|
|
::xsd::cxx::tree::one< St8_type > St8_;
|
|
::xsd::cxx::tree::one< St9_type > St9_;
|
|
::xsd::cxx::tree::one< St10_type > St10_;
|
|
::xsd::cxx::tree::one< St11_type > St11_;
|
|
::xsd::cxx::tree::one< St12_type > St12_;
|
|
::xsd::cxx::tree::one< St13_type > St13_;
|
|
::xsd::cxx::tree::one< St14_type > St14_;
|
|
::xsd::cxx::tree::one< St15_type > St15_;
|
|
::xsd::cxx::tree::one< St16_type > St16_;
|
|
::xsd::cxx::tree::one< St17_type > St17_;
|
|
::xsd::cxx::tree::one< St18_type > St18_;
|
|
::xsd::cxx::tree::one< St19_type > St19_;
|
|
::xsd::cxx::tree::one< St20_type > St20_;
|
|
};
|
|
|
|
class ProjectInfo: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// ShipName
|
|
//
|
|
typedef ::xml_schema::string ShipName_type;
|
|
typedef ::xsd::cxx::tree::optional< ShipName_type > ShipName_optional;
|
|
typedef ::xsd::cxx::tree::traits< ShipName_type, char > ShipName_traits;
|
|
|
|
const ShipName_optional&
|
|
ShipName () const;
|
|
|
|
ShipName_optional&
|
|
ShipName ();
|
|
|
|
void
|
|
ShipName (const ShipName_type& x);
|
|
|
|
void
|
|
ShipName (const ShipName_optional& x);
|
|
|
|
void
|
|
ShipName (::std::unique_ptr< ShipName_type > p);
|
|
|
|
// Designer
|
|
//
|
|
typedef ::xml_schema::string Designer_type;
|
|
typedef ::xsd::cxx::tree::optional< Designer_type > Designer_optional;
|
|
typedef ::xsd::cxx::tree::traits< Designer_type, char > Designer_traits;
|
|
|
|
const Designer_optional&
|
|
Designer () const;
|
|
|
|
Designer_optional&
|
|
Designer ();
|
|
|
|
void
|
|
Designer (const Designer_type& x);
|
|
|
|
void
|
|
Designer (const Designer_optional& x);
|
|
|
|
void
|
|
Designer (::std::unique_ptr< Designer_type > p);
|
|
|
|
// WorkNo
|
|
//
|
|
typedef ::xml_schema::string WorkNo_type;
|
|
typedef ::xsd::cxx::tree::optional< WorkNo_type > WorkNo_optional;
|
|
typedef ::xsd::cxx::tree::traits< WorkNo_type, char > WorkNo_traits;
|
|
|
|
const WorkNo_optional&
|
|
WorkNo () const;
|
|
|
|
WorkNo_optional&
|
|
WorkNo ();
|
|
|
|
void
|
|
WorkNo (const WorkNo_type& x);
|
|
|
|
void
|
|
WorkNo (const WorkNo_optional& x);
|
|
|
|
void
|
|
WorkNo (::std::unique_ptr< WorkNo_type > p);
|
|
|
|
// Signature
|
|
//
|
|
typedef ::xml_schema::string Signature_type;
|
|
typedef ::xsd::cxx::tree::optional< Signature_type > Signature_optional;
|
|
typedef ::xsd::cxx::tree::traits< Signature_type, char > Signature_traits;
|
|
|
|
const Signature_optional&
|
|
Signature () const;
|
|
|
|
Signature_optional&
|
|
Signature ();
|
|
|
|
void
|
|
Signature (const Signature_type& x);
|
|
|
|
void
|
|
Signature (const Signature_optional& x);
|
|
|
|
void
|
|
Signature (::std::unique_ptr< Signature_type > p);
|
|
|
|
// Owner
|
|
//
|
|
typedef ::xml_schema::string Owner_type;
|
|
typedef ::xsd::cxx::tree::optional< Owner_type > Owner_optional;
|
|
typedef ::xsd::cxx::tree::traits< Owner_type, char > Owner_traits;
|
|
|
|
const Owner_optional&
|
|
Owner () const;
|
|
|
|
Owner_optional&
|
|
Owner ();
|
|
|
|
void
|
|
Owner (const Owner_type& x);
|
|
|
|
void
|
|
Owner (const Owner_optional& x);
|
|
|
|
void
|
|
Owner (::std::unique_ptr< Owner_type > p);
|
|
|
|
// CalDate
|
|
//
|
|
typedef ::xml_schema::string CalDate_type;
|
|
typedef ::xsd::cxx::tree::optional< CalDate_type > CalDate_optional;
|
|
typedef ::xsd::cxx::tree::traits< CalDate_type, char > CalDate_traits;
|
|
|
|
const CalDate_optional&
|
|
CalDate () const;
|
|
|
|
CalDate_optional&
|
|
CalDate ();
|
|
|
|
void
|
|
CalDate (const CalDate_type& x);
|
|
|
|
void
|
|
CalDate (const CalDate_optional& x);
|
|
|
|
void
|
|
CalDate (::std::unique_ptr< CalDate_type > p);
|
|
|
|
// Constructors.
|
|
//
|
|
ProjectInfo ();
|
|
|
|
ProjectInfo (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
ProjectInfo (const ProjectInfo& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual ProjectInfo*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
ProjectInfo&
|
|
operator= (const ProjectInfo& x);
|
|
|
|
virtual
|
|
~ProjectInfo ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
ShipName_optional ShipName_;
|
|
Designer_optional Designer_;
|
|
WorkNo_optional WorkNo_;
|
|
Signature_optional Signature_;
|
|
Owner_optional Owner_;
|
|
CalDate_optional CalDate_;
|
|
};
|
|
|
|
class Pub: public ::xml_schema::type
|
|
{
|
|
public:
|
|
// CrRule
|
|
//
|
|
typedef ::xml_schema::int_ CrRule_type;
|
|
typedef ::xsd::cxx::tree::optional< CrRule_type > CrRule_optional;
|
|
typedef ::xsd::cxx::tree::traits< CrRule_type, char > CrRule_traits;
|
|
|
|
const CrRule_optional&
|
|
CrRule () const;
|
|
|
|
CrRule_optional&
|
|
CrRule ();
|
|
|
|
void
|
|
CrRule (const CrRule_type& x);
|
|
|
|
void
|
|
CrRule (const CrRule_optional& x);
|
|
|
|
static CrRule_type
|
|
CrRule_default_value ();
|
|
|
|
// ShipType
|
|
//
|
|
typedef ::xml_schema::string 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);
|
|
|
|
void
|
|
ShipType (::std::unique_ptr< ShipType_type > p);
|
|
|
|
// NavArea
|
|
//
|
|
typedef ::xml_schema::string NavArea_type;
|
|
typedef ::xsd::cxx::tree::optional< NavArea_type > NavArea_optional;
|
|
typedef ::xsd::cxx::tree::traits< NavArea_type, char > NavArea_traits;
|
|
|
|
const NavArea_optional&
|
|
NavArea () const;
|
|
|
|
NavArea_optional&
|
|
NavArea ();
|
|
|
|
void
|
|
NavArea (const NavArea_type& x);
|
|
|
|
void
|
|
NavArea (const NavArea_optional& x);
|
|
|
|
void
|
|
NavArea (::std::unique_ptr< NavArea_type > p);
|
|
|
|
// NavReach
|
|
//
|
|
typedef ::xml_schema::string NavReach_type;
|
|
typedef ::xsd::cxx::tree::optional< NavReach_type > NavReach_optional;
|
|
typedef ::xsd::cxx::tree::traits< NavReach_type, char > NavReach_traits;
|
|
|
|
const NavReach_optional&
|
|
NavReach () const;
|
|
|
|
NavReach_optional&
|
|
NavReach ();
|
|
|
|
void
|
|
NavReach (const NavReach_type& x);
|
|
|
|
void
|
|
NavReach (const NavReach_optional& x);
|
|
|
|
void
|
|
NavReach (::std::unique_ptr< NavReach_type > p);
|
|
|
|
// Lpp
|
|
//
|
|
typedef ::xml_schema::double_ Lpp_type;
|
|
typedef ::xsd::cxx::tree::optional< Lpp_type > Lpp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Lpp_type, char, ::xsd::cxx::tree::schema_type::double_ > Lpp_traits;
|
|
|
|
const Lpp_optional&
|
|
Lpp () const;
|
|
|
|
Lpp_optional&
|
|
Lpp ();
|
|
|
|
void
|
|
Lpp (const Lpp_type& x);
|
|
|
|
void
|
|
Lpp (const Lpp_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);
|
|
|
|
// 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);
|
|
|
|
// dmax
|
|
//
|
|
typedef ::xml_schema::double_ dmax_type;
|
|
typedef ::xsd::cxx::tree::optional< dmax_type > dmax_optional;
|
|
typedef ::xsd::cxx::tree::traits< dmax_type, char, ::xsd::cxx::tree::schema_type::double_ > dmax_traits;
|
|
|
|
const dmax_optional&
|
|
dmax () const;
|
|
|
|
dmax_optional&
|
|
dmax ();
|
|
|
|
void
|
|
dmax (const dmax_type& x);
|
|
|
|
void
|
|
dmax (const dmax_optional& x);
|
|
|
|
// Cb
|
|
//
|
|
typedef ::xml_schema::double_ Cb_type;
|
|
typedef ::xsd::cxx::tree::optional< Cb_type > Cb_optional;
|
|
typedef ::xsd::cxx::tree::traits< Cb_type, char, ::xsd::cxx::tree::schema_type::double_ > Cb_traits;
|
|
|
|
const Cb_optional&
|
|
Cb () const;
|
|
|
|
Cb_optional&
|
|
Cb ();
|
|
|
|
void
|
|
Cb (const Cb_type& x);
|
|
|
|
void
|
|
Cb (const Cb_optional& x);
|
|
|
|
// SuperStruct
|
|
//
|
|
typedef ::xml_schema::boolean SuperStruct_type;
|
|
typedef ::xsd::cxx::tree::optional< SuperStruct_type > SuperStruct_optional;
|
|
typedef ::xsd::cxx::tree::traits< SuperStruct_type, char > SuperStruct_traits;
|
|
|
|
const SuperStruct_optional&
|
|
SuperStruct () const;
|
|
|
|
SuperStruct_optional&
|
|
SuperStruct ();
|
|
|
|
void
|
|
SuperStruct (const SuperStruct_type& x);
|
|
|
|
void
|
|
SuperStruct (const SuperStruct_optional& x);
|
|
|
|
static SuperStruct_type
|
|
SuperStruct_default_value ();
|
|
|
|
// DoubleDeck
|
|
//
|
|
typedef ::xml_schema::boolean DoubleDeck_type;
|
|
typedef ::xsd::cxx::tree::optional< DoubleDeck_type > DoubleDeck_optional;
|
|
typedef ::xsd::cxx::tree::traits< DoubleDeck_type, char > DoubleDeck_traits;
|
|
|
|
const DoubleDeck_optional&
|
|
DoubleDeck () const;
|
|
|
|
DoubleDeck_optional&
|
|
DoubleDeck ();
|
|
|
|
void
|
|
DoubleDeck (const DoubleDeck_type& x);
|
|
|
|
void
|
|
DoubleDeck (const DoubleDeck_optional& x);
|
|
|
|
static DoubleDeck_type
|
|
DoubleDeck_default_value ();
|
|
|
|
// a
|
|
//
|
|
typedef ::xml_schema::double_ a_type;
|
|
typedef ::xsd::cxx::tree::optional< a_type > a_optional;
|
|
typedef ::xsd::cxx::tree::traits< a_type, char, ::xsd::cxx::tree::schema_type::double_ > a_traits;
|
|
|
|
const a_optional&
|
|
a () const;
|
|
|
|
a_optional&
|
|
a ();
|
|
|
|
void
|
|
a (const a_type& x);
|
|
|
|
void
|
|
a (const a_optional& x);
|
|
|
|
static a_type
|
|
a_default_value ();
|
|
|
|
// 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);
|
|
|
|
static y_type
|
|
y_default_value ();
|
|
|
|
// yd
|
|
//
|
|
typedef ::xml_schema::double_ yd_type;
|
|
typedef ::xsd::cxx::tree::optional< yd_type > yd_optional;
|
|
typedef ::xsd::cxx::tree::traits< yd_type, char, ::xsd::cxx::tree::schema_type::double_ > yd_traits;
|
|
|
|
const yd_optional&
|
|
yd () const;
|
|
|
|
yd_optional&
|
|
yd ();
|
|
|
|
void
|
|
yd (const yd_type& x);
|
|
|
|
void
|
|
yd (const yd_optional& x);
|
|
|
|
static yd_type
|
|
yd_default_value ();
|
|
|
|
// SigmaDeck
|
|
//
|
|
typedef ::xml_schema::string SigmaDeck_type;
|
|
typedef ::xsd::cxx::tree::optional< SigmaDeck_type > SigmaDeck_optional;
|
|
typedef ::xsd::cxx::tree::traits< SigmaDeck_type, char > SigmaDeck_traits;
|
|
|
|
const SigmaDeck_optional&
|
|
SigmaDeck () const;
|
|
|
|
SigmaDeck_optional&
|
|
SigmaDeck ();
|
|
|
|
void
|
|
SigmaDeck (const SigmaDeck_type& x);
|
|
|
|
void
|
|
SigmaDeck (const SigmaDeck_optional& x);
|
|
|
|
void
|
|
SigmaDeck (::std::unique_ptr< SigmaDeck_type > p);
|
|
|
|
// SigmaBottom
|
|
//
|
|
typedef ::xml_schema::string SigmaBottom_type;
|
|
typedef ::xsd::cxx::tree::optional< SigmaBottom_type > SigmaBottom_optional;
|
|
typedef ::xsd::cxx::tree::traits< SigmaBottom_type, char > SigmaBottom_traits;
|
|
|
|
const SigmaBottom_optional&
|
|
SigmaBottom () const;
|
|
|
|
SigmaBottom_optional&
|
|
SigmaBottom ();
|
|
|
|
void
|
|
SigmaBottom (const SigmaBottom_type& x);
|
|
|
|
void
|
|
SigmaBottom (const SigmaBottom_optional& x);
|
|
|
|
void
|
|
SigmaBottom (::std::unique_ptr< SigmaBottom_type > p);
|
|
|
|
// OpenType
|
|
//
|
|
typedef ::xml_schema::string OpenType_type;
|
|
typedef ::xsd::cxx::tree::optional< OpenType_type > OpenType_optional;
|
|
typedef ::xsd::cxx::tree::traits< OpenType_type, char > OpenType_traits;
|
|
|
|
const OpenType_optional&
|
|
OpenType () const;
|
|
|
|
OpenType_optional&
|
|
OpenType ();
|
|
|
|
void
|
|
OpenType (const OpenType_type& x);
|
|
|
|
void
|
|
OpenType (const OpenType_optional& x);
|
|
|
|
void
|
|
OpenType (::std::unique_ptr< OpenType_type > p);
|
|
|
|
// HatchCoam
|
|
//
|
|
typedef ::xml_schema::boolean HatchCoam_type;
|
|
typedef ::xsd::cxx::tree::optional< HatchCoam_type > HatchCoam_optional;
|
|
typedef ::xsd::cxx::tree::traits< HatchCoam_type, char > HatchCoam_traits;
|
|
|
|
const HatchCoam_optional&
|
|
HatchCoam () const;
|
|
|
|
HatchCoam_optional&
|
|
HatchCoam ();
|
|
|
|
void
|
|
HatchCoam (const HatchCoam_type& x);
|
|
|
|
void
|
|
HatchCoam (const HatchCoam_optional& x);
|
|
|
|
// Torsion
|
|
//
|
|
typedef ::xml_schema::boolean Torsion_type;
|
|
typedef ::xsd::cxx::tree::optional< Torsion_type > Torsion_optional;
|
|
typedef ::xsd::cxx::tree::traits< Torsion_type, char > Torsion_traits;
|
|
|
|
const Torsion_optional&
|
|
Torsion () const;
|
|
|
|
Torsion_optional&
|
|
Torsion ();
|
|
|
|
void
|
|
Torsion (const Torsion_type& x);
|
|
|
|
void
|
|
Torsion (const Torsion_optional& x);
|
|
|
|
// HatchBoard
|
|
//
|
|
typedef ::xml_schema::boolean HatchBoard_type;
|
|
typedef ::xsd::cxx::tree::optional< HatchBoard_type > HatchBoard_optional;
|
|
typedef ::xsd::cxx::tree::traits< HatchBoard_type, char > HatchBoard_traits;
|
|
|
|
const HatchBoard_optional&
|
|
HatchBoard () const;
|
|
|
|
HatchBoard_optional&
|
|
HatchBoard ();
|
|
|
|
void
|
|
HatchBoard (const HatchBoard_type& x);
|
|
|
|
void
|
|
HatchBoard (const HatchBoard_optional& x);
|
|
|
|
static HatchBoard_type
|
|
HatchBoard_default_value ();
|
|
|
|
// Gama
|
|
//
|
|
typedef ::xml_schema::double_ Gama_type;
|
|
typedef ::xsd::cxx::tree::optional< Gama_type > Gama_optional;
|
|
typedef ::xsd::cxx::tree::traits< Gama_type, char, ::xsd::cxx::tree::schema_type::double_ > Gama_traits;
|
|
|
|
const Gama_optional&
|
|
Gama () const;
|
|
|
|
Gama_optional&
|
|
Gama ();
|
|
|
|
void
|
|
Gama (const Gama_type& x);
|
|
|
|
void
|
|
Gama (const Gama_optional& x);
|
|
|
|
static Gama_type
|
|
Gama_default_value ();
|
|
|
|
// HatchWidth
|
|
//
|
|
typedef ::xml_schema::double_ HatchWidth_type;
|
|
typedef ::xsd::cxx::tree::optional< HatchWidth_type > HatchWidth_optional;
|
|
typedef ::xsd::cxx::tree::traits< HatchWidth_type, char, ::xsd::cxx::tree::schema_type::double_ > HatchWidth_traits;
|
|
|
|
const HatchWidth_optional&
|
|
HatchWidth () const;
|
|
|
|
HatchWidth_optional&
|
|
HatchWidth ();
|
|
|
|
void
|
|
HatchWidth (const HatchWidth_type& x);
|
|
|
|
void
|
|
HatchWidth (const HatchWidth_optional& x);
|
|
|
|
static HatchWidth_type
|
|
HatchWidth_default_value ();
|
|
|
|
// HatchLength
|
|
//
|
|
typedef ::xml_schema::double_ HatchLength_type;
|
|
typedef ::xsd::cxx::tree::optional< HatchLength_type > HatchLength_optional;
|
|
typedef ::xsd::cxx::tree::traits< HatchLength_type, char, ::xsd::cxx::tree::schema_type::double_ > HatchLength_traits;
|
|
|
|
const HatchLength_optional&
|
|
HatchLength () const;
|
|
|
|
HatchLength_optional&
|
|
HatchLength ();
|
|
|
|
void
|
|
HatchLength (const HatchLength_type& x);
|
|
|
|
void
|
|
HatchLength (const HatchLength_optional& x);
|
|
|
|
static HatchLength_type
|
|
HatchLength_default_value ();
|
|
|
|
// BulkheadSpace
|
|
//
|
|
typedef ::xml_schema::double_ BulkheadSpace_type;
|
|
typedef ::xsd::cxx::tree::optional< BulkheadSpace_type > BulkheadSpace_optional;
|
|
typedef ::xsd::cxx::tree::traits< BulkheadSpace_type, char, ::xsd::cxx::tree::schema_type::double_ > BulkheadSpace_traits;
|
|
|
|
const BulkheadSpace_optional&
|
|
BulkheadSpace () const;
|
|
|
|
BulkheadSpace_optional&
|
|
BulkheadSpace ();
|
|
|
|
void
|
|
BulkheadSpace (const BulkheadSpace_type& x);
|
|
|
|
void
|
|
BulkheadSpace (const BulkheadSpace_optional& x);
|
|
|
|
static BulkheadSpace_type
|
|
BulkheadSpace_default_value ();
|
|
|
|
// LiftedCargo
|
|
//
|
|
typedef ::xml_schema::boolean LiftedCargo_type;
|
|
typedef ::xsd::cxx::tree::optional< LiftedCargo_type > LiftedCargo_optional;
|
|
typedef ::xsd::cxx::tree::traits< LiftedCargo_type, char > LiftedCargo_traits;
|
|
|
|
const LiftedCargo_optional&
|
|
LiftedCargo () const;
|
|
|
|
LiftedCargo_optional&
|
|
LiftedCargo ();
|
|
|
|
void
|
|
LiftedCargo (const LiftedCargo_type& x);
|
|
|
|
void
|
|
LiftedCargo (const LiftedCargo_optional& x);
|
|
|
|
static LiftedCargo_type
|
|
LiftedCargo_default_value ();
|
|
|
|
// 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);
|
|
|
|
static P_type
|
|
P_default_value ();
|
|
|
|
// l0
|
|
//
|
|
typedef ::xml_schema::double_ l0_type;
|
|
typedef ::xsd::cxx::tree::optional< l0_type > l0_optional;
|
|
typedef ::xsd::cxx::tree::traits< l0_type, char, ::xsd::cxx::tree::schema_type::double_ > l0_traits;
|
|
|
|
const l0_optional&
|
|
l0 () const;
|
|
|
|
l0_optional&
|
|
l0 ();
|
|
|
|
void
|
|
l0 (const l0_type& x);
|
|
|
|
void
|
|
l0 (const l0_optional& x);
|
|
|
|
static l0_type
|
|
l0_default_value ();
|
|
|
|
// Shore
|
|
//
|
|
typedef ::xml_schema::boolean Shore_type;
|
|
typedef ::xsd::cxx::tree::optional< Shore_type > Shore_optional;
|
|
typedef ::xsd::cxx::tree::traits< Shore_type, char > Shore_traits;
|
|
|
|
const Shore_optional&
|
|
Shore () const;
|
|
|
|
Shore_optional&
|
|
Shore ();
|
|
|
|
void
|
|
Shore (const Shore_type& x);
|
|
|
|
void
|
|
Shore (const Shore_optional& x);
|
|
|
|
static Shore_type
|
|
Shore_default_value ();
|
|
|
|
// Disp
|
|
//
|
|
typedef ::xml_schema::double_ Disp_type;
|
|
typedef ::xsd::cxx::tree::optional< Disp_type > Disp_optional;
|
|
typedef ::xsd::cxx::tree::traits< Disp_type, char, ::xsd::cxx::tree::schema_type::double_ > Disp_traits;
|
|
|
|
const Disp_optional&
|
|
Disp () const;
|
|
|
|
Disp_optional&
|
|
Disp ();
|
|
|
|
void
|
|
Disp (const Disp_type& x);
|
|
|
|
void
|
|
Disp (const Disp_optional& x);
|
|
|
|
static Disp_type
|
|
Disp_default_value ();
|
|
|
|
// CargoLoad
|
|
//
|
|
typedef ::xml_schema::double_ CargoLoad_type;
|
|
typedef ::xsd::cxx::tree::optional< CargoLoad_type > CargoLoad_optional;
|
|
typedef ::xsd::cxx::tree::traits< CargoLoad_type, char, ::xsd::cxx::tree::schema_type::double_ > CargoLoad_traits;
|
|
|
|
const CargoLoad_optional&
|
|
CargoLoad () const;
|
|
|
|
CargoLoad_optional&
|
|
CargoLoad ();
|
|
|
|
void
|
|
CargoLoad (const CargoLoad_type& x);
|
|
|
|
void
|
|
CargoLoad (const CargoLoad_optional& x);
|
|
|
|
static CargoLoad_type
|
|
CargoLoad_default_value ();
|
|
|
|
// SuperStructCoef
|
|
//
|
|
typedef ::xml_schema::double_ SuperStructCoef_type;
|
|
typedef ::xsd::cxx::tree::optional< SuperStructCoef_type > SuperStructCoef_optional;
|
|
typedef ::xsd::cxx::tree::traits< SuperStructCoef_type, char, ::xsd::cxx::tree::schema_type::double_ > SuperStructCoef_traits;
|
|
|
|
const SuperStructCoef_optional&
|
|
SuperStructCoef () const;
|
|
|
|
SuperStructCoef_optional&
|
|
SuperStructCoef ();
|
|
|
|
void
|
|
SuperStructCoef (const SuperStructCoef_type& x);
|
|
|
|
void
|
|
SuperStructCoef (const SuperStructCoef_optional& x);
|
|
|
|
// lH
|
|
//
|
|
typedef ::xml_schema::double_ lH_type;
|
|
typedef ::xsd::cxx::tree::optional< lH_type > lH_optional;
|
|
typedef ::xsd::cxx::tree::traits< lH_type, char, ::xsd::cxx::tree::schema_type::double_ > lH_traits;
|
|
|
|
const lH_optional&
|
|
lH () const;
|
|
|
|
lH_optional&
|
|
lH ();
|
|
|
|
void
|
|
lH (const lH_type& x);
|
|
|
|
void
|
|
lH (const lH_optional& x);
|
|
|
|
static lH_type
|
|
lH_default_value ();
|
|
|
|
// SelfNav
|
|
//
|
|
typedef ::xml_schema::boolean SelfNav_type;
|
|
typedef ::xsd::cxx::tree::optional< SelfNav_type > SelfNav_optional;
|
|
typedef ::xsd::cxx::tree::traits< SelfNav_type, char > SelfNav_traits;
|
|
|
|
const SelfNav_optional&
|
|
SelfNav () const;
|
|
|
|
SelfNav_optional&
|
|
SelfNav ();
|
|
|
|
void
|
|
SelfNav (const SelfNav_type& x);
|
|
|
|
void
|
|
SelfNav (const SelfNav_optional& x);
|
|
|
|
static SelfNav_type
|
|
SelfNav_default_value ();
|
|
|
|
// CargoRORO
|
|
//
|
|
typedef ::xml_schema::boolean CargoRORO_type;
|
|
typedef ::xsd::cxx::tree::optional< CargoRORO_type > CargoRORO_optional;
|
|
typedef ::xsd::cxx::tree::traits< CargoRORO_type, char > CargoRORO_traits;
|
|
|
|
const CargoRORO_optional&
|
|
CargoRORO () const;
|
|
|
|
CargoRORO_optional&
|
|
CargoRORO ();
|
|
|
|
void
|
|
CargoRORO (const CargoRORO_type& x);
|
|
|
|
void
|
|
CargoRORO (const CargoRORO_optional& x);
|
|
|
|
static CargoRORO_type
|
|
CargoRORO_default_value ();
|
|
|
|
// BulbousBow
|
|
//
|
|
typedef ::xml_schema::boolean BulbousBow_type;
|
|
typedef ::xsd::cxx::tree::optional< BulbousBow_type > BulbousBow_optional;
|
|
typedef ::xsd::cxx::tree::traits< BulbousBow_type, char > BulbousBow_traits;
|
|
|
|
const BulbousBow_optional&
|
|
BulbousBow () const;
|
|
|
|
BulbousBow_optional&
|
|
BulbousBow ();
|
|
|
|
void
|
|
BulbousBow (const BulbousBow_type& x);
|
|
|
|
void
|
|
BulbousBow (const BulbousBow_optional& x);
|
|
|
|
static BulbousBow_type
|
|
BulbousBow_default_value ();
|
|
|
|
// EvenLoad
|
|
//
|
|
typedef ::xml_schema::boolean EvenLoad_type;
|
|
typedef ::xsd::cxx::tree::optional< EvenLoad_type > EvenLoad_optional;
|
|
typedef ::xsd::cxx::tree::traits< EvenLoad_type, char > EvenLoad_traits;
|
|
|
|
const EvenLoad_optional&
|
|
EvenLoad () const;
|
|
|
|
EvenLoad_optional&
|
|
EvenLoad ();
|
|
|
|
void
|
|
EvenLoad (const EvenLoad_type& x);
|
|
|
|
void
|
|
EvenLoad (const EvenLoad_optional& x);
|
|
|
|
static EvenLoad_type
|
|
EvenLoad_default_value ();
|
|
|
|
// Constructors.
|
|
//
|
|
Pub ();
|
|
|
|
Pub (const ::xercesc::DOMElement& e,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
Pub (const Pub& x,
|
|
::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0);
|
|
|
|
virtual Pub*
|
|
_clone (::xml_schema::flags f = 0,
|
|
::xml_schema::container* c = 0) const;
|
|
|
|
Pub&
|
|
operator= (const Pub& x);
|
|
|
|
virtual
|
|
~Pub ();
|
|
|
|
// Implementation.
|
|
//
|
|
protected:
|
|
void
|
|
parse (::xsd::cxx::xml::dom::parser< char >&,
|
|
::xml_schema::flags);
|
|
|
|
protected:
|
|
CrRule_optional CrRule_;
|
|
ShipType_optional ShipType_;
|
|
NavArea_optional NavArea_;
|
|
NavReach_optional NavReach_;
|
|
Lpp_optional Lpp_;
|
|
L_optional L_;
|
|
B_optional B_;
|
|
D_optional D_;
|
|
dmax_optional dmax_;
|
|
Cb_optional Cb_;
|
|
SuperStruct_optional SuperStruct_;
|
|
DoubleDeck_optional DoubleDeck_;
|
|
a_optional a_;
|
|
y_optional y_;
|
|
yd_optional yd_;
|
|
SigmaDeck_optional SigmaDeck_;
|
|
SigmaBottom_optional SigmaBottom_;
|
|
OpenType_optional OpenType_;
|
|
HatchCoam_optional HatchCoam_;
|
|
Torsion_optional Torsion_;
|
|
HatchBoard_optional HatchBoard_;
|
|
Gama_optional Gama_;
|
|
HatchWidth_optional HatchWidth_;
|
|
HatchLength_optional HatchLength_;
|
|
BulkheadSpace_optional BulkheadSpace_;
|
|
LiftedCargo_optional LiftedCargo_;
|
|
P_optional P_;
|
|
l0_optional l0_;
|
|
Shore_optional Shore_;
|
|
Disp_optional Disp_;
|
|
CargoLoad_optional CargoLoad_;
|
|
SuperStructCoef_optional SuperStructCoef_;
|
|
lH_optional lH_;
|
|
SelfNav_optional SelfNav_;
|
|
CargoRORO_optional CargoRORO_;
|
|
BulbousBow_optional BulbousBow_;
|
|
EvenLoad_optional EvenLoad_;
|
|
};
|
|
}
|
|
|
|
#include <iosfwd>
|
|
|
|
#include <xercesc/sax/InputSource.hpp>
|
|
#include <xercesc/dom/DOMDocument.hpp>
|
|
#include <xercesc/dom/DOMErrorHandler.hpp>
|
|
|
|
namespace strength_set
|
|
{
|
|
// Parse a URI or a local file.
|
|
//
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (const ::std::string& uri,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (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< ::strength_set::StrengthSet >
|
|
StrengthSet_ (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< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::std::istream& is,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::std::istream& is,
|
|
::xml_schema::error_handler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::std::istream& is,
|
|
::xercesc::DOMErrorHandler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::std::istream& is,
|
|
const ::std::string& id,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::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< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::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< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::xercesc::InputSource& is,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::xercesc::InputSource& is,
|
|
::xml_schema::error_handler& eh,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::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< ::strength_set::StrengthSet >
|
|
StrengthSet_ (const ::xercesc::DOMDocument& d,
|
|
::xml_schema::flags f = 0,
|
|
const ::xml_schema::properties& p = ::xml_schema::properties ());
|
|
|
|
::std::unique_ptr< ::strength_set::StrengthSet >
|
|
StrengthSet_ (::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 strength_set
|
|
{
|
|
// Serialize to std::ostream.
|
|
//
|
|
|
|
void
|
|
StrengthSet_ (::std::ostream& os,
|
|
const ::strength_set::StrengthSet& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
const ::std::string& e = "UTF-8",
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
StrengthSet_ (::std::ostream& os,
|
|
const ::strength_set::StrengthSet& 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
|
|
StrengthSet_ (::std::ostream& os,
|
|
const ::strength_set::StrengthSet& 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
|
|
StrengthSet_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::strength_set::StrengthSet& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
const ::std::string& e = "UTF-8",
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
StrengthSet_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::strength_set::StrengthSet& 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
|
|
StrengthSet_ (::xercesc::XMLFormatTarget& ft,
|
|
const ::strength_set::StrengthSet& 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
|
|
StrengthSet_ (::xercesc::DOMDocument& d,
|
|
const ::strength_set::StrengthSet& x,
|
|
::xml_schema::flags f = 0);
|
|
|
|
// Serialize to a new xercesc::DOMDocument.
|
|
//
|
|
|
|
::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
|
|
StrengthSet_ (const ::strength_set::StrengthSet& x,
|
|
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
|
|
::xml_schema::flags f = 0);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const StrengthSet&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Section&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SecNode&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SecPlate&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SecOpenroom&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SecCloseroom&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const SecShell&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Subnode&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Mat&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Subgirder&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Attach&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Girder&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Loads&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Offset&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const WL&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Bonjean&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const KL&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const LoadCase&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const StWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ItemWeight&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const MTC&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const LiftedCargo&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ChkSubgirder&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ChkPlate&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ChkLongitudinal&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const StaticLoad&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const AllowLoad&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const AddtionalLoad&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const ProjectInfo&);
|
|
|
|
void
|
|
operator<< (::xercesc::DOMElement&, const Pub&);
|
|
}
|
|
|
|
#include <xsd/cxx/post.hxx>
|
|
|
|
// Begin epilogue.
|
|
//
|
|
//
|
|
// End epilogue.
|
|
|
|
#endif // STRENGTH_SET_HXX
|