// 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 "TonnageModelDS.hxx"

namespace tonnagemodel_ds
{
  // TonnageModelDS
  //

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

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

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

  const TonnageModelDS::V1Inf_sequence& TonnageModelDS::
  V1Inf () const
  {
    return this->V1Inf_;
  }

  TonnageModelDS::V1Inf_sequence& TonnageModelDS::
  V1Inf ()
  {
    return this->V1Inf_;
  }

  void TonnageModelDS::
  V1Inf (const V1Inf_sequence& s)
  {
    this->V1Inf_ = s;
  }

  const TonnageModelDS::V1Simpson_sequence& TonnageModelDS::
  V1Simpson () const
  {
    return this->V1Simpson_;
  }

  TonnageModelDS::V1Simpson_sequence& TonnageModelDS::
  V1Simpson ()
  {
    return this->V1Simpson_;
  }

  void TonnageModelDS::
  V1Simpson (const V1Simpson_sequence& s)
  {
    this->V1Simpson_ = s;
  }

  const TonnageModelDS::V2Simpson_sequence& TonnageModelDS::
  V2Simpson () const
  {
    return this->V2Simpson_;
  }

  TonnageModelDS::V2Simpson_sequence& TonnageModelDS::
  V2Simpson ()
  {
    return this->V2Simpson_;
  }

  void TonnageModelDS::
  V2Simpson (const V2Simpson_sequence& s)
  {
    this->V2Simpson_ = s;
  }

  const TonnageModelDS::V2Block_sequence& TonnageModelDS::
  V2Block () const
  {
    return this->V2Block_;
  }

  TonnageModelDS::V2Block_sequence& TonnageModelDS::
  V2Block ()
  {
    return this->V2Block_;
  }

  void TonnageModelDS::
  V2Block (const V2Block_sequence& s)
  {
    this->V2Block_ = s;
  }

  const TonnageModelDS::V2other_sequence& TonnageModelDS::
  V2other () const
  {
    return this->V2other_;
  }

  TonnageModelDS::V2other_sequence& TonnageModelDS::
  V2other ()
  {
    return this->V2other_;
  }

  void TonnageModelDS::
  V2other (const V2other_sequence& s)
  {
    this->V2other_ = s;
  }

  const TonnageModelDS::V3_sequence& TonnageModelDS::
  V3 () const
  {
    return this->V3_;
  }

  TonnageModelDS::V3_sequence& TonnageModelDS::
  V3 ()
  {
    return this->V3_;
  }

  void TonnageModelDS::
  V3 (const V3_sequence& s)
  {
    this->V3_ = s;
  }

  const TonnageModelDS::V43_sequence& TonnageModelDS::
  V43 () const
  {
    return this->V43_;
  }

  TonnageModelDS::V43_sequence& TonnageModelDS::
  V43 ()
  {
    return this->V43_;
  }

  void TonnageModelDS::
  V43 (const V43_sequence& s)
  {
    this->V43_ = s;
  }

  const TonnageModelDS::V41_sequence& TonnageModelDS::
  V41 () const
  {
    return this->V41_;
  }

  TonnageModelDS::V41_sequence& TonnageModelDS::
  V41 ()
  {
    return this->V41_;
  }

  void TonnageModelDS::
  V41 (const V41_sequence& s)
  {
    this->V41_ = s;
  }

  const TonnageModelDS::V42_sequence& TonnageModelDS::
  V42 () const
  {
    return this->V42_;
  }

  TonnageModelDS::V42_sequence& TonnageModelDS::
  V42 ()
  {
    return this->V42_;
  }

  void TonnageModelDS::
  V42 (const V42_sequence& s)
  {
    this->V42_ = s;
  }

  const TonnageModelDS::V43Total_sequence& TonnageModelDS::
  V43Total () const
  {
    return this->V43Total_;
  }

  TonnageModelDS::V43Total_sequence& TonnageModelDS::
  V43Total ()
  {
    return this->V43Total_;
  }

  void TonnageModelDS::
  V43Total (const V43Total_sequence& s)
  {
    this->V43Total_ = s;
  }

  const TonnageModelDS::V5_sequence& TonnageModelDS::
  V5 () const
  {
    return this->V5_;
  }

  TonnageModelDS::V5_sequence& TonnageModelDS::
  V5 ()
  {
    return this->V5_;
  }

  void TonnageModelDS::
  V5 (const V5_sequence& s)
  {
    this->V5_ = s;
  }

  const TonnageModelDS::V2Entity_sequence& TonnageModelDS::
  V2Entity () const
  {
    return this->V2Entity_;
  }

  TonnageModelDS::V2Entity_sequence& TonnageModelDS::
  V2Entity ()
  {
    return this->V2Entity_;
  }

  void TonnageModelDS::
  V2Entity (const V2Entity_sequence& s)
  {
    this->V2Entity_ = s;
  }

  const TonnageModelDS::V1Entity_sequence& TonnageModelDS::
  V1Entity () const
  {
    return this->V1Entity_;
  }

  TonnageModelDS::V1Entity_sequence& TonnageModelDS::
  V1Entity ()
  {
    return this->V1Entity_;
  }

