COMPASSi/trunk/code/projects/DataManager/XSDSource/EEDIModelDS.cxx

// 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.
//

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

#include <xsd/cxx/pre.hxx>

#include "EEDIModelDS.hxx"

namespace eedimodel_ds
{
  // EEDIModelDS
  //

  const EEDIModelDS::BInf_sequence& EEDIModelDS::
  BInf () const
  {
    return this->BInf_;
  }

  EEDIModelDS::BInf_sequence& EEDIModelDS::
  BInf ()
  {
    return this->BInf_;
  }

  void EEDIModelDS::
  BInf (const BInf_sequence& s)
  {
    this->BInf_ = s;
  }

  const EEDIModelDS::ME_sequence& EEDIModelDS::
  ME () const
  {
    return this->ME_;
  }

  EEDIModelDS::ME_sequence& EEDIModelDS::
  ME ()
  {
    return this->ME_;
  }

  void EEDIModelDS::
  ME (const ME_sequence& s)
  {
    this->ME_ = s;
  }

  const EEDIModelDS::AE_sequence& EEDIModelDS::
  AE () const
  {
    return this->AE_;
  }

  EEDIModelDS::AE_sequence& EEDIModelDS::
  AE ()
  {
    return this->AE_;
  }

  void EEDIModelDS::
  AE (const AE_sequence& s)
  {
    this->AE_ = s;
  }

  const EEDIModelDS::PTI_sequence& EEDIModelDS::
  PTI () const
  {
    return this->PTI_;
  }

  EEDIModelDS::PTI_sequence& EEDIModelDS::
  PTI ()
  {
    return this->PTI_;
  }

  void EEDIModelDS::
  PTI (const PTI_sequence& s)
  {
    this->PTI_ = s;
  }

  const EEDIModelDS::PTO_sequence& EEDIModelDS::
  PTO () const
  {
    return this->PTO_;
  }

  EEDIModelDS::PTO_sequence& EEDIModelDS::
  PTO ()
  {
    return this->PTO_;
  }

  void EEDIModelDS::
  PTO (const PTO_sequence& s)
  {
    this->PTO_ = s;
  }

  const EEDIModelDS::Propelor_sequence& EEDIModelDS::
  Propelor () const
  {
    return this->Propelor_;
  }

  EEDIModelDS::Propelor_sequence& EEDIModelDS::
  Propelor ()
  {
    return this->Propelor_;
  }

  void EEDIModelDS::
  Propelor (const Propelor_sequence& s)
  {
    this->Propelor_ = s;
  }


  // BInf
  //

  const BInf::ParamID_type& BInf::
  ParamID () const
  {
    return this->ParamID_.get ();
  }

  BInf::ParamID_type& BInf::
  ParamID ()
  {
    return this->ParamID_.get ();
  }

  void BInf::
  ParamID (const ParamID_type& x)
  {
    this->ParamID_.set (x);
  }

  void BInf::
  ParamID (::std::unique_ptr< ParamID_type > x)
  {
    this->ParamID_.set (std::move (x));
  }

  const BInf::Unit_optional& BInf::
  Unit () const
  {
    return this->Unit_;
  }

  BInf::Unit_optional& BInf::
  Unit ()
  {
    return this->Unit_;
  }

  void BInf::
  Unit (const Unit_type& x)
  {
    this->Unit_.set (x);
  }

  void BInf::
  Unit (const Unit_optional& x)
  {
    this->Unit_ = x;
  }

  void BInf::
  Unit (::std::unique_ptr< Unit_type > x)
  {
    this->Unit_.set (std::move (x));
  }

  const BInf::Caption_optional& BInf::
  Caption () const
  {
    return this->Caption_;
  }

  BInf::Caption_optional& BInf::
  Caption ()
  {
    return this->Caption_;
  }

  void BInf::
  Caption (const Caption_type& x)
  {
    this->Caption_.set (x);
  }

  void BInf::
  Caption (const Caption_optional& x)
  {
    this->Caption_ = x;
  }

  void BInf::
  Caption (::std::unique_ptr< Caption_type > x)
  {
    this->Caption_.set (std::move (x));
  }

  const BInf::ValueType_optional& BInf::
  ValueType () const
  {
    return this->ValueType_;
  }

  BInf::ValueType_optional& BInf::
  ValueType ()
  {
    return this->ValueType_;
  }

  void BInf::
  ValueType (const ValueType_type& x)
  {
    this->ValueType_.set (x);
  }

  void BInf::
  ValueType (const ValueType_optional& x)
  {
    this->ValueType_ = x;
  }

  void BInf::
  ValueType (::std::unique_ptr< ValueType_type > x)
  {
    this->ValueType_.set (std::move (x));
  }

  const BInf::Value_optional& BInf::
  Value () const
  {
    return this->Value_;
  }

  BInf::Value_optional& BInf::
  Value ()
  {
    return this->Value_;
  }

  void BInf::
  Value (const Value_type& x)
  {
    this->Value_.set (x);
  }

  void BInf::
  Value (const Value_optional& x)
  {
    this->Value_ = x;
  }

  void BInf::
  Value (::std::unique_ptr< Value_type > x)
  {
    this->Value_.set (std::move (x));
  }

  const BInf::Remark_optional& BInf::
  Remark () const
  {
    return this->Remark_;
  }

  BInf::Remark_optional& BInf::
  Remark ()
  {
    return this->Remark_;
  }

  void BInf::
  Remark (const Remark_type& x)
  {
    this->Remark_.set (x);
  }

