solution_h2d_xml.cpp

// Copyright (C) 2005-2010 Code Synthesis Tools CC
//
// 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 Tools CC 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 Tools CC 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 "solution_h2d_xml.h"

namespace XMLSolution
{
  // solution
  // 

  const solution::mono_coeffs_sequence& solution::
  mono_coeffs () const
  {
    return this->mono_coeffs_;
  }

  solution::mono_coeffs_sequence& solution::
  mono_coeffs ()
  {
    return this->mono_coeffs_;
  }

  void solution::
  mono_coeffs (const mono_coeffs_sequence& s)
  {
    this->mono_coeffs_ = s;
  }

  const solution::elem_orders_sequence& solution::
  elem_orders () const
  {
    return this->elem_orders_;
  }

  solution::elem_orders_sequence& solution::
  elem_orders ()
  {
    return this->elem_orders_;
  }

  void solution::
  elem_orders (const elem_orders_sequence& s)
  {
    this->elem_orders_ = s;
  }

  const solution::component_sequence& solution::
  component () const
  {
    return this->component_;
  }

  solution::component_sequence& solution::
  component ()
  {
    return this->component_;
  }

  void solution::
  component (const component_sequence& s)
  {
    this->component_ = s;
  }

  const solution::ncmp_type& solution::
  ncmp () const
  {
    return this->ncmp_.get ();
  }

  solution::ncmp_type& solution::
  ncmp ()
  {
    return this->ncmp_.get ();
  }

  void solution::
  ncmp (const ncmp_type& x)
  {
    this->ncmp_.set (x);
  }

  const solution::nel_type& solution::
  nel () const
  {
    return this->nel_.get ();
  }

  solution::nel_type& solution::
  nel ()
  {
    return this->nel_.get ();
  }

  void solution::
  nel (const nel_type& x)
  {
    this->nel_.set (x);
  }

  const solution::nc_type& solution::
  nc () const
  {
    return this->nc_.get ();
  }

  solution::nc_type& solution::
  nc ()
  {
    return this->nc_.get ();
  }

  void solution::
  nc (const nc_type& x)
  {
    this->nc_.set (x);
  }

  const solution::exact_type& solution::
  exact () const
  {
    return this->exact_.get ();
  }

  solution::exact_type& solution::
  exact ()
  {
    return this->exact_.get ();
  }

  void solution::
  exact (const exact_type& x)
  {
    this->exact_.set (x);
  }

  const solution::exactC_type& solution::
  exactC () const
  {
    return this->exactC_.get ();
  }

  solution::exactC_type& solution::
  exactC ()
  {
    return this->exactC_.get ();
  }

  void solution::
  exactC (const exactC_type& x)
  {
    this->exactC_.set (x);
  }

  const solution::exactCXR_optional& solution::
  exactCXR () const
  {
    return this->exactCXR_;
  }

  solution::exactCXR_optional& solution::
  exactCXR ()
  {
    return this->exactCXR_;
  }

  void solution::
  exactCXR (const exactCXR_type& x)
  {
    this->exactCXR_.set (x);
  }

  void solution::
  exactCXR (const exactCXR_optional& x)
  {
    this->exactCXR_ = x;
  }

  const solution::exactCYR_optional& solution::
  exactCYR () const
  {
    return this->exactCYR_;
  }

  solution::exactCYR_optional& solution::
  exactCYR ()
  {
    return this->exactCYR_;
  }

  void solution::
  exactCYR (const exactCYR_type& x)
  {
    this->exactCYR_.set (x);
  }

  void solution::
  exactCYR (const exactCYR_optional& x)
  {
    this->exactCYR_ = x;
  }

  const solution::exactCXC_optional& solution::
  exactCXC () const
  {
    return this->exactCXC_;
  }

  solution::exactCXC_optional& solution::
  exactCXC ()
  {
    return this->exactCXC_;
  }

  void solution::
  exactCXC (const exactCXC_type& x)
  {
    this->exactCXC_.set (x);
  }

  void solution::
  exactCXC (const exactCXC_optional& x)
  {
    this->exactCXC_ = x;
  }

