// 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 EEDIMODEL_DS_HXX
#define EEDIMODEL_DS_HXX

#ifndef XSD_CXX11
#define XSD_CXX11
#endif

#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif

#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif

// Begin prologue.
//
//
// End prologue.

#include <xsd/cxx/config.hxx>

#if (LIBXSD_VERSION != 400002000000000L)
#error XSD runtime version mismatch
#endif

#include <xsd/cxx/pre.hxx>

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>

#include <xsd/cxx/xml/error-handler.hxx>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>

#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>

namespace xml_schema
{
  // anyType and anySimpleType.
  //
  typedef ::xsd::cxx::tree::type type;
  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
  typedef ::xsd::cxx::tree::type container;

  // 8-bit
  //
  typedef signed char byte;
  typedef unsigned char unsigned_byte;

  // 16-bit
  //
  typedef short short_;
  typedef unsigned short unsigned_short;

  // 32-bit
  //
  typedef int int_;
  typedef unsigned int unsigned_int;

  // 64-bit
  //
  typedef long long long_;
  typedef unsigned long long unsigned_long;

  // Supposed to be arbitrary-length integral types.
  //
  typedef long long integer;
  typedef long long non_positive_integer;
  typedef unsigned long long non_negative_integer;
  typedef unsigned long long positive_integer;
  typedef long long negative_integer;

  // Boolean.
  //
  typedef bool boolean;

  // Floating-point types.
  //
  typedef float float_;
  typedef double double_;
  typedef double decimal;

  // String types.
  //
  typedef ::xsd::cxx::tree::string< char, simple_type > string;
  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
  typedef ::xsd::cxx::tree::token< char, normalized_string > token;
  typedef ::xsd::cxx::tree::name< char, token > name;
  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
  typedef ::xsd::cxx::tree::ncname< char, name > ncname;
  typedef ::xsd::cxx::tree::language< char, token > language;

  // ID/IDREF.
  //
  typedef ::xsd::cxx::tree::id< char, ncname > id;
  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;

  // URI.
  //
  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;

  // Qualified name.
  //
  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;

  // Binary.
  //
  typedef ::xsd::cxx::tree::buffer< char > buffer;
  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;

  // Date/time.
  //
  typedef ::xsd::cxx::tree::time_zone time_zone;
  typedef ::xsd::cxx::tree::date< char, simple_type > date;
  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
  typedef ::xsd::cxx::tree::time< char, simple_type > time;

  // Entity.
  //
  typedef ::xsd::cxx::tree::entity< char, ncname > entity;
  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;

  typedef ::xsd::cxx::tree::content_order content_order;
  // Namespace information and list stream. Used in
  // serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;
  typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;
  typedef ::xsd::cxx::tree::list_stream< char > list_stream;
  typedef ::xsd::cxx::tree::as_double< double_ > as_double;
  typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;
  typedef ::xsd::cxx::tree::facet facet;

  // Flags and properties.
  //
  typedef ::xsd::cxx::tree::flags flags;
  typedef ::xsd::cxx::tree::properties< char > properties;

  // Parsing/serialization diagnostics.
  //
  typedef ::xsd::cxx::tree::severity severity;
  typedef ::xsd::cxx::tree::error< char > error;
  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;

  // Exceptions.
  //
  typedef ::xsd::cxx::tree::exception< char > exception;
  typedef ::xsd::cxx::tree::bounds< char > bounds;
  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
  typedef ::xsd::cxx::tree::parsing< char > parsing;
  typedef ::xsd::cxx::tree::expected_element< char > expected_element;
  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
  typedef ::xsd::cxx::tree::serialization< char > serialization;

  // Error handler callback interface.
  //
  typedef ::xsd::cxx::xml::error_handler< char > error_handler;

  // DOM interaction.
  //
  namespace dom
  {
    // Automatic pointer for DOMDocument.
    //
    using ::xsd::cxx::xml::dom::unique_ptr;

#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
    // DOM user data key for back pointers to tree nodes.
    //
    const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
  }
}

// Forward declarations.
//
namespace eedimodel_ds
{
  class EEDIModelDS;
  class BInf;
  class ME;
  class AE;
  class PTI;
  class PTO;
  class Propelor;
}