  void BInf::
  Remark (const Remark_optional& x)
  {
    this->Remark_ = x;
  }

  void BInf::
  Remark (::std::unique_ptr< Remark_type > x)
  {
    this->Remark_.set (std::move (x));
  }


  // ME
  //

  const ME::ID_type& ME::
  ID () const
  {
    return this->ID_.get ();
  }

  ME::ID_type& ME::
  ID ()
  {
    return this->ID_.get ();
  }

  void ME::
  ID (const ID_type& x)
  {
    this->ID_.set (x);
  }

  void ME::
  ID (::std::unique_ptr< ID_type > x)
  {
    this->ID_.set (std::move (x));
  }

  const ME::Yard_optional& ME::
  Yard () const
  {
    return this->Yard_;
  }

  ME::Yard_optional& ME::
  Yard ()
  {
    return this->Yard_;
  }

  void ME::
  Yard (const Yard_type& x)
  {
    this->Yard_.set (x);
  }

  void ME::
  Yard (const Yard_optional& x)
  {
    this->Yard_ = x;
  }

  void ME::
  Yard (::std::unique_ptr< Yard_type > x)
  {
    this->Yard_.set (std::move (x));
  }

  const ME::Type_optional& ME::
  Type () const
  {
    return this->Type_;
  }

  ME::Type_optional& ME::
  Type ()
  {
    return this->Type_;
  }

  void ME::
  Type (const Type_type& x)
  {
    this->Type_.set (x);
  }

  void ME::
  Type (const Type_optional& x)
  {
    this->Type_ = x;
  }

  void ME::
  Type (::std::unique_ptr< Type_type > x)
  {
    this->Type_.set (std::move (x));
  }

  const ME::MCR_optional& ME::
  MCR () const
  {
    return this->MCR_;
  }

  ME::MCR_optional& ME::
  MCR ()
  {
    return this->MCR_;
  }

  void ME::
  MCR (const MCR_type& x)
  {
    this->MCR_.set (x);
  }

  void ME::
  MCR (const MCR_optional& x)
  {
    this->MCR_ = x;
  }

  const ME::MPP_optional& ME::
  MPP () const
  {
    return this->MPP_;
  }

  ME::MPP_optional& ME::
  MPP ()
  {
    return this->MPP_;
  }

  void ME::
  MPP (const MPP_type& x)
  {
    this->MPP_.set (x);
  }

  void ME::
  MPP (const MPP_optional& x)
  {
    this->MPP_ = x;
  }

  const ME::SFC_optional& ME::
  SFC () const
  {
    return this->SFC_;
  }

  ME::SFC_optional& ME::
  SFC ()
  {
    return this->SFC_;
  }

  void ME::
  SFC (const SFC_type& x)
  {
    this->SFC_.set (x);
  }

  void ME::
  SFC (const SFC_optional& x)
  {
    this->SFC_ = x;
  }

  const ME::FuelType_optional& ME::
  FuelType () const
  {
    return this->FuelType_;
  }

  ME::FuelType_optional& ME::
  FuelType ()
  {
    return this->FuelType_;
  }

  void ME::
  FuelType (const FuelType_type& x)
  {
    this->FuelType_.set (x);
  }

  void ME::
  FuelType (const FuelType_optional& x)
  {
    this->FuelType_ = x;
  }

  ME::FuelType_type ME::
  FuelType_default_value ()
  {
    return FuelType_type (1);
  }


  // AE
  //

  const AE::ID_type& AE::
  ID () const
  {
    return this->ID_.get ();
  }

  AE::ID_type& AE::
  ID ()
  {
    return this->ID_.get ();
  }

  void AE::
  ID (const ID_type& x)
  {
    this->ID_.set (x);
  }

  void AE::
  ID (::std::unique_ptr< ID_type > x)
  {
    this->ID_.set (std::move (x));
  }

  const AE::Yard_optional& AE::
  Yard () const
  {
    return this->Yard_;
  }

  AE::Yard_optional& AE::
  Yard ()
  {
    return this->Yard_;
  }

  void AE::
  Yard (const Yard_type& x)
  {
    this->Yard_.set (x);
  }

  void AE::
  Yard (const Yard_optional& x)
  {
    this->Yard_ = x;
  }

  void AE::
  Yard (::std::unique_ptr< Yard_type > x)
  {
    this->Yard_.set (std::move (x));
  }

  const AE::Type_optional& AE::
  Type () const
  {
    return this->Type_;
  }

  AE::Type_optional& AE::
  Type ()
  {
    return this->Type_;
  }

  void AE::
  Type (const Type_type& x)
  {
    this->Type_.set (x);
  }

  void AE::
  Type (const Type_optional& x)
  {
    this->Type_ = x;
  }

  void AE::
  Type (::std::unique_ptr< Type_type > x)
  {
    this->Type_.set (std::move (x));
  }

  const AE::MCR_optional& AE::
  MCR () const
  {
    return this->MCR_;
  }

  AE::MCR_optional& AE::
  MCR ()
  {
    return this->MCR_;
  }

  void AE::
  MCR (const MCR_type& x)
  {
    this->MCR_.set (x);
  }

  void AE::
  MCR (const MCR_optional& x)
  {
    this->MCR_ = x;
  }

  const AE::MPP_optional& AE::
  MPP () const
  {
    return this->MPP_;
  }

  AE::MPP_optional& AE::
  MPP ()
  {
    return this->MPP_;
  }