  void TonnageModelDS::
  V1Entity (const V1Entity_sequence& s)
  {
    this->V1Entity_ = 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));
  }


  // V1Inf
  //

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


  // V1Simpson
  //

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

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

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

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

  const V1Simpson::V_optional& V1Simpson::
  V () const
  {
    return this->V_;
  }

  V1Simpson::V_optional& V1Simpson::
  V ()
  {
    return this->V_;
  }

  void V1Simpson::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V1Simpson::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

  const V1Simpson::L_optional& V1Simpson::
  L () const
  {
    return this->L_;
  }

  V1Simpson::L_optional& V1Simpson::
  L ()
  {
    return this->L_;
  }

  void V1Simpson::
  L (const L_type& x)
  {
    this->L_.set (x);
  }

  void V1Simpson::
  L (const L_optional& x)
  {
    this->L_ = x;
  }

  const V1Simpson::n_optional& V1Simpson::
  n () const
  {
    return this->n_;
  }

  V1Simpson::n_optional& V1Simpson::
  n ()
  {
    return this->n_;
  }

  void V1Simpson::
  n (const n_type& x)
  {
    this->n_.set (x);
  }

  void V1Simpson::
  n (const n_optional& x)
  {
    this->n_ = x;
  }

  const V1Simpson::SParam_optional& V1Simpson::
  SParam () const
  {
    return this->SParam_;
  }

  V1Simpson::SParam_optional& V1Simpson::
  SParam ()
  {
    return this->SParam_;
  }

  void V1Simpson::
  SParam (const SParam_type& x)
  {
    this->SParam_.set (x);
  }

  void V1Simpson::
  SParam (const SParam_optional& x)
  {
    this->SParam_ = x;
  }

  void V1Simpson::
  SParam (::std::unique_ptr< SParam_type > x)
  {
    this->SParam_.set (std::move (x));
  }


  // V2Simpson
  //

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

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

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

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

  const V2Simpson::V_optional& V2Simpson::
  V () const
  {
    return this->V_;
  }

  V2Simpson::V_optional& V2Simpson::
  V ()
  {
    return this->V_;
  }

  void V2Simpson::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V2Simpson::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

  const V2Simpson::L_optional& V2Simpson::
  L () const
  {
    return this->L_;
  }

  V2Simpson::L_optional& V2Simpson::
  L ()
  {
    return this->L_;
  }

  void V2Simpson::
  L (const L_type& x)
  {
    this->L_.set (x);
  }

  void V2Simpson::
  L (const L_optional& x)
  {
    this->L_ = x;
  }

  const V2Simpson::n_optional& V2Simpson::
  n () const
  {
    return this->n_;
  }

  V2Simpson::n_optional& V2Simpson::
  n ()
  {
    return this->n_;
  }

  void V2Simpson::
  n (const n_type& x)
  {
    this->n_.set (x);
  }

  void V2Simpson::
  n (const n_optional& x)
  {
    this->n_ = x;
  }

  const V2Simpson::S_optional& V2Simpson::
  S () const
  {
    return this->S_;
  }

  V2Simpson::S_optional& V2Simpson::
  S ()
  {
    return this->S_;
  }

  void V2Simpson::
  S (const S_type& x)
  {
    this->S_.set (x);
  }

  void V2Simpson::
  S (const S_optional& x)
  {
    this->S_ = x;
  }

  const V2Simpson::H_optional& V2Simpson::
  H () const
  {
    return this->H_;
  }

  V2Simpson::H_optional& V2Simpson::
  H ()
  {
    return this->H_;
  }

  void V2Simpson::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V2Simpson::
  H (const H_optional& x)
  {
    this->H_ = x;
  }

  const V2Simpson::BParam_optional& V2Simpson::
  BParam () const
  {
    return this->BParam_;
  }

  V2Simpson::BParam_optional& V2Simpson::
  BParam ()
  {
    return this->BParam_;
  }

  void V2Simpson::
  BParam (const BParam_type& x)
  {
    this->BParam_.set (x);
  }

  void V2Simpson::
  BParam (const BParam_optional& x)
  {
    this->BParam_ = x;
  }

  void V2Simpson::
  BParam (::std::unique_ptr< BParam_type > x)
  {
    this->BParam_.set (std::move (x));
  }

  const V2Simpson::HParam_optional& V2Simpson::
  HParam () const
  {
    return this->HParam_;
  }

  V2Simpson::HParam_optional& V2Simpson::
  HParam ()
  {
    return this->HParam_;
  }

  void V2Simpson::
  HParam (const HParam_type& x)
  {
    this->HParam_.set (x);
  }

  void V2Simpson::
  HParam (const HParam_optional& x)
  {
    this->HParam_ = x;
  }

  void V2Simpson::
  HParam (::std::unique_ptr< HParam_type > x)
  {
    this->HParam_.set (std::move (x));
  }


  // V2Block
  //

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

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

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

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

  const V2Block::V_optional& V2Block::
  V () const
  {
    return this->V_;
  }

  V2Block::V_optional& V2Block::
  V ()
  {
    return this->V_;
  }

  void V2Block::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V2Block::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

  const V2Block::L_optional& V2Block::
  L () const
  {
    return this->L_;
  }

  V2Block::L_optional& V2Block::
  L ()
  {
    return this->L_;
  }

  void V2Block::
  L (const L_type& x)
  {
    this->L_.set (x);
  }

  void V2Block::
  L (const L_optional& x)
  {
    this->L_ = x;
  }

  const V2Block::B_optional& V2Block::
  B () const
  {
    return this->B_;
  }

  V2Block::B_optional& V2Block::
  B ()
  {
    return this->B_;
  }

  void V2Block::
  B (const B_type& x)
  {
    this->B_.set (x);
  }

  void V2Block::
  B (const B_optional& x)
  {
    this->B_ = x;
  }

  const V2Block::H_optional& V2Block::
  H () const
  {
    return this->H_;
  }

  V2Block::H_optional& V2Block::
  H ()
  {
    return this->H_;
  }

  void V2Block::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V2Block::
  H (const H_optional& x)
  {
    this->H_ = x;
  }


  // V2other
  //

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

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

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

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

  const V2other::V_optional& V2other::
  V () const
  {
    return this->V_;
  }

  V2other::V_optional& V2other::
  V ()
  {
    return this->V_;
  }

  void V2other::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V2other::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

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


  // V3
  //

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

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

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

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

  const V3::V_optional& V3::
  V () const
  {
    return this->V_;
  }

  V3::V_optional& V3::
  V ()
  {
    return this->V_;
  }

  void V3::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V3::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

  V3::Type_type V3::
  Type_default_value ()
  {
    return Type_type (1);
  }

  const V3::S_optional& V3::
  S () const
  {
    return this->S_;
  }

  V3::S_optional& V3::
  S ()
  {
    return this->S_;
  }

  void V3::
  S (const S_type& x)
  {
    this->S_.set (x);
  }

  void V3::
  S (const S_optional& x)
  {
    this->S_ = x;
  }

  const V3::H_optional& V3::
  H () const
  {
    return this->H_;
  }

  V3::H_optional& V3::
  H ()
  {
    return this->H_;
  }

  void V3::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V3::
  H (const H_optional& x)
  {
    this->H_ = x;
  }


  // V43
  //

  const V43::Case_type& V43::
  Case () const
  {
    return this->Case_.get ();
  }

  V43::Case_type& V43::
  Case ()
  {
    return this->Case_.get ();
  }

  void V43::
  Case (const Case_type& x)
  {
    this->Case_.set (x);
  }

  void V43::
  Case (::std::unique_ptr< Case_type > x)
  {
    this->Case_.set (std::move (x));
  }

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

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

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

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

  const V43::V_optional& V43::
  V () const
  {
    return this->V_;
  }

  V43::V_optional& V43::
  V ()
  {
    return this->V_;
  }

  void V43::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V43::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

  const V43::S_optional& V43::
  S () const
  {
    return this->S_;
  }

  V43::S_optional& V43::
  S ()
  {
    return this->S_;
  }

  void V43::
  S (const S_type& x)
  {
    this->S_.set (x);
  }

  void V43::
  S (const S_optional& x)
  {
    this->S_ = x;
  }

  const V43::H_optional& V43::
  H () const
  {
    return this->H_;
  }

  V43::H_optional& V43::
  H ()
  {
    return this->H_;
  }

  void V43::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V43::
  H (const H_optional& x)
  {
    this->H_ = x;
  }

  const V43::hc_optional& V43::
  hc () const
  {
    return this->hc_;
  }

  V43::hc_optional& V43::
  hc ()
  {
    return this->hc_;
  }

  void V43::
  hc (const hc_type& x)
  {
    this->hc_.set (x);
  }

  void V43::
  hc (const hc_optional& x)
  {
    this->hc_ = x;
  }


  // V41
  //

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

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

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

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

  const V41::V_optional& V41::
  V () const
  {
    return this->V_;
  }

  V41::V_optional& V41::
  V ()
  {
    return this->V_;
  }

  void V41::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V41::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

  V41::Type_type V41::
  Type_default_value ()
  {
    return Type_type (1);
  }

  const V41::S_optional& V41::
  S () const
  {
    return this->S_;
  }

  V41::S_optional& V41::
  S ()
  {
    return this->S_;
  }

  void V41::
  S (const S_type& x)
  {
    this->S_.set (x);
  }

  void V41::
  S (const S_optional& x)
  {
    this->S_ = x;
  }

  const V41::L_optional& V41::
  L () const
  {
    return this->L_;
  }

  V41::L_optional& V41::
  L ()
  {
    return this->L_;
  }

  void V41::
  L (const L_type& x)
  {
    this->L_.set (x);
  }

  void V41::
  L (const L_optional& x)
  {
    this->L_ = x;
  }

  const V41::B_optional& V41::
  B () const
  {
    return this->B_;
  }

  V41::B_optional& V41::
  B ()
  {
    return this->B_;
  }

  void V41::
  B (const B_type& x)
  {
    this->B_.set (x);
  }

  void V41::
  B (const B_optional& x)
  {
    this->B_ = x;
  }

  const V41::H_optional& V41::
  H () const
  {
    return this->H_;
  }

  V41::H_optional& V41::
  H ()
  {
    return this->H_;
  }

  void V41::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V41::
  H (const H_optional& x)
  {
    this->H_ = x;
  }

  const V41::Ha_optional& V41::
  Ha () const
  {
    return this->Ha_;
  }

  V41::Ha_optional& V41::
  Ha ()
  {
    return this->Ha_;
  }

  void V41::
  Ha (const Ha_type& x)
  {
    this->Ha_.set (x);
  }

  void V41::
  Ha (const Ha_optional& x)
  {
    this->Ha_ = x;
  }


  // V42
  //

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

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

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

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

  const V42::V_optional& V42::
  V () const
  {
    return this->V_;
  }

  V42::V_optional& V42::
  V ()
  {
    return this->V_;
  }

  void V42::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V42::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

  const V42::IsCar_type& V42::
  IsCar () const
  {
    return this->IsCar_.get ();
  }

  V42::IsCar_type& V42::
  IsCar ()
  {
    return this->IsCar_.get ();
  }

  void V42::
  IsCar (const IsCar_type& x)
  {
    this->IsCar_.set (x);
  }

  V42::IsCar_type V42::
  IsCar_default_value ()
  {
    return IsCar_type (false);
  }

  const V42::S_optional& V42::
  S () const
  {
    return this->S_;
  }

  V42::S_optional& V42::
  S ()
  {
    return this->S_;
  }

  void V42::
  S (const S_type& x)
  {
    this->S_.set (x);
  }

  void V42::
  S (const S_optional& x)
  {
    this->S_ = x;
  }

  const V42::H_optional& V42::
  H () const
  {
    return this->H_;
  }

  V42::H_optional& V42::
  H ()
  {
    return this->H_;
  }

  void V42::
  H (const H_type& x)
  {
    this->H_.set (x);
  }

  void V42::
  H (const H_optional& x)
  {
    this->H_ = x;
  }

  const V42::Hv_optional& V42::
  Hv () const
  {
    return this->Hv_;
  }

  V42::Hv_optional& V42::
  Hv ()
  {
    return this->Hv_;
  }

  void V42::
  Hv (const Hv_type& x)
  {
    this->Hv_.set (x);
  }

  void V42::
  Hv (const Hv_optional& x)
  {
    this->Hv_ = x;
  }

  const V42::Ha_optional& V42::
  Ha () const
  {
    return this->Ha_;
  }

  V42::Ha_optional& V42::
  Ha ()
  {
    return this->Ha_;
  }

  void V42::
  Ha (const Ha_type& x)
  {
    this->Ha_.set (x);
  }

  void V42::
  Ha (const Ha_optional& x)
  {
    this->Ha_ = x;
  }


  // V43Total
  //

  const V43Total::Case_type& V43Total::
  Case () const
  {
    return this->Case_.get ();
  }

  V43Total::Case_type& V43Total::
  Case ()
  {
    return this->Case_.get ();
  }

  void V43Total::
  Case (const Case_type& x)
  {
    this->Case_.set (x);
  }

  void V43Total::
  Case (::std::unique_ptr< Case_type > x)
  {
    this->Case_.set (std::move (x));
  }

  const V43Total::V_optional& V43Total::
  V () const
  {
    return this->V_;
  }

  V43Total::V_optional& V43Total::
  V ()
  {
    return this->V_;
  }

  void V43Total::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V43Total::
  V (const V_optional& x)
  {
    this->V_ = x;
  }


  // V5
  //

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

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

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

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

  const V5::V_optional& V5::
  V () const
  {
    return this->V_;
  }

  V5::V_optional& V5::
  V ()
  {
    return this->V_;
  }

  void V5::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V5::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

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


  // V2Entity
  //

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

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

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

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

  const V2Entity::EntityID_optional& V2Entity::
  EntityID () const
  {
    return this->EntityID_;
  }

  V2Entity::EntityID_optional& V2Entity::
  EntityID ()
  {
    return this->EntityID_;
  }

  void V2Entity::
  EntityID (const EntityID_type& x)
  {
    this->EntityID_.set (x);
  }

  void V2Entity::
  EntityID (const EntityID_optional& x)
  {
    this->EntityID_ = x;
  }

  void V2Entity::
  EntityID (::std::unique_ptr< EntityID_type > x)
  {
    this->EntityID_.set (std::move (x));
  }

  const V2Entity::V_optional& V2Entity::
  V () const
  {
    return this->V_;
  }

  V2Entity::V_optional& V2Entity::
  V ()
  {
    return this->V_;
  }

  void V2Entity::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V2Entity::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

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

  const V2Entity::SID_optional& V2Entity::
  SID () const
  {
    return this->SID_;
  }

  V2Entity::SID_optional& V2Entity::
  SID ()
  {
    return this->SID_;
  }

  void V2Entity::
  SID (const SID_type& x)
  {
    this->SID_.set (x);
  }

  void V2Entity::
  SID (const SID_optional& x)
  {
    this->SID_ = x;
  }


  // V1Entity
  //

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

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

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

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

  const V1Entity::EntityID_optional& V1Entity::
  EntityID () const
  {
    return this->EntityID_;
  }

  V1Entity::EntityID_optional& V1Entity::
  EntityID ()
  {
    return this->EntityID_;
  }

  void V1Entity::
  EntityID (const EntityID_type& x)
  {
    this->EntityID_.set (x);
  }

  void V1Entity::
  EntityID (const EntityID_optional& x)
  {
    this->EntityID_ = x;
  }

  void V1Entity::
  EntityID (::std::unique_ptr< EntityID_type > x)
  {
    this->EntityID_.set (std::move (x));
  }

  const V1Entity::V_optional& V1Entity::
  V () const
  {
    return this->V_;
  }

  V1Entity::V_optional& V1Entity::
  V ()
  {
    return this->V_;
  }

  void V1Entity::
  V (const V_type& x)
  {
    this->V_.set (x);
  }

  void V1Entity::
  V (const V_optional& x)
  {
    this->V_ = x;
  }

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

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

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

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

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

  const V1Entity::SID_optional& V1Entity::
  SID () const
  {
    return this->SID_;
  }

  V1Entity::SID_optional& V1Entity::
  SID ()
  {
    return this->SID_;
  }

  void V1Entity::
  SID (const SID_type& x)
  {
    this->SID_.set (x);
  }

  void V1Entity::
  SID (const SID_optional& x)
  {
    this->SID_ = x;
  }
}

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