#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 eedimodel_ds
{
  class EEDIModelDS: public ::xml_schema::type
  {
    public:
    // BInf
    //
    typedef ::eedimodel_ds::BInf BInf_type;
    typedef ::xsd::cxx::tree::sequence< BInf_type > BInf_sequence;
    typedef BInf_sequence::iterator BInf_iterator;
    typedef BInf_sequence::const_iterator BInf_const_iterator;
    typedef ::xsd::cxx::tree::traits< BInf_type, char > BInf_traits;

    const BInf_sequence&
    BInf () const;

    BInf_sequence&
    BInf ();

    void
    BInf (const BInf_sequence& s);

    // ME
    //
    typedef ::eedimodel_ds::ME ME_type;
    typedef ::xsd::cxx::tree::sequence< ME_type > ME_sequence;
    typedef ME_sequence::iterator ME_iterator;
    typedef ME_sequence::const_iterator ME_const_iterator;
    typedef ::xsd::cxx::tree::traits< ME_type, char > ME_traits;

    const ME_sequence&
    ME () const;

    ME_sequence&
    ME ();

    void
    ME (const ME_sequence& s);

    // AE
    //
    typedef ::eedimodel_ds::AE AE_type;
    typedef ::xsd::cxx::tree::sequence< AE_type > AE_sequence;
    typedef AE_sequence::iterator AE_iterator;
    typedef AE_sequence::const_iterator AE_const_iterator;
    typedef ::xsd::cxx::tree::traits< AE_type, char > AE_traits;

    const AE_sequence&
    AE () const;

    AE_sequence&
    AE ();

    void
    AE (const AE_sequence& s);

    // PTI
    //
    typedef ::eedimodel_ds::PTI PTI_type;
    typedef ::xsd::cxx::tree::sequence< PTI_type > PTI_sequence;
    typedef PTI_sequence::iterator PTI_iterator;
    typedef PTI_sequence::const_iterator PTI_const_iterator;
    typedef ::xsd::cxx::tree::traits< PTI_type, char > PTI_traits;

    const PTI_sequence&
    PTI () const;

    PTI_sequence&
    PTI ();

    void
    PTI (const PTI_sequence& s);

    // PTO
    //
    typedef ::eedimodel_ds::PTO PTO_type;
    typedef ::xsd::cxx::tree::sequence< PTO_type > PTO_sequence;
    typedef PTO_sequence::iterator PTO_iterator;
    typedef PTO_sequence::const_iterator PTO_const_iterator;
    typedef ::xsd::cxx::tree::traits< PTO_type, char > PTO_traits;

    const PTO_sequence&
    PTO () const;

    PTO_sequence&
    PTO ();

    void
    PTO (const PTO_sequence& s);

    // Propelor
    //
    typedef ::eedimodel_ds::Propelor Propelor_type;
    typedef ::xsd::cxx::tree::sequence< Propelor_type > Propelor_sequence;
    typedef Propelor_sequence::iterator Propelor_iterator;
    typedef Propelor_sequence::const_iterator Propelor_const_iterator;
    typedef ::xsd::cxx::tree::traits< Propelor_type, char > Propelor_traits;

    const Propelor_sequence&
    Propelor () const;

    Propelor_sequence&
    Propelor ();

    void
    Propelor (const Propelor_sequence& s);

    // Constructors.
    //
    EEDIModelDS ();

    EEDIModelDS (const ::xercesc::DOMElement& e,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);

    EEDIModelDS (const EEDIModelDS& x,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);

    virtual EEDIModelDS*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    EEDIModelDS&
    operator= (const EEDIModelDS& x);

    virtual 
    ~EEDIModelDS ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    BInf_sequence BInf_;
    ME_sequence ME_;
    AE_sequence AE_;
    PTI_sequence PTI_;
    PTO_sequence PTO_;
    Propelor_sequence Propelor_;
  };

  class BInf: public ::xml_schema::type
  {
    public:
    // ParamID
    //
    typedef ::xml_schema::string ParamID_type;
    typedef ::xsd::cxx::tree::traits< ParamID_type, char > ParamID_traits;

    const ParamID_type&
    ParamID () const;

    ParamID_type&
    ParamID ();

    void
    ParamID (const ParamID_type& x);

    void
    ParamID (::std::unique_ptr< ParamID_type > p);

    // Unit
    //
    typedef ::xml_schema::string Unit_type;
    typedef ::xsd::cxx::tree::optional< Unit_type > Unit_optional;
    typedef ::xsd::cxx::tree::traits< Unit_type, char > Unit_traits;

    const Unit_optional&
    Unit () const;

    Unit_optional&
    Unit ();

    void
    Unit (const Unit_type& x);

    void
    Unit (const Unit_optional& x);

    void
    Unit (::std::unique_ptr< Unit_type > p);

    // Caption
    //
    typedef ::xml_schema::string Caption_type;
    typedef ::xsd::cxx::tree::optional< Caption_type > Caption_optional;
    typedef ::xsd::cxx::tree::traits< Caption_type, char > Caption_traits;

    const Caption_optional&
    Caption () const;

    Caption_optional&
    Caption ();

    void
    Caption (const Caption_type& x);

    void
    Caption (const Caption_optional& x);

    void
    Caption (::std::unique_ptr< Caption_type > p);

    // ValueType
    //
    typedef ::xml_schema::string ValueType_type;
    typedef ::xsd::cxx::tree::optional< ValueType_type > ValueType_optional;
    typedef ::xsd::cxx::tree::traits< ValueType_type, char > ValueType_traits;

    const ValueType_optional&
    ValueType () const;

    ValueType_optional&
    ValueType ();

    void
    ValueType (const ValueType_type& x);

    void
    ValueType (const ValueType_optional& x);

    void
    ValueType (::std::unique_ptr< ValueType_type > p);

    // Value
    //
    typedef ::xml_schema::string Value_type;
    typedef ::xsd::cxx::tree::optional< Value_type > Value_optional;
    typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;

    const Value_optional&
    Value () const;

    Value_optional&
    Value ();

    void
    Value (const Value_type& x);

    void
    Value (const Value_optional& x);

    void
    Value (::std::unique_ptr< Value_type > p);

    // Remark
    //
    typedef ::xml_schema::string Remark_type;
    typedef ::xsd::cxx::tree::optional< Remark_type > Remark_optional;
    typedef ::xsd::cxx::tree::traits< Remark_type, char > Remark_traits;

    const Remark_optional&
    Remark () const;

    Remark_optional&
    Remark ();

    void
    Remark (const Remark_type& x);

    void
    Remark (const Remark_optional& x);

    void
    Remark (::std::unique_ptr< Remark_type > p);

    // Constructors.
    //
    BInf (const ParamID_type&);

    BInf (const ::xercesc::DOMElement& e,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);

    BInf (const BInf& x,
          ::xml_schema::flags f = 0,
          ::xml_schema::container* c = 0);

    virtual BInf*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    BInf&
    operator= (const BInf& x);

    virtual 
    ~BInf ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ParamID_type > ParamID_;
    Unit_optional Unit_;
    Caption_optional Caption_;
    ValueType_optional ValueType_;
    Value_optional Value_;
    Remark_optional Remark_;
  };

  class ME: 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);

    // Yard
    //
    typedef ::xml_schema::string Yard_type;
    typedef ::xsd::cxx::tree::optional< Yard_type > Yard_optional;
    typedef ::xsd::cxx::tree::traits< Yard_type, char > Yard_traits;

    const Yard_optional&
    Yard () const;

    Yard_optional&
    Yard ();

    void
    Yard (const Yard_type& x);

    void
    Yard (const Yard_optional& x);

    void
    Yard (::std::unique_ptr< Yard_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);

    // MCR
    //
    typedef ::xml_schema::double_ MCR_type;
    typedef ::xsd::cxx::tree::optional< MCR_type > MCR_optional;
    typedef ::xsd::cxx::tree::traits< MCR_type, char, ::xsd::cxx::tree::schema_type::double_ > MCR_traits;

    const MCR_optional&
    MCR () const;

    MCR_optional&
    MCR ();

    void
    MCR (const MCR_type& x);

    void
    MCR (const MCR_optional& x);

    // MPP
    //
    typedef ::xml_schema::double_ MPP_type;
    typedef ::xsd::cxx::tree::optional< MPP_type > MPP_optional;
    typedef ::xsd::cxx::tree::traits< MPP_type, char, ::xsd::cxx::tree::schema_type::double_ > MPP_traits;

    const MPP_optional&
    MPP () const;

    MPP_optional&
    MPP ();

    void
    MPP (const MPP_type& x);

    void
    MPP (const MPP_optional& x);

    // SFC
    //
    typedef ::xml_schema::double_ SFC_type;
    typedef ::xsd::cxx::tree::optional< SFC_type > SFC_optional;
    typedef ::xsd::cxx::tree::traits< SFC_type, char, ::xsd::cxx::tree::schema_type::double_ > SFC_traits;

    const SFC_optional&
    SFC () const;

    SFC_optional&
    SFC ();

    void
    SFC (const SFC_type& x);

    void
    SFC (const SFC_optional& x);

    // FuelType
    //
    typedef ::xml_schema::int_ FuelType_type;
    typedef ::xsd::cxx::tree::optional< FuelType_type > FuelType_optional;
    typedef ::xsd::cxx::tree::traits< FuelType_type, char > FuelType_traits;

    const FuelType_optional&
    FuelType () const;

    FuelType_optional&
    FuelType ();

    void
    FuelType (const FuelType_type& x);

    void
    FuelType (const FuelType_optional& x);

    static FuelType_type
    FuelType_default_value ();

    // Constructors.
    //
    ME (const ID_type&);

    ME (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);

    ME (const ME& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);

    virtual ME*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    ME&
    operator= (const ME& x);

    virtual 
    ~ME ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ID_type > ID_;
    Yard_optional Yard_;
    Type_optional Type_;
    MCR_optional MCR_;
    MPP_optional MPP_;
    SFC_optional SFC_;
    FuelType_optional FuelType_;
  };

  class AE: 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);

    // Yard
    //
    typedef ::xml_schema::string Yard_type;
    typedef ::xsd::cxx::tree::optional< Yard_type > Yard_optional;
    typedef ::xsd::cxx::tree::traits< Yard_type, char > Yard_traits;

    const Yard_optional&
    Yard () const;

    Yard_optional&
    Yard ();

    void
    Yard (const Yard_type& x);

    void
    Yard (const Yard_optional& x);

    void
    Yard (::std::unique_ptr< Yard_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);

    // MCR
    //
    typedef ::xml_schema::double_ MCR_type;
    typedef ::xsd::cxx::tree::optional< MCR_type > MCR_optional;
    typedef ::xsd::cxx::tree::traits< MCR_type, char, ::xsd::cxx::tree::schema_type::double_ > MCR_traits;

    const MCR_optional&
    MCR () const;

    MCR_optional&
    MCR ();

    void
    MCR (const MCR_type& x);

    void
    MCR (const MCR_optional& x);

    // MPP
    //
    typedef ::xml_schema::double_ MPP_type;
    typedef ::xsd::cxx::tree::optional< MPP_type > MPP_optional;
    typedef ::xsd::cxx::tree::traits< MPP_type, char, ::xsd::cxx::tree::schema_type::double_ > MPP_traits;

    const MPP_optional&
    MPP () const;

    MPP_optional&
    MPP ();

    void
    MPP (const MPP_type& x);

    void
    MPP (const MPP_optional& x);

    // SFC
    //
    typedef ::xml_schema::double_ SFC_type;
    typedef ::xsd::cxx::tree::optional< SFC_type > SFC_optional;
    typedef ::xsd::cxx::tree::traits< SFC_type, char, ::xsd::cxx::tree::schema_type::double_ > SFC_traits;

    const SFC_optional&
    SFC () const;

    SFC_optional&
    SFC ();

    void
    SFC (const SFC_type& x);

    void
    SFC (const SFC_optional& x);

    // FuelType
    //
    typedef ::xml_schema::int_ FuelType_type;
    typedef ::xsd::cxx::tree::optional< FuelType_type > FuelType_optional;
    typedef ::xsd::cxx::tree::traits< FuelType_type, char > FuelType_traits;

    const FuelType_optional&
    FuelType () const;

    FuelType_optional&
    FuelType ();

    void
    FuelType (const FuelType_type& x);

    void
    FuelType (const FuelType_optional& x);

    static FuelType_type
    FuelType_default_value ();

    // Constructors.
    //
    AE (const ID_type&);

    AE (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);

    AE (const AE& x,
        ::xml_schema::flags f = 0,
        ::xml_schema::container* c = 0);

    virtual AE*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    AE&
    operator= (const AE& x);

    virtual 
    ~AE ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ID_type > ID_;
    Yard_optional Yard_;
    Type_optional Type_;
    MCR_optional MCR_;
    MPP_optional MPP_;
    SFC_optional SFC_;
    FuelType_optional FuelType_;
  };

  class PTI: 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);

    // SysNo
    //
    typedef ::xml_schema::string SysNo_type;
    typedef ::xsd::cxx::tree::optional< SysNo_type > SysNo_optional;
    typedef ::xsd::cxx::tree::traits< SysNo_type, char > SysNo_traits;

    const SysNo_optional&
    SysNo () const;

    SysNo_optional&
    SysNo ();

    void
    SysNo (const SysNo_type& x);

    void
    SysNo (const SysNo_optional& x);

    void
    SysNo (::std::unique_ptr< SysNo_type > p);

    // Yard
    //
    typedef ::xml_schema::string Yard_type;
    typedef ::xsd::cxx::tree::optional< Yard_type > Yard_optional;
    typedef ::xsd::cxx::tree::traits< Yard_type, char > Yard_traits;

    const Yard_optional&
    Yard () const;

    Yard_optional&
    Yard ();

    void
    Yard (const Yard_type& x);

    void
    Yard (const Yard_optional& x);

    void
    Yard (::std::unique_ptr< Yard_type > p);

    // Power
    //
    typedef ::xml_schema::double_ Power_type;
    typedef ::xsd::cxx::tree::optional< Power_type > Power_optional;
    typedef ::xsd::cxx::tree::traits< Power_type, char, ::xsd::cxx::tree::schema_type::double_ > Power_traits;

    const Power_optional&
    Power () const;

    Power_optional&
    Power ();

    void
    Power (const Power_type& x);

    void
    Power (const Power_optional& x);

    // EtaPTI
    //
    typedef ::xml_schema::double_ EtaPTI_type;
    typedef ::xsd::cxx::tree::optional< EtaPTI_type > EtaPTI_optional;
    typedef ::xsd::cxx::tree::traits< EtaPTI_type, char, ::xsd::cxx::tree::schema_type::double_ > EtaPTI_traits;

    const EtaPTI_optional&
    EtaPTI () const;

    EtaPTI_optional&
    EtaPTI ();

    void
    EtaPTI (const EtaPTI_type& x);

    void
    EtaPTI (const EtaPTI_optional& x);

    // Constructors.
    //
    PTI (const ID_type&);

    PTI (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);

    PTI (const PTI& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);

    virtual PTI*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    PTI&
    operator= (const PTI& x);

    virtual 
    ~PTI ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ID_type > ID_;
    SysNo_optional SysNo_;
    Yard_optional Yard_;
    Power_optional Power_;
    EtaPTI_optional EtaPTI_;
  };

  class PTO: 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);

    // SysNo
    //
    typedef ::xml_schema::string SysNo_type;
    typedef ::xsd::cxx::tree::optional< SysNo_type > SysNo_optional;
    typedef ::xsd::cxx::tree::traits< SysNo_type, char > SysNo_traits;

    const SysNo_optional&
    SysNo () const;

    SysNo_optional&
    SysNo ();

    void
    SysNo (const SysNo_type& x);

    void
    SysNo (const SysNo_optional& x);

    void
    SysNo (::std::unique_ptr< SysNo_type > p);

    // Yard
    //
    typedef ::xml_schema::string Yard_type;
    typedef ::xsd::cxx::tree::optional< Yard_type > Yard_optional;
    typedef ::xsd::cxx::tree::traits< Yard_type, char > Yard_traits;

    const Yard_optional&
    Yard () const;

    Yard_optional&
    Yard ();

    void
    Yard (const Yard_type& x);

    void
    Yard (const Yard_optional& x);

    void
    Yard (::std::unique_ptr< Yard_type > p);

    // Power
    //
    typedef ::xml_schema::double_ Power_type;
    typedef ::xsd::cxx::tree::optional< Power_type > Power_optional;
    typedef ::xsd::cxx::tree::traits< Power_type, char, ::xsd::cxx::tree::schema_type::double_ > Power_traits;

    const Power_optional&
    Power () const;

    Power_optional&
    Power ();

    void
    Power (const Power_type& x);

    void
    Power (const Power_optional& x);

    // Constructors.
    //
    PTO (const ID_type&);

    PTO (const ::xercesc::DOMElement& e,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);

    PTO (const PTO& x,
         ::xml_schema::flags f = 0,
         ::xml_schema::container* c = 0);

    virtual PTO*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    PTO&
    operator= (const PTO& x);

    virtual 
    ~PTO ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ID_type > ID_;
    SysNo_optional SysNo_;
    Yard_optional Yard_;
    Power_optional Power_;
  };

  class Propelor: 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);

    // PType
    //
    typedef ::xml_schema::string PType_type;
    typedef ::xsd::cxx::tree::optional< PType_type > PType_optional;
    typedef ::xsd::cxx::tree::traits< PType_type, char > PType_traits;

    const PType_optional&
    PType () const;

    PType_optional&
    PType ();

    void
    PType (const PType_type& x);

    void
    PType (const PType_optional& x);

    void
    PType (::std::unique_ptr< PType_type > p);

    // PBlade
    //
    typedef ::xml_schema::int_ PBlade_type;
    typedef ::xsd::cxx::tree::optional< PBlade_type > PBlade_optional;
    typedef ::xsd::cxx::tree::traits< PBlade_type, char > PBlade_traits;

    const PBlade_optional&
    PBlade () const;

    PBlade_optional&
    PBlade ();

    void
    PBlade (const PBlade_type& x);

    void
    PBlade (const PBlade_optional& x);

    // DIA
    //
    typedef ::xml_schema::double_ DIA_type;
    typedef ::xsd::cxx::tree::optional< DIA_type > DIA_optional;
    typedef ::xsd::cxx::tree::traits< DIA_type, char, ::xsd::cxx::tree::schema_type::double_ > DIA_traits;

    const DIA_optional&
    DIA () const;

    DIA_optional&
    DIA ();

    void
    DIA (const DIA_type& x);

    void
    DIA (const DIA_optional& x);

    // Constructors.
    //
    Propelor (const ID_type&);

    Propelor (const ::xercesc::DOMElement& e,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);

    Propelor (const Propelor& x,
              ::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0);

    virtual Propelor*
    _clone (::xml_schema::flags f = 0,
            ::xml_schema::container* c = 0) const;

    Propelor&
    operator= (const Propelor& x);

    virtual 
    ~Propelor ();

    // Implementation.
    //
    protected:
    void
    parse (::xsd::cxx::xml::dom::parser< char >&,
           ::xml_schema::flags);

    protected:
    ::xsd::cxx::tree::one< ID_type > ID_;
    PType_optional PType_;
    PBlade_optional PBlade_;
    DIA_optional DIA_;
  };
}