  const solution::exactCYC_optional& solution::
  exactCYC () const
  {
    return this->exactCYC_;
  }

  solution::exactCYC_optional& solution::
  exactCYC ()
  {
    return this->exactCYC_;
  }

  void solution::
  exactCYC (const exactCYC_type& x)
  {
    this->exactCYC_.set (x);
  }

  void solution::
  exactCYC (const exactCYC_optional& x)
  {
    this->exactCYC_ = x;
  }

  const solution::space_optional& solution::
  space () const
  {
    return this->space_;
  }

  solution::space_optional& solution::
  space ()
  {
    return this->space_;
  }

  void solution::
  space (const space_type& x)
  {
    this->space_.set (x);
  }

  void solution::
  space (const space_optional& x)
  {
    this->space_ = x;
  }

  void solution::
  space (::std::auto_ptr< space_type > x)
  {
    this->space_.set (x);
  }


  // mono_coeffs
  // 

  const mono_coeffs::id_type& mono_coeffs::
  id () const
  {
    return this->id_.get ();
  }

  mono_coeffs::id_type& mono_coeffs::
  id ()
  {
    return this->id_.get ();
  }

  void mono_coeffs::
  id (const id_type& x)
  {
    this->id_.set (x);
  }

  const mono_coeffs::re_type& mono_coeffs::
  re () const
  {
    return this->re_.get ();
  }

  mono_coeffs::re_type& mono_coeffs::
  re ()
  {
    return this->re_.get ();
  }

  void mono_coeffs::
  re (const re_type& x)
  {
    this->re_.set (x);
  }

  const mono_coeffs::im_optional& mono_coeffs::
  im () const
  {
    return this->im_;
  }

  mono_coeffs::im_optional& mono_coeffs::
  im ()
  {
    return this->im_;
  }

  void mono_coeffs::
  im (const im_type& x)
  {
    this->im_.set (x);
  }

  void mono_coeffs::
  im (const im_optional& x)
  {
    this->im_ = x;
  }


  // elem_orders
  // 

  const elem_orders::id_type& elem_orders::
  id () const
  {
    return this->id_.get ();
  }

  elem_orders::id_type& elem_orders::
  id ()
  {
    return this->id_.get ();
  }

  void elem_orders::
  id (const id_type& x)
  {
    this->id_.set (x);
  }

  const elem_orders::ord_type& elem_orders::
  ord () const
  {
    return this->ord_.get ();
  }

  elem_orders::ord_type& elem_orders::
  ord ()
  {
    return this->ord_.get ();
  }

  void elem_orders::
  ord (const ord_type& x)
  {
    this->ord_.set (x);
  }


  // component
  // 

  const component::elem_coeffs_sequence& component::
  elem_coeffs () const
  {
    return this->elem_coeffs_;
  }

  component::elem_coeffs_sequence& component::
  elem_coeffs ()
  {
    return this->elem_coeffs_;
  }

  void component::
  elem_coeffs (const elem_coeffs_sequence& s)
  {
    this->elem_coeffs_ = s;
  }

  const component::component_number_optional& component::
  component_number () const
  {
    return this->component_number_;
  }

  component::component_number_optional& component::
  component_number ()
  {
    return this->component_number_;
  }

  void component::
  component_number (const component_number_type& x)
  {
    this->component_number_.set (x);
  }

  void component::
  component_number (const component_number_optional& x)
  {
    this->component_number_ = x;
  }


  // elem_coeffs
  // 

  const elem_coeffs::id_type& elem_coeffs::
  id () const
  {
    return this->id_.get ();
  }

  elem_coeffs::id_type& elem_coeffs::
  id ()
  {
    return this->id_.get ();
  }

  void elem_coeffs::
  id (const id_type& x)
  {
    this->id_.set (x);
  }

  const elem_coeffs::c_type& elem_coeffs::
  c () const
  {
    return this->c_.get ();
  }

  elem_coeffs::c_type& elem_coeffs::
  c ()
  {
    return this->c_.get ();
  }