  void AE::
  MPP (const MPP_type& x)
  {
    this->MPP_.set (x);
  }

  void AE::
  MPP (const MPP_optional& x)
  {
    this->MPP_ = x;
  }

  const AE::SFC_optional& AE::
  SFC () const
  {
    return this->SFC_;
  }

  AE::SFC_optional& AE::
  SFC ()
  {
    return this->SFC_;
  }

  void AE::
  SFC (const SFC_type& x)
  {
    this->SFC_.set (x);
  }

  void AE::
  SFC (const SFC_optional& x)
  {
    this->SFC_ = x;
  }

  const AE::FuelType_optional& AE::
  FuelType () const
  {
    return this->FuelType_;
  }

  AE::FuelType_optional& AE::
  FuelType ()
  {
    return this->FuelType_;
  }

  void AE::
  FuelType (const FuelType_type& x)
  {
    this->FuelType_.set (x);
  }

  void AE::
  FuelType (const FuelType_optional& x)
  {
    this->FuelType_ = x;
  }

  AE::FuelType_type AE::
  FuelType_default_value ()
  {
    return FuelType_type (1);
  }


  // PTI
  //

  const PTI::ID_type& PTI::
  ID () const
  {
    return this->ID_.get ();
  }

  PTI::ID_type& PTI::
  ID ()
  {
    return this->ID_.get ();
  }

  void PTI::
  ID (const ID_type& x)
  {
    this->ID_.set (x);
  }

  void PTI::
  ID (::std::unique_ptr< ID_type > x)
  {
    this->ID_.set (std::move (x));
  }

  const PTI::SysNo_optional& PTI::
  SysNo () const
  {
    return this->SysNo_;
  }

  PTI::SysNo_optional& PTI::
  SysNo ()
  {
    return this->SysNo_;
  }

  void PTI::
  SysNo (const SysNo_type& x)
  {
    this->SysNo_.set (x);
  }

  void PTI::
  SysNo (const SysNo_optional& x)
  {
    this->SysNo_ = x;
  }

  void PTI::
  SysNo (::std::unique_ptr< SysNo_type > x)
  {
    this->SysNo_.set (std::move (x));
  }

  const PTI::Yard_optional& PTI::
  Yard () const
  {
    return this->Yard_;
  }

  PTI::Yard_optional& PTI::
  Yard ()
  {
    return this->Yard_;
  }

  void PTI::
  Yard (const Yard_type& x)
  {
    this->Yard_.set (x);
  }

  void PTI::
  Yard (const Yard_optional& x)
  {
    this->Yard_ = x;
  }

  void PTI::
  Yard (::std::unique_ptr< Yard_type > x)
  {
    this->Yard_.set (std::move (x));
  }

  const PTI::Power_optional& PTI::
  Power () const
  {
    return this->Power_;
  }

  PTI::Power_optional& PTI::
  Power ()
  {
    return this->Power_;
  }

  void PTI::
  Power (const Power_type& x)
  {
    this->Power_.set (x);
  }

  void PTI::
  Power (const Power_optional& x)
  {
    this->Power_ = x;
  }

  const PTI::EtaPTI_optional& PTI::
  EtaPTI () const
  {
    return this->EtaPTI_;
  }

  PTI::EtaPTI_optional& PTI::
  EtaPTI ()
  {
    return this->EtaPTI_;
  }

  void PTI::
  EtaPTI (const EtaPTI_type& x)
  {
    this->EtaPTI_.set (x);
  }

  void PTI::
  EtaPTI (const EtaPTI_optional& x)
  {
    this->EtaPTI_ = x;
  }


  // PTO
  //

  const PTO::ID_type& PTO::
  ID () const
  {
    return this->ID_.get ();
  }

  PTO::ID_type& PTO::
  ID ()
  {
    return this->ID_.get ();
  }

  void PTO::
  ID (const ID_type& x)
  {
    this->ID_.set (x);
  }

  void PTO::
  ID (::std::unique_ptr< ID_type > x)
  {
    this->ID_.set (std::move (x));
  }

  const PTO::SysNo_optional& PTO::
  SysNo () const
  {
    return this->SysNo_;
  }

  PTO::SysNo_optional& PTO::
  SysNo ()
  {
    return this->SysNo_;
  }

  void PTO::
  SysNo (const SysNo_type& x)
  {
    this->SysNo_.set (x);
  }

  void PTO::
  SysNo (const SysNo_optional& x)
  {
    this->SysNo_ = x;
  }

  void PTO::
  SysNo (::std::unique_ptr< SysNo_type > x)
  {
    this->SysNo_.set (std::move (x));
  }

  const PTO::Yard_optional& PTO::
  Yard () const
  {
    return this->Yard_;
  }

  PTO::Yard_optional& PTO::
  Yard ()
  {
    return this->Yard_;
  }

  void PTO::
  Yard (const Yard_type& x)
  {
    this->Yard_.set (x);
  }

  void PTO::
  Yard (const Yard_optional& x)
  {
    this->Yard_ = x;
  }

  void PTO::
  Yard (::std::unique_ptr< Yard_type > x)
  {
    this->Yard_.set (std::move (x));
  }

  const PTO::Power_optional& PTO::
  Power () const
  {
    return this->Power_;
  }

  PTO::Power_optional& PTO::
  Power ()
  {
    return this->Power_;
  }

  void PTO::
  Power (const Power_type& x)
  {
    this->Power_.set (x);
  }