namespace tonnagemodel_ds
{
  // TonnageModelDS
  //

  TonnageModelDS::
  TonnageModelDS ()
  : ::xml_schema::type (),
    BInf_ (this),
    V1Inf_ (this),
    V1Simpson_ (this),
    V2Simpson_ (this),
    V2Block_ (this),
    V2other_ (this),
    V3_ (this),
    V43_ (this),
    V41_ (this),
    V42_ (this),
    V43Total_ (this),
    V5_ (this),
    V2Entity_ (this),
    V1Entity_ (this)
  {
  }

  TonnageModelDS::
  TonnageModelDS (const TonnageModelDS& x,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    BInf_ (x.BInf_, f, this),
    V1Inf_ (x.V1Inf_, f, this),
    V1Simpson_ (x.V1Simpson_, f, this),
    V2Simpson_ (x.V2Simpson_, f, this),
    V2Block_ (x.V2Block_, f, this),
    V2other_ (x.V2other_, f, this),
    V3_ (x.V3_, f, this),
    V43_ (x.V43_, f, this),
    V41_ (x.V41_, f, this),
    V42_ (x.V42_, f, this),
    V43Total_ (x.V43Total_, f, this),
    V5_ (x.V5_, f, this),
    V2Entity_ (x.V2Entity_, f, this),
    V1Entity_ (x.V1Entity_, f, this)
  {
  }

  TonnageModelDS::
  TonnageModelDS (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    BInf_ (this),
    V1Inf_ (this),
    V1Simpson_ (this),
    V2Simpson_ (this),
    V2Block_ (this),
    V2other_ (this),
    V3_ (this),
    V43_ (this),
    V41_ (this),
    V42_ (this),
    V43Total_ (this),
    V5_ (this),
    V2Entity_ (this),
    V1Entity_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void TonnageModelDS::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< BInf_type > r (
          BInf_traits::create (i, f, this));

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

      // V1Inf
      //
      if (n.name () == "V1Inf" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V1Inf_type > r (
          V1Inf_traits::create (i, f, this));

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

      // V1Simpson
      //
      if (n.name () == "V1Simpson" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V1Simpson_type > r (
          V1Simpson_traits::create (i, f, this));

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

      // V2Simpson
      //
      if (n.name () == "V2Simpson" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V2Simpson_type > r (
          V2Simpson_traits::create (i, f, this));

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

      // V2Block
      //
      if (n.name () == "V2Block" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V2Block_type > r (
          V2Block_traits::create (i, f, this));

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

      // V2other
      //
      if (n.name () == "V2other" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V2other_type > r (
          V2other_traits::create (i, f, this));

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

      // V3
      //
      if (n.name () == "V3" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V3_type > r (
          V3_traits::create (i, f, this));

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

      // V43
      //
      if (n.name () == "V43" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V43_type > r (
          V43_traits::create (i, f, this));

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

      // V41
      //
      if (n.name () == "V41" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V41_type > r (
          V41_traits::create (i, f, this));

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

      // V42
      //
      if (n.name () == "V42" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V42_type > r (
          V42_traits::create (i, f, this));

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

      // V43Total
      //
      if (n.name () == "V43Total" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V43Total_type > r (
          V43Total_traits::create (i, f, this));

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

      // V5
      //
      if (n.name () == "V5" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V5_type > r (
          V5_traits::create (i, f, this));

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

      // V2Entity
      //
      if (n.name () == "V2Entity" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V2Entity_type > r (
          V2Entity_traits::create (i, f, this));

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

      // V1Entity
      //
      if (n.name () == "V1Entity" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< V1Entity_type > r (
          V1Entity_traits::create (i, f, this));

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

      break;
    }
  }

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

  TonnageModelDS& TonnageModelDS::
  operator= (const TonnageModelDS& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->BInf_ = x.BInf_;
      this->V1Inf_ = x.V1Inf_;
      this->V1Simpson_ = x.V1Simpson_;
      this->V2Simpson_ = x.V2Simpson_;
      this->V2Block_ = x.V2Block_;
      this->V2other_ = x.V2other_;
      this->V3_ = x.V3_;
      this->V43_ = x.V43_;
      this->V41_ = x.V41_;
      this->V42_ = x.V42_;
      this->V43Total_ = x.V43Total_;
      this->V5_ = x.V5_;
      this->V2Entity_ = x.V2Entity_;
      this->V1Entity_ = x.V1Entity_;
    }

    return *this;
  }

  TonnageModelDS::
  ~TonnageModelDS ()
  {
  }

  // 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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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 ()
  {
  }

  // V1Inf
  //

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

  V1Inf::
  V1Inf (const V1Inf& 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)
  {
  }

  V1Inf::
  V1Inf (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 V1Inf::
  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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.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/TonnageModelDS.xsd");
    }
  }

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

  V1Inf& V1Inf::
  operator= (const V1Inf& 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;
  }

  V1Inf::
  ~V1Inf ()
  {
  }

  // V1Simpson
  //

  V1Simpson::
  V1Simpson (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    L_ (this),
    n_ (this),
    SParam_ (this)
  {
  }

  V1Simpson::
  V1Simpson (const V1Simpson& x,
             ::xml_schema::flags f,
             ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    L_ (x.L_, f, this),
    n_ (x.n_, f, this),
    SParam_ (x.SParam_, f, this)
  {
  }

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

  void V1Simpson::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // L
      //
      if (n.name () == "L" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->L_)
        {
          this->L_.set (L_traits::create (i, f, this));
          continue;
        }
      }

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

      // SParam
      //
      if (n.name () == "SParam" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< SParam_type > r (
          SParam_traits::create (i, f, this));

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

      break;
    }

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

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

  V1Simpson& V1Simpson::
  operator= (const V1Simpson& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->L_ = x.L_;
      this->n_ = x.n_;
      this->SParam_ = x.SParam_;
    }

    return *this;
  }

  V1Simpson::
  ~V1Simpson ()
  {
  }

  // V2Simpson
  //

  V2Simpson::
  V2Simpson (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    L_ (this),
    n_ (this),
    S_ (this),
    H_ (this),
    BParam_ (this),
    HParam_ (this)
  {
  }

  V2Simpson::
  V2Simpson (const V2Simpson& x,
             ::xml_schema::flags f,
             ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    L_ (x.L_, f, this),
    n_ (x.n_, f, this),
    S_ (x.S_, f, this),
    H_ (x.H_, f, this),
    BParam_ (x.BParam_, f, this),
    HParam_ (x.HParam_, f, this)
  {
  }

  V2Simpson::
  V2Simpson (const ::xercesc::DOMElement& e,
             ::xml_schema::flags f,
             ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    V_ (this),
    L_ (this),
    n_ (this),
    S_ (this),
    H_ (this),
    BParam_ (this),
    HParam_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void V2Simpson::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // L
      //
      if (n.name () == "L" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->L_)
        {
          this->L_.set (L_traits::create (i, f, this));
          continue;
        }
      }

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

      // S
      //
      if (n.name () == "S" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->S_)
        {
          this->S_.set (S_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      // BParam
      //
      if (n.name () == "BParam" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< BParam_type > r (
          BParam_traits::create (i, f, this));

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

      // HParam
      //
      if (n.name () == "HParam" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< HParam_type > r (
          HParam_traits::create (i, f, this));

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

      break;
    }

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

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

  V2Simpson& V2Simpson::
  operator= (const V2Simpson& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->L_ = x.L_;
      this->n_ = x.n_;
      this->S_ = x.S_;
      this->H_ = x.H_;
      this->BParam_ = x.BParam_;
      this->HParam_ = x.HParam_;
    }

    return *this;
  }

  V2Simpson::
  ~V2Simpson ()
  {
  }

  // V2Block
  //

  V2Block::
  V2Block (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    L_ (this),
    B_ (this),
    H_ (this)
  {
  }

  V2Block::
  V2Block (const V2Block& x,
           ::xml_schema::flags f,
           ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    L_ (x.L_, f, this),
    B_ (x.B_, f, this),
    H_ (x.H_, f, this)
  {
  }

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

  void V2Block::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // L
      //
      if (n.name () == "L" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->L_)
        {
          this->L_.set (L_traits::create (i, f, this));
          continue;
        }
      }

      // B
      //
      if (n.name () == "B" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->B_)
        {
          this->B_.set (B_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V2Block& V2Block::
  operator= (const V2Block& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->L_ = x.L_;
      this->B_ = x.B_;
      this->H_ = x.H_;
    }

    return *this;
  }

  V2Block::
  ~V2Block ()
  {
  }

  // V2other
  //

  V2other::
  V2other (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    Remark_ (this)
  {
  }

  V2other::
  V2other (const V2other& x,
           ::xml_schema::flags f,
           ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    Remark_ (x.Remark_, f, this)
  {
  }

  V2other::
  V2other (const ::xercesc::DOMElement& e,
           ::xml_schema::flags f,
           ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    V_ (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 V2other::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // Remark
      //
      if (n.name () == "Remark" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.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 (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/TonnageModelDS.xsd");
    }
  }

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

  V2other& V2other::
  operator= (const V2other& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->Remark_ = x.Remark_;
    }

    return *this;
  }

  V2other::
  ~V2other ()
  {
  }

  // V3
  //

  V3::
  V3 (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    Type_ (this),
    S_ (this),
    H_ (this)
  {
  }

  V3::
  V3 (const V3& x,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    Type_ (x.Type_, f, this),
    S_ (x.S_, f, this),
    H_ (x.H_, f, this)
  {
  }

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

  void V3::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // Type
      //
      if (n.name () == "Type" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->Type_)
        {
          this->Type_.set (Type_traits::create (i, f, this));
          continue;
        }
      }

      // S
      //
      if (n.name () == "S" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->S_)
        {
          this->S_.set (S_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V3& V3::
  operator= (const V3& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->Type_ = x.Type_;
      this->S_ = x.S_;
      this->H_ = x.H_;
    }

    return *this;
  }

  V3::
  ~V3 ()
  {
  }

  // V43
  //

  V43::
  V43 (const Case_type& Case,
       const ID_type& ID)
  : ::xml_schema::type (),
    Case_ (Case, this),
    ID_ (ID, this),
    V_ (this),
    S_ (this),
    H_ (this),
    hc_ (this)
  {
  }

  V43::
  V43 (const V43& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    Case_ (x.Case_, f, this),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    S_ (x.S_, f, this),
    H_ (x.H_, f, this),
    hc_ (x.hc_, f, this)
  {
  }

  V43::
  V43 (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    Case_ (this),
    ID_ (this),
    V_ (this),
    S_ (this),
    H_ (this),
    hc_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void V43::
  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));

      // Case
      //
      if (n.name () == "Case" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< Case_type > r (
          Case_traits::create (i, f, this));

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

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

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // S
      //
      if (n.name () == "S" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->S_)
        {
          this->S_.set (S_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      // hc
      //
      if (n.name () == "hc" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->hc_)
        {
          this->hc_.set (hc_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

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

  V43& V43::
  operator= (const V43& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->Case_ = x.Case_;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->S_ = x.S_;
      this->H_ = x.H_;
      this->hc_ = x.hc_;
    }

    return *this;
  }

  V43::
  ~V43 ()
  {
  }

  // V41
  //

  V41::
  V41 (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    Type_ (this),
    S_ (this),
    L_ (this),
    B_ (this),
    H_ (this),
    Ha_ (this)
  {
  }

  V41::
  V41 (const V41& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    Type_ (x.Type_, f, this),
    S_ (x.S_, f, this),
    L_ (x.L_, f, this),
    B_ (x.B_, f, this),
    H_ (x.H_, f, this),
    Ha_ (x.Ha_, f, this)
  {
  }

  V41::
  V41 (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    V_ (this),
    Type_ (this),
    S_ (this),
    L_ (this),
    B_ (this),
    H_ (this),
    Ha_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void V41::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // Type
      //
      if (n.name () == "Type" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->Type_)
        {
          this->Type_.set (Type_traits::create (i, f, this));
          continue;
        }
      }

      // S
      //
      if (n.name () == "S" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->S_)
        {
          this->S_.set (S_traits::create (i, f, this));
          continue;
        }
      }

      // L
      //
      if (n.name () == "L" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->L_)
        {
          this->L_.set (L_traits::create (i, f, this));
          continue;
        }
      }

      // B
      //
      if (n.name () == "B" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->B_)
        {
          this->B_.set (B_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      // Ha
      //
      if (n.name () == "Ha" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->Ha_)
        {
          this->Ha_.set (Ha_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V41& V41::
  operator= (const V41& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->Type_ = x.Type_;
      this->S_ = x.S_;
      this->L_ = x.L_;
      this->B_ = x.B_;
      this->H_ = x.H_;
      this->Ha_ = x.Ha_;
    }

    return *this;
  }

  V41::
  ~V41 ()
  {
  }

  // V42
  //

  V42::
  V42 (const ID_type& ID,
       const IsCar_type& IsCar)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    IsCar_ (IsCar, this),
    S_ (this),
    H_ (this),
    Hv_ (this),
    Ha_ (this)
  {
  }

  V42::
  V42 (const V42& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    IsCar_ (x.IsCar_, f, this),
    S_ (x.S_, f, this),
    H_ (x.H_, f, this),
    Hv_ (x.Hv_, f, this),
    Ha_ (x.Ha_, f, this)
  {
  }

  V42::
  V42 (const ::xercesc::DOMElement& e,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    V_ (this),
    IsCar_ (this),
    S_ (this),
    H_ (this),
    Hv_ (this),
    Ha_ (this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      this->parse (p, f);
    }
  }

  void V42::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // IsCar
      //
      if (n.name () == "IsCar" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!IsCar_.present ())
        {
          this->IsCar_.set (IsCar_traits::create (i, f, this));
          continue;
        }
      }

      // S
      //
      if (n.name () == "S" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->S_)
        {
          this->S_.set (S_traits::create (i, f, this));
          continue;
        }
      }

      // H
      //
      if (n.name () == "H" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->H_)
        {
          this->H_.set (H_traits::create (i, f, this));
          continue;
        }
      }

      // Hv
      //
      if (n.name () == "Hv" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->Hv_)
        {
          this->Hv_.set (Hv_traits::create (i, f, this));
          continue;
        }
      }

      // Ha
      //
      if (n.name () == "Ha" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->Ha_)
        {
          this->Ha_.set (Ha_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

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

  V42& V42::
  operator= (const V42& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->IsCar_ = x.IsCar_;
      this->S_ = x.S_;
      this->H_ = x.H_;
      this->Hv_ = x.Hv_;
      this->Ha_ = x.Ha_;
    }

    return *this;
  }

  V42::
  ~V42 ()
  {
  }

  // V43Total
  //

  V43Total::
  V43Total (const Case_type& Case)
  : ::xml_schema::type (),
    Case_ (Case, this),
    V_ (this)
  {
  }

  V43Total::
  V43Total (const V43Total& x,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    Case_ (x.Case_, f, this),
    V_ (x.V_, f, this)
  {
  }

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

  void V43Total::
  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));

      // Case
      //
      if (n.name () == "Case" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< Case_type > r (
          Case_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V43Total& V43Total::
  operator= (const V43Total& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->Case_ = x.Case_;
      this->V_ = x.V_;
    }

    return *this;
  }

  V43Total::
  ~V43Total ()
  {
  }

  // V5
  //

  V5::
  V5 (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    V_ (this),
    Remark_ (this)
  {
  }

  V5::
  V5 (const V5& x,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    V_ (x.V_, f, this),
    Remark_ (x.Remark_, f, this)
  {
  }

  V5::
  V5 (const ::xercesc::DOMElement& e,
      ::xml_schema::flags f,
      ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    ID_ (this),
    V_ (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 V5::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

      // Remark
      //
      if (n.name () == "Remark" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.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 (!ID_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "ID",
        "http://tempuri.org/TonnageModelDS.xsd");
    }
  }

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

  V5& V5::
  operator= (const V5& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->V_ = x.V_;
      this->Remark_ = x.Remark_;
    }

    return *this;
  }

  V5::
  ~V5 ()
  {
  }

  // V2Entity
  //

  V2Entity::
  V2Entity (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    EntityID_ (this),
    V_ (this),
    Remark_ (this),
    SID_ (this)
  {
  }

  V2Entity::
  V2Entity (const V2Entity& x,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    EntityID_ (x.EntityID_, f, this),
    V_ (x.V_, f, this),
    Remark_ (x.Remark_, f, this),
    SID_ (x.SID_, f, this)
  {
  }

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

  void V2Entity::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // EntityID
      //
      if (n.name () == "EntityID" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< EntityID_type > r (
          EntityID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

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

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

      // SID
      //
      if (n.name () == "SID" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->SID_)
        {
          this->SID_.set (SID_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V2Entity& V2Entity::
  operator= (const V2Entity& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->EntityID_ = x.EntityID_;
      this->V_ = x.V_;
      this->Remark_ = x.Remark_;
      this->SID_ = x.SID_;
    }

    return *this;
  }

  V2Entity::
  ~V2Entity ()
  {
  }

  // V1Entity
  //

  V1Entity::
  V1Entity (const ID_type& ID)
  : ::xml_schema::type (),
    ID_ (ID, this),
    EntityID_ (this),
    V_ (this),
    Remark_ (this),
    SID_ (this)
  {
  }

  V1Entity::
  V1Entity (const V1Entity& x,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    ID_ (x.ID_, f, this),
    EntityID_ (x.EntityID_, f, this),
    V_ (x.V_, f, this),
    Remark_ (x.Remark_, f, this),
    SID_ (x.SID_, f, this)
  {
  }

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

  void V1Entity::
  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/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< ID_type > r (
          ID_traits::create (i, f, this));

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

      // EntityID
      //
      if (n.name () == "EntityID" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        ::std::unique_ptr< EntityID_type > r (
          EntityID_traits::create (i, f, this));

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

      // V
      //
      if (n.name () == "V" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->V_)
        {
          this->V_.set (V_traits::create (i, f, this));
          continue;
        }
      }

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

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

      // SID
      //
      if (n.name () == "SID" && n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
      {
        if (!this->SID_)
        {
          this->SID_.set (SID_traits::create (i, f, this));
          continue;
        }
      }

      break;
    }

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

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

  V1Entity& V1Entity::
  operator= (const V1Entity& x)
  {
    if (this != &x)
    {
      static_cast< ::xml_schema::type& > (*this) = x;
      this->ID_ = x.ID_;
      this->EntityID_ = x.EntityID_;
      this->V_ = x.V_;
      this->Remark_ = x.Remark_;
      this->SID_ = x.SID_;
    }

    return *this;
  }

  V1Entity::
  ~V1Entity ()
  {
  }
}

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

namespace tonnagemodel_ds
{
  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 ::tonnagemodel_ds::TonnageModelDS_ (isrc, h, f, p);
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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< ::tonnagemodel_ds::TonnageModelDS > (
      ::tonnagemodel_ds::TonnageModelDS_ (
        std::move (d), f | ::xml_schema::flags::own_dom, p));
  }

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (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< ::tonnagemodel_ds::TonnageModelDS > (
        ::tonnagemodel_ds::TonnageModelDS_ (
          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 () == "TonnageModelDS" &&
        n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
    {
      ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS > r (
        ::xsd::cxx::tree::traits< ::tonnagemodel_ds::TonnageModelDS, char >::create (
          e, f, 0));
      return r;
    }

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

  ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS >
  TonnageModelDS_ (::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 () == "TonnageModelDS" &&
        n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
    {
      ::std::unique_ptr< ::tonnagemodel_ds::TonnageModelDS > r (
        ::xsd::cxx::tree::traits< ::tonnagemodel_ds::TonnageModelDS, char >::create (
          e, f, 0));
      return r;
    }

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

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

namespace tonnagemodel_ds
{
  void
  TonnageModelDS_ (::std::ostream& o,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 (
      ::tonnagemodel_ds::TonnageModelDS_ (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
  TonnageModelDS_ (::std::ostream& o,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 (
      ::tonnagemodel_ds::TonnageModelDS_ (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
  TonnageModelDS_ (::std::ostream& o,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 (
      ::tonnagemodel_ds::TonnageModelDS_ (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
  TonnageModelDS_ (::xercesc::XMLFormatTarget& t,
                   const ::tonnagemodel_ds::TonnageModelDS& s,
                   const ::xml_schema::namespace_infomap& m,
                   const ::std::string& e,
                   ::xml_schema::flags f)
  {
    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
      ::tonnagemodel_ds::TonnageModelDS_ (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
  TonnageModelDS_ (::xercesc::XMLFormatTarget& t,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 (
      ::tonnagemodel_ds::TonnageModelDS_ (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  TonnageModelDS_ (::xercesc::XMLFormatTarget& t,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 (
      ::tonnagemodel_ds::TonnageModelDS_ (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  TonnageModelDS_ (::xercesc::DOMDocument& d,
                   const ::tonnagemodel_ds::TonnageModelDS& 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 () == "TonnageModelDS" &&
        n.namespace_ () == "http://tempuri.org/TonnageModelDS.xsd")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "TonnageModelDS",
        "http://tempuri.org/TonnageModelDS.xsd");
    }
  }

  ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
  TonnageModelDS_ (const ::tonnagemodel_ds::TonnageModelDS& 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 > (
        "TonnageModelDS",
        "http://tempuri.org/TonnageModelDS.xsd",
        m, f));

    ::tonnagemodel_ds::TonnageModelDS_ (*d, s, f);
    return d;
  }

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

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

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

      s << x;
    }

    // V1Inf
    //
    for (TonnageModelDS::V1Inf_const_iterator
         b (i.V1Inf ().begin ()), n (i.V1Inf ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V1Inf_type& x (*b);

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

      s << x;
    }

    // V1Simpson
    //
    for (TonnageModelDS::V1Simpson_const_iterator
         b (i.V1Simpson ().begin ()), n (i.V1Simpson ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V1Simpson_type& x (*b);

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

      s << x;
    }

    // V2Simpson
    //
    for (TonnageModelDS::V2Simpson_const_iterator
         b (i.V2Simpson ().begin ()), n (i.V2Simpson ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V2Simpson_type& x (*b);

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

      s << x;
    }

    // V2Block
    //
    for (TonnageModelDS::V2Block_const_iterator
         b (i.V2Block ().begin ()), n (i.V2Block ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V2Block_type& x (*b);

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

      s << x;
    }

    // V2other
    //
    for (TonnageModelDS::V2other_const_iterator
         b (i.V2other ().begin ()), n (i.V2other ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V2other_type& x (*b);

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

      s << x;
    }

    // V3
    //
    for (TonnageModelDS::V3_const_iterator
         b (i.V3 ().begin ()), n (i.V3 ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V3_type& x (*b);

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

      s << x;
    }

    // V43
    //
    for (TonnageModelDS::V43_const_iterator
         b (i.V43 ().begin ()), n (i.V43 ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V43_type& x (*b);

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

      s << x;
    }

    // V41
    //
    for (TonnageModelDS::V41_const_iterator
         b (i.V41 ().begin ()), n (i.V41 ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V41_type& x (*b);

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

      s << x;
    }

    // V42
    //
    for (TonnageModelDS::V42_const_iterator
         b (i.V42 ().begin ()), n (i.V42 ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V42_type& x (*b);

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

      s << x;
    }

    // V43Total
    //
    for (TonnageModelDS::V43Total_const_iterator
         b (i.V43Total ().begin ()), n (i.V43Total ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V43Total_type& x (*b);

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

      s << x;
    }

    // V5
    //
    for (TonnageModelDS::V5_const_iterator
         b (i.V5 ().begin ()), n (i.V5 ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V5_type& x (*b);

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

      s << x;
    }

    // V2Entity
    //
    for (TonnageModelDS::V2Entity_const_iterator
         b (i.V2Entity ().begin ()), n (i.V2Entity ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V2Entity_type& x (*b);

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

      s << x;
    }

    // V1Entity
    //
    for (TonnageModelDS::V1Entity_const_iterator
         b (i.V1Entity ().begin ()), n (i.V1Entity ().end ());
         b != n; ++b)
    {
      const TonnageModelDS::V1Entity_type& x (*b);

      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "V1Entity",
          "http://tempuri.org/TonnageModelDS.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/TonnageModelDS.xsd",
          e));

      s << i.ParamID ();
    }

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

      s << *i.Unit ();
    }

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

      s << *i.Caption ();
    }

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

      s << *i.ValueType ();
    }

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

      s << *i.Value ();
    }

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

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

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

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

      s << i.ParamID ();
    }

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

      s << *i.Unit ();
    }

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

      s << *i.Caption ();
    }

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

      s << *i.ValueType ();
    }

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

      s << *i.Value ();
    }

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

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

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

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

      s << i.ID ();
    }

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

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

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

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

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

      s << *i.n ();
    }

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

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

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

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

      s << i.ID ();
    }

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

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

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

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

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

      s << *i.n ();
    }

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

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

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

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

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

      s << *i.BParam ();
    }

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

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

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

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

      s << i.ID ();
    }

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

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

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

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

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

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

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

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

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

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

      s << i.ID ();
    }

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

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

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

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

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

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

      s << i.ID ();
    }

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

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

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

      s << *i.Type ();
    }

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

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

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

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

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

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

      s << i.Case ();
    }

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

      s << i.ID ();
    }

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

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

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

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

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

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

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

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

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

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

      s << i.ID ();
    }

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

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

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

      s << *i.Type ();
    }

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

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

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

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

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

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

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

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

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

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

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

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

      s << i.ID ();
    }

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

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

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

      s << i.IsCar ();
    }

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

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

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

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

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

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

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

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

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

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

      s << i.Case ();
    }

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

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

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

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

      s << i.ID ();
    }

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

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

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

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

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

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

      s << i.ID ();
    }

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

      s << *i.EntityID ();
    }

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

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

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

      s << *i.Remark ();
    }

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

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

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

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

      s << i.ID ();
    }

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

      s << *i.EntityID ();
    }

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

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

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

      s << *i.Remark ();
    }

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

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

#include <xsd/cxx/post.hxx>

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