  void elem_coeffs::
  c (const c_type& x)
  {
    this->c_.set (x);
  }
}

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

namespace XMLSolution
{
  // solution
  //

  solution::
  solution (const ncmp_type& ncmp,
            const nel_type& nel,
            const nc_type& nc,
            const exact_type& exact,
            const exactC_type& exactC)
  : ::xml_schema::type (),
    mono_coeffs_ (::xml_schema::flags (), this),
    elem_orders_ (::xml_schema::flags (), this),
    component_ (::xml_schema::flags (), this),
    ncmp_ (ncmp, ::xml_schema::flags (), this),
    nel_ (nel, ::xml_schema::flags (), this),
    nc_ (nc, ::xml_schema::flags (), this),
    exact_ (exact, ::xml_schema::flags (), this),
    exactC_ (exactC, ::xml_schema::flags (), this),
    exactCXR_ (::xml_schema::flags (), this),
    exactCYR_ (::xml_schema::flags (), this),
    exactCXC_ (::xml_schema::flags (), this),
    exactCYC_ (::xml_schema::flags (), this),
    space_ (::xml_schema::flags (), this)
  {
  }

  solution::
  solution (const solution& x,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    mono_coeffs_ (x.mono_coeffs_, f, this),
    elem_orders_ (x.elem_orders_, f, this),
    component_ (x.component_, f, this),
    ncmp_ (x.ncmp_, f, this),
    nel_ (x.nel_, f, this),
    nc_ (x.nc_, f, this),
    exact_ (x.exact_, f, this),
    exactC_ (x.exactC_, f, this),
    exactCXR_ (x.exactCXR_, f, this),
    exactCYR_ (x.exactCYR_, f, this),
    exactCXC_ (x.exactCXC_, f, this),
    exactCYC_ (x.exactCYC_, f, this),
    space_ (x.space_, f, this)
  {
  }

  solution::
  solution (const ::xercesc::DOMElement& e,
            ::xml_schema::flags f,
            ::xml_schema::container* c)
  : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
    mono_coeffs_ (f, this),
    elem_orders_ (f, this),
    component_ (f, this),
    ncmp_ (f, this),
    nel_ (f, this),
    nc_ (f, this),
    exact_ (f, this),
    exactC_ (f, this),
    exactCXR_ (f, this),
    exactCYR_ (f, this),
    exactCXC_ (f, this),
    exactCYC_ (f, this),
    space_ (f, this)
  {
    if ((f & ::xml_schema::flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // mono_coeffs
      //
      if (n.name () == "mono_coeffs" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< mono_coeffs_type > r (
          mono_coeffs_traits::create (i, f, this));

        this->mono_coeffs_.push_back (r);
        continue;
      }

      // elem_orders
      //
      if (n.name () == "elem_orders" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< elem_orders_type > r (
          elem_orders_traits::create (i, f, this));

        this->elem_orders_.push_back (r);
        continue;
      }

      // component
      //
      if (n.name () == "component" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< component_type > r (
          component_traits::create (i, f, this));

        this->component_.push_back (r);
        continue;
      }

      break;
    }

    while (p.more_attributes ())
    {
      const ::xercesc::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "ncmp" && n.namespace_ ().empty ())
      {
        this->ncmp_.set (ncmp_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "nel" && n.namespace_ ().empty ())
      {
        this->nel_.set (nel_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "nc" && n.namespace_ ().empty ())
      {
        this->nc_.set (nc_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exact" && n.namespace_ ().empty ())
      {
        this->exact_.set (exact_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exactC" && n.namespace_ ().empty ())
      {
        this->exactC_.set (exactC_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exactCXR" && n.namespace_ ().empty ())
      {
        this->exactCXR_.set (exactCXR_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exactCYR" && n.namespace_ ().empty ())
      {
        this->exactCYR_.set (exactCYR_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exactCXC" && n.namespace_ ().empty ())
      {
        this->exactCXC_.set (exactCXC_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "exactCYC" && n.namespace_ ().empty ())
      {
        this->exactCYC_.set (exactCYC_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "space" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< space_type > r (
          space_traits::create (i, f, this));

        this->space_.set (r);
        continue;
      }
    }

    if (!ncmp_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "ncmp",
        "");
    }

    if (!nel_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "nel",
        "");
    }

    if (!nc_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "nc",
        "");
    }

    if (!exact_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "exact",
        "");
    }

    if (!exactC_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "exactC",
        "");
    }
  }

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

  solution::
  ~solution ()
  {
  }

  // mono_coeffs
  //

  mono_coeffs::
  mono_coeffs (const id_type& id,
               const re_type& re)
  : ::xml_schema::type (),
    id_ (id, ::xml_schema::flags (), this),
    re_ (re, ::xml_schema::flags (), this),
    im_ (::xml_schema::flags (), this)
  {
  }

  mono_coeffs::
  mono_coeffs (const mono_coeffs& x,
               ::xml_schema::flags f,
               ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    id_ (x.id_, f, this),
    re_ (x.re_, f, this),
    im_ (x.im_, f, this)
  {
  }

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

  void mono_coeffs::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    while (p.more_attributes ())
    {
      const ::xercesc::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "id" && n.namespace_ ().empty ())
      {
        this->id_.set (id_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "re" && n.namespace_ ().empty ())
      {
        this->re_.set (re_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "im" && n.namespace_ ().empty ())
      {
        this->im_.set (im_traits::create (i, f, this));
        continue;
      }
    }

    if (!id_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "id",
        "");
    }

    if (!re_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "re",
        "");
    }
  }

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

  mono_coeffs::
  ~mono_coeffs ()
  {
  }

  // elem_orders
  //

  elem_orders::
  elem_orders (const id_type& id,
               const ord_type& ord)
  : ::xml_schema::type (),
    id_ (id, ::xml_schema::flags (), this),
    ord_ (ord, ::xml_schema::flags (), this)
  {
  }

  elem_orders::
  elem_orders (const elem_orders& x,
               ::xml_schema::flags f,
               ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    id_ (x.id_, f, this),
    ord_ (x.ord_, f, this)
  {
  }

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

  void elem_orders::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    while (p.more_attributes ())
    {
      const ::xercesc::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "id" && n.namespace_ ().empty ())
      {
        this->id_.set (id_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "ord" && n.namespace_ ().empty ())
      {
        this->ord_.set (ord_traits::create (i, f, this));
        continue;
      }
    }

    if (!id_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "id",
        "");
    }

    if (!ord_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "ord",
        "");
    }
  }

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

  elem_orders::
  ~elem_orders ()
  {
  }

  // component
  //

  component::
  component ()
  : ::xml_schema::type (),
    elem_coeffs_ (::xml_schema::flags (), this),
    component_number_ (::xml_schema::flags (), this)
  {
  }

  component::
  component (const component& x,
             ::xml_schema::flags f,
             ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    elem_coeffs_ (x.elem_coeffs_, f, this),
    component_number_ (x.component_number_, f, this)
  {
  }

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

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

      // elem_coeffs
      //
      if (n.name () == "elem_coeffs" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< elem_coeffs_type > r (
          elem_coeffs_traits::create (i, f, this));

        this->elem_coeffs_.push_back (r);
        continue;
      }

      break;
    }

    while (p.more_attributes ())
    {
      const ::xercesc::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "component_number" && n.namespace_ ().empty ())
      {
        this->component_number_.set (component_number_traits::create (i, f, this));
        continue;
      }
    }
  }

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

  component::
  ~component ()
  {
  }

  // elem_coeffs
  //

  elem_coeffs::
  elem_coeffs (const id_type& id,
               const c_type& c)
  : ::xml_schema::type (),
    id_ (id, ::xml_schema::flags (), this),
    c_ (c, ::xml_schema::flags (), this)
  {
  }

  elem_coeffs::
  elem_coeffs (const elem_coeffs& x,
               ::xml_schema::flags f,
               ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    id_ (x.id_, f, this),
    c_ (x.c_, f, this)
  {
  }

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

  void elem_coeffs::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::flags f)
  {
    while (p.more_attributes ())
    {
      const ::xercesc::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "id" && n.namespace_ ().empty ())
      {
        this->id_.set (id_traits::create (i, f, this));
        continue;
      }

      if (n.name () == "c" && n.namespace_ ().empty ())
      {
        this->c_.set (c_traits::create (i, f, this));
        continue;
      }
    }

    if (!id_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "id",
        "");
    }

    if (!c_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "c",
        "");
    }
  }

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

  elem_coeffs::
  ~elem_coeffs ()
  {
  }
}

#include <ostream>

namespace XMLSolution
{
  ::std::ostream&
  operator<< (::std::ostream& o, const solution& i)
  {
    for (solution::mono_coeffs_const_iterator
         b (i.mono_coeffs ().begin ()), e (i.mono_coeffs ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "mono_coeffs: " << *b;
    }

    for (solution::elem_orders_const_iterator
         b (i.elem_orders ().begin ()), e (i.elem_orders ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "elem_orders: " << *b;
    }

    for (solution::component_const_iterator
         b (i.component ().begin ()), e (i.component ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "component: " << *b;
    }

    o << ::std::endl << "ncmp: " << i.ncmp ();
    o << ::std::endl << "nel: " << i.nel ();
    o << ::std::endl << "nc: " << i.nc ();
    o << ::std::endl << "exact: " << i.exact ();
    o << ::std::endl << "exactC: " << i.exactC ();
    if (i.exactCXR ())
    {
      o << ::std::endl << "exactCXR: " << *i.exactCXR ();
    }

    if (i.exactCYR ())
    {
      o << ::std::endl << "exactCYR: " << *i.exactCYR ();
    }

    if (i.exactCXC ())
    {
      o << ::std::endl << "exactCXC: " << *i.exactCXC ();
    }

    if (i.exactCYC ())
    {
      o << ::std::endl << "exactCYC: " << *i.exactCYC ();
    }

    if (i.space ())
    {
      o << ::std::endl << "space: " << *i.space ();
    }

    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const mono_coeffs& i)
  {
    o << ::std::endl << "id: " << i.id ();
    o << ::std::endl << "re: " << i.re ();
    if (i.im ())
    {
      o << ::std::endl << "im: " << *i.im ();
    }

    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const elem_orders& i)
  {
    o << ::std::endl << "id: " << i.id ();
    o << ::std::endl << "ord: " << i.ord ();
    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const component& i)
  {
    for (component::elem_coeffs_const_iterator
         b (i.elem_coeffs ().begin ()), e (i.elem_coeffs ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "elem_coeffs: " << *b;
    }

    if (i.component_number ())
    {
      o << ::std::endl << "component_number: " << *i.component_number ();
    }

    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const elem_coeffs& i)
  {
    o << ::std::endl << "id: " << i.id ();
    o << ::std::endl << "c: " << i.c ();
    return o;
  }
}

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

namespace XMLSolution
{
  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (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::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (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::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (const ::std::string& u,
             ::xercesc::DOMErrorHandler& h,
             ::xml_schema::flags f,
             const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::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 ::XMLSolution::solution_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::xercesc::InputSource& i,
             ::xml_schema::flags f,
             const ::xml_schema::properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::xercesc::InputSource& i,
             ::xml_schema::error_handler& h,
             ::xml_schema::flags f,
             const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::xercesc::InputSource& i,
             ::xercesc::DOMErrorHandler& h,
             ::xml_schema::flags f,
             const ::xml_schema::properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::XMLSolution::solution > r (
      ::XMLSolution::solution_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (const ::xercesc::DOMDocument& d,
             ::xml_schema::flags f,
             const ::xml_schema::properties& p)
  {
    if (f & ::xml_schema::flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c (
        static_cast< ::xercesc::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::XMLSolution::solution > r (
        ::XMLSolution::solution_ (
          c, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "solution" &&
        n.namespace_ () == "XMLSolution")
    {
      ::std::auto_ptr< ::XMLSolution::solution > r (
        ::xsd::cxx::tree::traits< ::XMLSolution::solution, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "solution",
      "XMLSolution");
  }

  ::std::auto_ptr< ::XMLSolution::solution >
  solution_ (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >& d,
             ::xml_schema::flags f,
             const ::xml_schema::properties&)
  {
    ::xml_schema::dom::auto_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 () == "solution" &&
        n.namespace_ () == "XMLSolution")
    {
      ::std::auto_ptr< ::XMLSolution::solution > r (
        ::xsd::cxx::tree::traits< ::XMLSolution::solution, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "solution",
      "XMLSolution");
  }
}

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

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

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

  void
  solution_ (::xercesc::DOMDocument& d,
             const ::XMLSolution::solution& 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 () == "solution" &&
        n.namespace_ () == "XMLSolution")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "solution",
        "XMLSolution");
    }
  }

  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >
  solution_ (const ::XMLSolution::solution& s,
             const ::xml_schema::namespace_infomap& m,
             ::xml_schema::flags f)
  {
    ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "solution",
        "XMLSolution",
        m, f));

    ::XMLSolution::solution_ (*d, s, f);
    return d;
  }

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

    // mono_coeffs
    //
    for (solution::mono_coeffs_const_iterator
         b (i.mono_coeffs ().begin ()), n (i.mono_coeffs ().end ());
         b != n; ++b)
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "mono_coeffs",
          e));

      s << *b;
    }

    // elem_orders
    //
    for (solution::elem_orders_const_iterator
         b (i.elem_orders ().begin ()), n (i.elem_orders ().end ());
         b != n; ++b)
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "elem_orders",
          e));

      s << *b;
    }

    // component
    //
    for (solution::component_const_iterator
         b (i.component ().begin ()), n (i.component ().end ());
         b != n; ++b)
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "component",
          e));