  void PTO::
  Power (const Power_optional& x)
  {
    this->Power_ = x;
  }


  // Propelor
  //

  const Propelor::ID_type& Propelor::
  ID () const
  {
    return this->ID_.get ();
  }

  Propelor::ID_type& Propelor::
  ID ()
  {
    return this->ID_.get ();
  }

  void Propelor::
  ID (const ID_type& x)
  {
    this->ID_.set (x);
  }

  void Propelor::
  ID (::std::unique_ptr< ID_type > x)
  {
    this->ID_.set (std::move (x));
  }

  const Propelor::PType_optional& Propelor::
  PType () const
  {
    return this->PType_;
  }

  Propelor::PType_optional& Propelor::
  PType ()
  {
    return this->PType_;
  }

  void Propelor::
  PType (const PType_type& x)
  {
    this->PType_.set (x);
  }

  void Propelor::
  PType (const PType_optional& x)
  {
    this->PType_ = x;
  }

  void Propelor::
  PType (::std::unique_ptr< PType_type > x)
  {
    this->PType_.set (std::move (x));
  }

  const Propelor::PBlade_optional& Propelor::
  PBlade () const
  {
    return this->PBlade_;
  }

  Propelor::PBlade_optional& Propelor::
  PBlade ()
  {
    return this->PBlade_;
  }

  void Propelor::
  PBlade (const PBlade_type& x)
  {
    this->PBlade_.set (x);
  }

  void Propelor::
  PBlade (const PBlade_optional& x)
  {
    this->PBlade_ = x;
  }

  const Propelor::DIA_optional& Propelor::
  DIA () const
  {
    return this->DIA_;
  }

  Propelor::DIA_optional& Propelor::
  DIA ()
  {
    return this->DIA_;
  }

  void Propelor::
  DIA (const DIA_type& x)
  {
    this->DIA_.set (x);
  }

  void Propelor::
  DIA (const DIA_optional& x)
  {
    this->DIA_ = x;
  }
}

#include <xsd/cxx/xml/dom/parsing-source.hxx>

namespace eedimodel_ds
{
  // EEDIModelDS
  //

  EEDIModelDS::
  EEDIModelDS ()
  : ::xml_schema::type (),
    BInf_ (this),
    ME_ (this),
    AE_ (this),
    PTI_ (this),
    PTO_ (this),
    Propelor_ (this)
  {
  }

  EEDIModelDS::
  EEDIModelDS (const EEDIModelDS& x,
               ::xml_schema::flags f,
               ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    BInf_ (x.BInf_, f, this),
    ME_ (x.ME_, f, this),
    AE_ (x.AE_, f, this),
    PTI_ (x.PTI_, f, this),
    PTO_ (x.PTO_, f, this),
    Propelor_ (x.Propelor_, f, this)
  {
  }

  EEDIModelDS::
  EEDIModelDS (const ::xercesc::DOMElement& e,
               ::xml_schema::flags f,
               ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    BInf_ (this),
    ME_ (this),
    AE_ (this),
    PTI_ (this),
    PTO_ (this),
    Propelor_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void EEDIModelDS::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // BInf
      //
      if (n.name () == "BInf" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< BInf_type > r (
          BInf_traits::create (i, f, this));

        this->BInf_.push_back (::std::move (r));
        continue;
      }

      // ME
      //
      if (n.name () == "ME" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ME_type > r (
          ME_traits::create (i, f, this));

        this->ME_.push_back (::std::move (r));
        continue;
      }

      // AE
      //
      if (n.name () == "AE" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< AE_type > r (
          AE_traits::create (i, f, this));

        this->AE_.push_back (::std::move (r));
        continue;
      }

      // PTI
      //
      if (n.name () == "PTI" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< PTI_type > r (
          PTI_traits::create (i, f, this));

        this->PTI_.push_back (::std::move (r));
        continue;
      }

      // PTO
      //
      if (n.name () == "PTO" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< PTO_type > r (
          PTO_traits::create (i, f, this));

        this->PTO_.push_back (::std::move (r));
        continue;
      }

      // Propelor
      //
      if (n.name () == "Propelor" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Propelor_type > r (
          Propelor_traits::create (i, f, this));

        this->Propelor_.push_back (::std::move (r));
        continue;
      }

      break;
    }
  }