#include <iosfwd>

#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>

namespace eedimodel_ds
{
  // Parse a URI or a local file.
  //

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::std::string& uri,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (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< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (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< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xml_schema::error_handler& eh,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xercesc::DOMErrorHandler& eh,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                const ::std::string& id,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::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< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::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< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xercesc::InputSource& is,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xercesc::InputSource& is,
                ::xml_schema::error_handler& eh,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::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< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::xercesc::DOMDocument& d,
                ::xml_schema::flags f = 0,
                const ::xml_schema::properties& p = ::xml_schema::properties ());

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::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 eedimodel_ds
{
  // Serialize to std::ostream.
  //

  void
  EEDIModelDS_ (::std::ostream& os,
                const ::eedimodel_ds::EEDIModelDS& x, 
                const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                const ::std::string& e = "UTF-8",
                ::xml_schema::flags f = 0);

  void
  EEDIModelDS_ (::std::ostream& os,
                const ::eedimodel_ds::EEDIModelDS& 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
  EEDIModelDS_ (::std::ostream& os,
                const ::eedimodel_ds::EEDIModelDS& 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
  EEDIModelDS_ (::xercesc::XMLFormatTarget& ft,
                const ::eedimodel_ds::EEDIModelDS& x, 
                const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                const ::std::string& e = "UTF-8",
                ::xml_schema::flags f = 0);

  void
  EEDIModelDS_ (::xercesc::XMLFormatTarget& ft,
                const ::eedimodel_ds::EEDIModelDS& 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
  EEDIModelDS_ (::xercesc::XMLFormatTarget& ft,
                const ::eedimodel_ds::EEDIModelDS& 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
  EEDIModelDS_ (::xercesc::DOMDocument& d,
                const ::eedimodel_ds::EEDIModelDS& x,
                ::xml_schema::flags f = 0);

  // Serialize to a new xercesc::DOMDocument.
  //

  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
  EEDIModelDS_ (const ::eedimodel_ds::EEDIModelDS& x, 
                const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                ::xml_schema::flags f = 0);

  void
  operator<< (::xercesc::DOMElement&, const EEDIModelDS&);

  void
  operator<< (::xercesc::DOMElement&, const BInf&);

  void
  operator<< (::xercesc::DOMElement&, const ME&);

  void
  operator<< (::xercesc::DOMElement&, const AE&);

  void
  operator<< (::xercesc::DOMElement&, const PTI&);

  void
  operator<< (::xercesc::DOMElement&, const PTO&);

  void
  operator<< (::xercesc::DOMElement&, const Propelor&);
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.

#endif // EEDIMODEL_DS_HXX