      s << *b;
    }

    // ncmp
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "ncmp",
          e));

      a << i.ncmp ();
    }

    // nel
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "nel",
          e));

      a << i.nel ();
    }

    // nc
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "nc",
          e));

      a << i.nc ();
    }

    // exact
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exact",
          e));

      a << i.exact ();
    }

    // exactC
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exactC",
          e));

      a << i.exactC ();
    }

    // exactCXR
    //
    if (i.exactCXR ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exactCXR",
          e));

      a << ::xml_schema::as_decimal(*i.exactCXR ());
    }

    // exactCYR
    //
    if (i.exactCYR ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exactCYR",
          e));

      a << ::xml_schema::as_decimal(*i.exactCYR ());
    }

    // exactCXC
    //
    if (i.exactCXC ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exactCXC",
          e));

      a << ::xml_schema::as_decimal(*i.exactCXC ());
    }

    // exactCYC
    //
    if (i.exactCYC ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "exactCYC",
          e));

      a << ::xml_schema::as_decimal(*i.exactCYC ());
    }

    // space
    //
    if (i.space ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "space",
          e));

      a << *i.space ();
    }
  }

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

    // id
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "id",
          e));

      a << i.id ();
    }

    // re
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "re",
          e));

      a << ::xml_schema::as_decimal(i.re ());
    }

    // im
    //
    if (i.im ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "im",
          e));

      a << ::xml_schema::as_decimal(*i.im ());
    }
  }

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

    // id
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "id",
          e));

      a << i.id ();
    }

    // ord
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "ord",
          e));

      a << i.ord ();
    }
  }

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

    // elem_coeffs
    //
    for (component::elem_coeffs_const_iterator
         b (i.elem_coeffs ().begin ()), n (i.elem_coeffs ().end ());
         b != n; ++b)
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "elem_coeffs",
          e));

      s << *b;
    }

    // component_number
    //
    if (i.component_number ())
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "component_number",
          e));

      a << *i.component_number ();
    }
  }

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

    // id
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "id",
          e));

      a << i.id ();
    }

    // c
    //
    {
      ::xercesc::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "c",
          e));

      a << i.c ();
    }
  }
}

#include <xsd/cxx/post.hxx>

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