  EEDIModelDS* EEDIModelDS::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class EEDIModelDS (*this, f, c);
  }

  EEDIModelDS& EEDIModelDS::
  operator= (const EEDIModelDS& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->BInf_ = x.BInf_;
      this->ME_ = x.ME_;
      this->AE_ = x.AE_;
      this->PTI_ = x.PTI_;
      this->PTO_ = x.PTO_;
      this->Propelor_ = x.Propelor_;
    }

    return *this;
  }

  EEDIModelDS::
  ~EEDIModelDS ()
  {
  }

  // BInf
  //

  BInf::
  BInf (const ParamID_type& ParamID)
  : ::xml_schema::type (),
    ParamID_ (ParamID, this),
    Unit_ (this),
    Caption_ (this),
    ValueType_ (this),
    Value_ (this),
    Remark_ (this)
  {
  }

  BInf::
  BInf (const BInf& x,
        ::xml_schema::flags f,
        ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ParamID_ (x.ParamID_, f, this),
    Unit_ (x.Unit_, f, this),
    Caption_ (x.Caption_, f, this),
    ValueType_ (x.ValueType_, f, this),
    Value_ (x.Value_, f, this),
    Remark_ (x.Remark_, f, this)
  {
  }

  BInf::
  BInf (const ::xercesc::DOMElement& e,
        ::xml_schema::flags f,
        ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ParamID_ (this),
    Unit_ (this),
    Caption_ (this),
    ValueType_ (this),
    Value_ (this),
    Remark_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void BInf::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ParamID
      //
      if (n.name () == "ParamID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ParamID_type > r (
          ParamID_traits::create (i, f, this));

        if (!ParamID_.present ())
        {
          this->ParamID_.set (::std::move (r));
          continue;
        }
      }

      // Unit
      //
      if (n.name () == "Unit" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Unit_type > r (
          Unit_traits::create (i, f, this));

        if (!this->Unit_)
        {
          this->Unit_.set (::std::move (r));
          continue;
        }
      }

      // Caption
      //
      if (n.name () == "Caption" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Caption_type > r (
          Caption_traits::create (i, f, this));

        if (!this->Caption_)
        {
          this->Caption_.set (::std::move (r));
          continue;
        }
      }

      // ValueType
      //
      if (n.name () == "ValueType" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ValueType_type > r (
          ValueType_traits::create (i, f, this));

        if (!this->ValueType_)
        {
          this->ValueType_.set (::std::move (r));
          continue;
        }
      }

      // Value
      //
      if (n.name () == "Value" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Value_type > r (
          Value_traits::create (i, f, this));

        if (!this->Value_)
        {
          this->Value_.set (::std::move (r));
          continue;
        }
      }

      // Remark
      //
      if (n.name () == "Remark" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Remark_type > r (
          Remark_traits::create (i, f, this));

        if (!this->Remark_)
        {
          this->Remark_.set (::std::move (r));
          continue;
        }
      }

      break;
    }

    if (!ParamID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ParamID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  BInf* BInf::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class BInf (*this, f, c);
  }

  BInf& BInf::
  operator= (const BInf& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ParamID_ = x.ParamID_;
      this->Unit_ = x.Unit_;
      this->Caption_ = x.Caption_;
      this->ValueType_ = x.ValueType_;
      this->Value_ = x.Value_;
      this->Remark_ = x.Remark_;
    }

    return *this;
  }

  BInf::
  ~BInf ()
  {
  }

  // ME
  //

  ME::
  ME (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    Yard_ (this),
    Type_ (this),
    MCR_ (this),
    MPP_ (this),
    SFC_ (this),
    FuelType_ (this)
  {
  }

  ME::
  ME (const ME& x,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    Yard_ (x.Yard_, f, this),
    Type_ (x.Type_, f, this),
    MCR_ (x.MCR_, f, this),
    MPP_ (x.MPP_, f, this),
    SFC_ (x.SFC_, f, this),
    FuelType_ (x.FuelType_, f, this)
  {
  }

  ME::
  ME (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    Yard_ (this),
    Type_ (this),
    MCR_ (this),
    MPP_ (this),
    SFC_ (this),
    FuelType_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void ME::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ID
      //
      if (n.name () == "ID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

        if (!ID_.present ())
        {
          this->ID_.set (::std::move (r));
          continue;
        }
      }

      // Yard
      //
      if (n.name () == "Yard" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Yard_type > r (
          Yard_traits::create (i, f, this));

        if (!this->Yard_)
        {
          this->Yard_.set (::std::move (r));
          continue;
        }
      }

      // Type
      //
      if (n.name () == "Type" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Type_type > r (
          Type_traits::create (i, f, this));

        if (!this->Type_)
        {
          this->Type_.set (::std::move (r));
          continue;
        }
      }

      // MCR
      //
      if (n.name () == "MCR" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->MCR_)
        {
          this->MCR_.set (MCR_traits::create (i, f, this));
          continue;
        }
      }

      // MPP
      //
      if (n.name () == "MPP" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->MPP_)
        {
          this->MPP_.set (MPP_traits::create (i, f, this));
          continue;
        }
      }

      // SFC
      //
      if (n.name () == "SFC" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->SFC_)
        {
          this->SFC_.set (SFC_traits::create (i, f, this));
          continue;
        }
      }

      // FuelType
      //
      if (n.name () == "FuelType" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->FuelType_)
        {
          this->FuelType_.set (FuelType_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  ME* ME::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class ME (*this, f, c);
  }

  ME& ME::
  operator= (const ME& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->Yard_ = x.Yard_;
      this->Type_ = x.Type_;
      this->MCR_ = x.MCR_;
      this->MPP_ = x.MPP_;
      this->SFC_ = x.SFC_;
      this->FuelType_ = x.FuelType_;
    }

    return *this;
  }

  ME::
  ~ME ()
  {
  }

  // AE
  //

  AE::
  AE (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    Yard_ (this),
    Type_ (this),
    MCR_ (this),
    MPP_ (this),
    SFC_ (this),
    FuelType_ (this)
  {
  }

  AE::
  AE (const AE& x,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    Yard_ (x.Yard_, f, this),
    Type_ (x.Type_, f, this),
    MCR_ (x.MCR_, f, this),
    MPP_ (x.MPP_, f, this),
    SFC_ (x.SFC_, f, this),
    FuelType_ (x.FuelType_, f, this)
  {
  }

  AE::
  AE (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    Yard_ (this),
    Type_ (this),
    MCR_ (this),
    MPP_ (this),
    SFC_ (this),
    FuelType_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void AE::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ID
      //
      if (n.name () == "ID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

        if (!ID_.present ())
        {
          this->ID_.set (::std::move (r));
          continue;
        }
      }

      // Yard
      //
      if (n.name () == "Yard" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Yard_type > r (
          Yard_traits::create (i, f, this));

        if (!this->Yard_)
        {
          this->Yard_.set (::std::move (r));
          continue;
        }
      }

      // Type
      //
      if (n.name () == "Type" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Type_type > r (
          Type_traits::create (i, f, this));

        if (!this->Type_)
        {
          this->Type_.set (::std::move (r));
          continue;
        }
      }

      // MCR
      //
      if (n.name () == "MCR" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->MCR_)
        {
          this->MCR_.set (MCR_traits::create (i, f, this));
          continue;
        }
      }

      // MPP
      //
      if (n.name () == "MPP" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->MPP_)
        {
          this->MPP_.set (MPP_traits::create (i, f, this));
          continue;
        }
      }

      // SFC
      //
      if (n.name () == "SFC" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->SFC_)
        {
          this->SFC_.set (SFC_traits::create (i, f, this));
          continue;
        }
      }

      // FuelType
      //
      if (n.name () == "FuelType" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->FuelType_)
        {
          this->FuelType_.set (FuelType_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  AE* AE::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class AE (*this, f, c);
  }

  AE& AE::
  operator= (const AE& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->Yard_ = x.Yard_;
      this->Type_ = x.Type_;
      this->MCR_ = x.MCR_;
      this->MPP_ = x.MPP_;
      this->SFC_ = x.SFC_;
      this->FuelType_ = x.FuelType_;
    }

    return *this;
  }

  AE::
  ~AE ()
  {
  }

  // PTI
  //

  PTI::
  PTI (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    SysNo_ (this),
    Yard_ (this),
    Power_ (this),
    EtaPTI_ (this)
  {
  }

  PTI::
  PTI (const PTI& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    SysNo_ (x.SysNo_, f, this),
    Yard_ (x.Yard_, f, this),
    Power_ (x.Power_, f, this),
    EtaPTI_ (x.EtaPTI_, f, this)
  {
  }

  PTI::
  PTI (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    SysNo_ (this),
    Yard_ (this),
    Power_ (this),
    EtaPTI_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void PTI::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ID
      //
      if (n.name () == "ID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

        if (!ID_.present ())
        {
          this->ID_.set (::std::move (r));
          continue;
        }
      }

      // SysNo
      //
      if (n.name () == "SysNo" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< SysNo_type > r (
          SysNo_traits::create (i, f, this));

        if (!this->SysNo_)
        {
          this->SysNo_.set (::std::move (r));
          continue;
        }
      }

      // Yard
      //
      if (n.name () == "Yard" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Yard_type > r (
          Yard_traits::create (i, f, this));

        if (!this->Yard_)
        {
          this->Yard_.set (::std::move (r));
          continue;
        }
      }

      // Power
      //
      if (n.name () == "Power" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->Power_)
        {
          this->Power_.set (Power_traits::create (i, f, this));
          continue;
        }
      }

      // EtaPTI
      //
      if (n.name () == "EtaPTI" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->EtaPTI_)
        {
          this->EtaPTI_.set (EtaPTI_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  PTI* PTI::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class PTI (*this, f, c);
  }

  PTI& PTI::
  operator= (const PTI& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->SysNo_ = x.SysNo_;
      this->Yard_ = x.Yard_;
      this->Power_ = x.Power_;
      this->EtaPTI_ = x.EtaPTI_;
    }

    return *this;
  }

  PTI::
  ~PTI ()
  {
  }

  // PTO
  //

  PTO::
  PTO (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    SysNo_ (this),
    Yard_ (this),
    Power_ (this)
  {
  }

  PTO::
  PTO (const PTO& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    SysNo_ (x.SysNo_, f, this),
    Yard_ (x.Yard_, f, this),
    Power_ (x.Power_, f, this)
  {
  }

  PTO::
  PTO (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    SysNo_ (this),
    Yard_ (this),
    Power_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void PTO::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ID
      //
      if (n.name () == "ID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

        if (!ID_.present ())
        {
          this->ID_.set (::std::move (r));
          continue;
        }
      }

      // SysNo
      //
      if (n.name () == "SysNo" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< SysNo_type > r (
          SysNo_traits::create (i, f, this));

        if (!this->SysNo_)
        {
          this->SysNo_.set (::std::move (r));
          continue;
        }
      }

      // Yard
      //
      if (n.name () == "Yard" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< Yard_type > r (
          Yard_traits::create (i, f, this));

        if (!this->Yard_)
        {
          this->Yard_.set (::std::move (r));
          continue;
        }
      }

      // Power
      //
      if (n.name () == "Power" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->Power_)
        {
          this->Power_.set (Power_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  PTO* PTO::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class PTO (*this, f, c);
  }

  PTO& PTO::
  operator= (const PTO& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->SysNo_ = x.SysNo_;
      this->Yard_ = x.Yard_;
      this->Power_ = x.Power_;
    }

    return *this;
  }

  PTO::
  ~PTO ()
  {
  }

  // Propelor
  //

  Propelor::
  Propelor (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    PType_ (this),
    PBlade_ (this),
    DIA_ (this)
  {
  }

  Propelor::
  Propelor (const Propelor& x,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    PType_ (x.PType_, f, this),
    PBlade_ (x.PBlade_, f, this),
    DIA_ (x.DIA_, f, this)
  {
  }

  Propelor::
  Propelor (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    PType_ (this),
    PBlade_ (this),
    DIA_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void Propelor::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    for (; p.more_content (); p.next_content (false))
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // ID
      //
      if (n.name () == "ID" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

        if (!ID_.present ())
        {
          this->ID_.set (::std::move (r));
          continue;
        }
      }

      // PType
      //
      if (n.name () == "PType" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        ::std::unique_ptr< PType_type > r (
          PType_traits::create (i, f, this));

        if (!this->PType_)
        {
          this->PType_.set (::std::move (r));
          continue;
        }
      }

      // PBlade
      //
      if (n.name () == "PBlade" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->PBlade_)
        {
          this->PBlade_.set (PBlade_traits::create (i, f, this));
          continue;
        }
      }

      // DIA
      //
      if (n.name () == "DIA" && n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
      {
        if (!this->DIA_)
        {
          this->DIA_.set (DIA_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  Propelor* Propelor::
  _clone (::xml_schema::flags f,
          ::xml_schema::container* c) const
  {
    return new class Propelor (*this, f, c);
  }

  Propelor& Propelor::
  operator= (const Propelor& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->PType_ = x.PType_;
      this->PBlade_ = x.PBlade_;
      this->DIA_ = x.DIA_;
    }

    return *this;
  }

  Propelor::
  ~Propelor ()
  {
  }
}

#include <istream>
#include <xsd/cxx/xml/sax/std-input-source.hxx>
#include <xsd/cxx/tree/error-handler.hxx>

namespace eedimodel_ds
{
  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::std::string& u,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xsd::cxx::tree::error_handler< char > h;

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

    h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::std::string& u,
                ::xml_schema::error_handler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

    if (!d.get ())
      throw ::xsd::cxx::tree::parsing< char > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::std::string& u,
                ::xercesc::DOMErrorHandler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

    if (!d.get ())
      throw ::xsd::cxx::tree::parsing< char > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xml_schema::error_handler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                ::xercesc::DOMErrorHandler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                const ::std::string& sid,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                const ::std::string& sid,
                ::xml_schema::error_handler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0,
      (f & ::xml_schema::flags::keep_dom) == 0);

    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::std::istream& is,
                const ::std::string& sid,
                ::xercesc::DOMErrorHandler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::eedimodel_ds::EEDIModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xercesc::InputSource& i,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

    h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xercesc::InputSource& i,
                ::xml_schema::error_handler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

    if (!d.get ())
      throw ::xsd::cxx::tree::parsing< char > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xercesc::InputSource& i,
                ::xercesc::DOMErrorHandler& h,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

    if (!d.get ())
      throw ::xsd::cxx::tree::parsing< char > ();

    return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
      ::eedimodel_ds::EEDIModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (const ::xercesc::DOMDocument& doc,
                ::xml_schema::flags f,
                const ::xml_schema::properties& p)
  {
    if (f & ::xml_schema::flags::keep_dom)
    {
      ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
        static_cast< ::xercesc::DOMDocument* > (doc.cloneNode (true)));

      return ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > (
        ::eedimodel_ds::EEDIModelDS_ (
          std::move (d), f | ::xml_schema::flags::own_dom, p));
    }

    const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "EEDIModelDS" &&
        n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
    {
      ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > r (
        ::xsd::cxx::tree::traits< ::eedimodel_ds::EEDIModelDS, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "EEDIModelDS",
      "http://tempuri.org/EEDIModelDS.xsd");
  }

  ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS >
  EEDIModelDS_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                ::xml_schema::flags f,
                const ::xml_schema::properties&)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > c (
      ((f & ::xml_schema::flags::keep_dom) &&
       !(f & ::xml_schema::flags::own_dom))
      ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
    const ::xercesc::DOMElement& e (*doc.getDocumentElement ());

    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (f & ::xml_schema::flags::keep_dom)
      doc.setUserData (::xml_schema::dom::tree_node_key,
                       (c.get () ? &c : &d),
                       0);

    if (n.name () == "EEDIModelDS" &&
        n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
    {
      ::std::unique_ptr< ::eedimodel_ds::EEDIModelDS > r (
        ::xsd::cxx::tree::traits< ::eedimodel_ds::EEDIModelDS, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "EEDIModelDS",
      "http://tempuri.org/EEDIModelDS.xsd");
  }
}

#include <ostream>
#include <xsd/cxx/tree/error-handler.hxx>
#include <xsd/cxx/xml/dom/serialization-source.hxx>

namespace eedimodel_ds
{
  void
  EEDIModelDS_ (::std::ostream& o,
                const ::eedimodel_ds::EEDIModelDS& s,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0);

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));

    ::xsd::cxx::tree::error_handler< char > h;

    ::xsd::cxx::xml::dom::ostream_format_target t (o);
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
    }
  }

  void
  EEDIModelDS_ (::std::ostream& o,
                const ::eedimodel_ds::EEDIModelDS& s,
                ::xml_schema::error_handler& h,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xsd::cxx::xml::auto_initializer i (
      (f & ::xml_schema::flags::dont_initialize) == 0);

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));
    ::xsd::cxx::xml::dom::ostream_format_target t (o);
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  EEDIModelDS_ (::std::ostream& o,
                const ::eedimodel_ds::EEDIModelDS& s,
                ::xercesc::DOMErrorHandler& h,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));
    ::xsd::cxx::xml::dom::ostream_format_target t (o);
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  EEDIModelDS_ (::xercesc::XMLFormatTarget& t,
                const ::eedimodel_ds::EEDIModelDS& s,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));

    ::xsd::cxx::tree::error_handler< char > h;

    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
    }
  }

  void
  EEDIModelDS_ (::xercesc::XMLFormatTarget& t,
                const ::eedimodel_ds::EEDIModelDS& s,
                ::xml_schema::error_handler& h,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  EEDIModelDS_ (::xercesc::XMLFormatTarget& t,
                const ::eedimodel_ds::EEDIModelDS& s,
                ::xercesc::DOMErrorHandler& h,
                const ::xml_schema::namespace_infomap& m,
                const ::std::string& e,
                ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::eedimodel_ds::EEDIModelDS_ (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  EEDIModelDS_ (::xercesc::DOMDocument& d,
                const ::eedimodel_ds::EEDIModelDS& s,
                ::xml_schema::flags)
  {
    ::xercesc::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "EEDIModelDS" &&
        n.namespace_ () == "http://tempuri.org/EEDIModelDS.xsd")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "EEDIModelDS",
        "http://tempuri.org/EEDIModelDS.xsd");
    }
  }

  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
  EEDIModelDS_ (const ::eedimodel_ds::EEDIModelDS& s,
                const ::xml_schema::namespace_infomap& m,
                ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "EEDIModelDS",
        "http://tempuri.org/EEDIModelDS.xsd",
        m, f));

    ::eedimodel_ds::EEDIModelDS_ (*d, s, f);
    return d;
  }

  void
  operator<< (::xercesc::DOMElement& e, const EEDIModelDS& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // BInf
    //
    for (EEDIModelDS::BInf_const_iterator
         b (i.BInf ().begin ()), n (i.BInf ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::BInf_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "BInf",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }

    // ME
    //
    for (EEDIModelDS::ME_const_iterator
         b (i.ME ().begin ()), n (i.ME ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::ME_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ME",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }

    // AE
    //
    for (EEDIModelDS::AE_const_iterator
         b (i.AE ().begin ()), n (i.AE ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::AE_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "AE",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }

    // PTI
    //
    for (EEDIModelDS::PTI_const_iterator
         b (i.PTI ().begin ()), n (i.PTI ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::PTI_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PTI",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }

    // PTO
    //
    for (EEDIModelDS::PTO_const_iterator
         b (i.PTO ().begin ()), n (i.PTO ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::PTO_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PTO",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }

    // Propelor
    //
    for (EEDIModelDS::Propelor_const_iterator
         b (i.Propelor ().begin ()), n (i.Propelor ().end ());
         b != n; ++b)
    {
      const EEDIModelDS::Propelor_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Propelor",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << x;
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const BInf& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ParamID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ParamID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ParamID ();
    }

    // Unit
    //
    if (i.Unit ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Unit",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Unit ();
    }

    // Caption
    //
    if (i.Caption ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Caption",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Caption ();
    }

    // ValueType
    //
    if (i.ValueType ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ValueType",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.ValueType ();
    }

    // Value
    //
    if (i.Value ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Value",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Value ();
    }

    // Remark
    //
    if (i.Remark ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Remark",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Remark ();
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const ME& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ID ();
    }

    // Yard
    //
    if (i.Yard ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Yard",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Yard ();
    }

    // Type
    //
    if (i.Type ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Type",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Type ();
    }

    // MCR
    //
    if (i.MCR ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "MCR",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.MCR ());
    }

    // MPP
    //
    if (i.MPP ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "MPP",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.MPP ());
    }

    // SFC
    //
    if (i.SFC ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SFC",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.SFC ());
    }

    // FuelType
    //
    if (i.FuelType ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "FuelType",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.FuelType ();
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const AE& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ID ();
    }

    // Yard
    //
    if (i.Yard ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Yard",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Yard ();
    }

    // Type
    //
    if (i.Type ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Type",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Type ();
    }

    // MCR
    //
    if (i.MCR ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "MCR",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.MCR ());
    }

    // MPP
    //
    if (i.MPP ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "MPP",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.MPP ());
    }

    // SFC
    //
    if (i.SFC ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SFC",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.SFC ());
    }

    // FuelType
    //
    if (i.FuelType ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "FuelType",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.FuelType ();
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const PTI& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ID ();
    }

    // SysNo
    //
    if (i.SysNo ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SysNo",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.SysNo ();
    }

    // Yard
    //
    if (i.Yard ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Yard",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Yard ();
    }

    // Power
    //
    if (i.Power ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Power",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.Power ());
    }

    // EtaPTI
    //
    if (i.EtaPTI ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "EtaPTI",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.EtaPTI ());
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const PTO& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ID ();
    }

    // SysNo
    //
    if (i.SysNo ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SysNo",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.SysNo ();
    }

    // Yard
    //
    if (i.Yard ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Yard",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.Yard ();
    }

    // Power
    //
    if (i.Power ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Power",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.Power ());
    }
  }

  void
  operator<< (::xercesc::DOMElement& e, const Propelor& i)
  {
    e << static_cast< const ::xml_schema::type& > (i);

    // ID
    //
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "ID",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << i.ID ();
    }

    // PType
    //
    if (i.PType ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PType",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.PType ();
    }

    // PBlade
    //
    if (i.PBlade ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PBlade",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << *i.PBlade ();
    }

    // DIA
    //
    if (i.DIA ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "DIA",
          "http://tempuri.org/EEDIModelDS.xsd",
          e));

      s << ::xml_schema::as_double(*i.DIA ());
    }
  }
}

#include <xsd/cxx/post.hxx>

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