mesh_h1d_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 "mesh_h1d_xml.h"

namespace XMLMesh1D
{
  // variables_type
  // 

  const variables_type::var_sequence& variables_type::
  var () const
  {
    return this->var_;
  }

  variables_type::var_sequence& variables_type::
  var ()
  {
    return this->var_;
  }

  void variables_type::
  var (const var_sequence& s)
  {
    this->var_ = s;
  }


  // mesh
  // 

  const mesh::variables_optional& mesh::
  variables () const
  {
    return this->variables_;
  }

  mesh::variables_optional& mesh::
  variables ()
  {
    return this->variables_;
  }

  void mesh::
  variables (const variables_type& x)
  {
    this->variables_.set (x);
  }

  void mesh::
  variables (const variables_optional& x)
  {
    this->variables_ = x;
  }

  void mesh::
  variables (::std::auto_ptr< variables_type > x)
  {
    this->variables_.set (x);
  }

  const mesh::v_sequence& mesh::
  v () const
  {
    return this->v_;
  }

  mesh::v_sequence& mesh::
  v ()
  {
    return this->v_;
  }

  void mesh::
  v (const v_sequence& s)
  {
    this->v_ = s;
  }


  // var
  // 

  const var::name_type& var::
  name () const
  {
    return this->name_.get ();
  }

  var::name_type& var::
  name ()
  {
    return this->name_.get ();
  }

  void var::
  name (const name_type& x)
  {
    this->name_.set (x);
  }

  void var::
  name (::std::auto_ptr< name_type > x)
  {
    this->name_.set (x);
  }

  const var::value_type& var::
  value () const
  {
    return this->value_.get ();
  }

  var::value_type& var::
  value ()
  {
    return this->value_.get ();
  }

  void var::
  value (const value_type& x)
  {
    this->value_.set (x);
  }


  // v
  // 

  const v::x_type& v::
  x () const
  {
    return this->x_.get ();
  }

  v::x_type& v::
  x ()
  {
    return this->x_.get ();
  }

  void v::
  x (const x_type& x)
  {
    this->x_.set (x);
  }

  void v::
  x (::std::auto_ptr< x_type > x)
  {
    this->x_.set (x);
  }

  const v::m_optional& v::
  m () const
  {
    return this->m_;
  }

  v::m_optional& v::
  m ()
  {
    return this->m_;
  }

  void v::
  m (const m_type& x)
  {
    this->m_.set (x);
  }

  void v::
  m (const m_optional& x)
  {
    this->m_ = x;
  }

  void v::
  m (::std::auto_ptr< m_type > x)
  {
    this->m_.set (x);
  }
}

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

#include <xsd/cxx/tree/type-factory-map.hxx>

namespace _xsd
{
  static
  const ::xsd::cxx::tree::type_factory_plate< 0, char >
  type_factory_plate_init;
}

namespace XMLMesh1D
{
  // variables_type
  //

  variables_type::
  variables_type ()
  : ::xml_schema::type (),
    var_ (::xml_schema::flags (), this)
  {
  }

  variables_type::
  variables_type (const variables_type& x,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    var_ (x.var_, f, this)
  {
  }

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

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

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

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

      break;
    }
  }

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

  variables_type::
  ~variables_type ()
  {
  }

  // mesh
  //

  mesh::
  mesh ()
  : ::xml_schema::type (),
    variables_ (::xml_schema::flags (), this),
    v_ (::xml_schema::flags (), this)
  {
  }

  mesh::
  mesh (const mesh& x,
        ::xml_schema::flags f,
        ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    variables_ (x.variables_, f, this),
    v_ (x.v_, f, this)
  {
  }

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

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

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

        if (!this->variables_)
        {
          this->variables_.set (r);
          continue;
        }
      }

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

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

      break;
    }
  }

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

  mesh::
  ~mesh ()
  {
  }

  // var
  //

  var::
  var (const name_type& name,
       const value_type& value)
  : ::xml_schema::type (),
    name_ (name, ::xml_schema::flags (), this),
    value_ (value, ::xml_schema::flags (), this)
  {
  }

  var::
  var (const var& x,
       ::xml_schema::flags f,
       ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    name_ (x.name_, f, this),
    value_ (x.value_, f, this)
  {
  }

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

  void var::
  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 () == "name" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< name_type > r (
          name_traits::create (i, f, this));

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

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

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

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

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

  var::
  ~var ()
  {
  }

  // v
  //

  v::
  v (const x_type& x)
  : ::xml_schema::type (),
    x_ (x, ::xml_schema::flags (), this),
    m_ (::xml_schema::flags (), this)
  {
  }

  v::
  v (const v& x,
     ::xml_schema::flags f,
     ::xml_schema::container* c)
  : ::xml_schema::type (x, f, c),
    x_ (x.x_, f, this),
    m_ (x.m_, f, this)
  {
  }

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

  void v::
  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 () == "x" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< x_type > r (
          x_traits::create (i, f, this));

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

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

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

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

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

  v::
  ~v ()
  {
  }
}

#include <ostream>

#include <xsd/cxx/tree/std-ostream-map.hxx>

namespace _xsd
{
  static
  const ::xsd::cxx::tree::std_ostream_plate< 0, char >
  std_ostream_plate_init;
}

namespace XMLMesh1D
{
  ::std::ostream&
  operator<< (::std::ostream& o, const variables_type& i)
  {
    for (variables_type::var_const_iterator
         b (i.var ().begin ()), e (i.var ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "var: " << *b;
    }

    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const mesh& i)
  {
    if (i.variables ())
    {
      o << ::std::endl << "variables: " << *i.variables ();
    }

    for (mesh::v_const_iterator
         b (i.v ().begin ()), e (i.v ().end ());
         b != e; ++b)
    {
      o << ::std::endl << "v: " << *b;
    }

    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const var& i)
  {
    o << ::std::endl << "name: " << i.name ();
    o << ::std::endl << "value: " << i.value ();
    return o;
  }

  ::std::ostream&
  operator<< (::std::ostream& o, const v& i)
  {
    o << ::std::endl << "x: " << i.x ();
    if (i.m ())
    {
      o << ::std::endl << "m: " << *i.m ();
    }

    return o;
  }
}

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

namespace XMLMesh1D
{
  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 ::XMLMesh1D::mesh_ (isrc, h, f, p);
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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< ::XMLMesh1D::mesh > r (
      ::XMLMesh1D::mesh_ (
        d, f | ::xml_schema::flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (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< ::XMLMesh1D::mesh > r (
        ::XMLMesh1D::mesh_ (
          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 () == "mesh" &&
        n.namespace_ () == "XMLMesh1D")
    {
      ::std::auto_ptr< ::XMLMesh1D::mesh > r (
        ::xsd::cxx::tree::traits< ::XMLMesh1D::mesh, char >::create (
          e, f, 0));
      return r;
    }

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

  ::std::auto_ptr< ::XMLMesh1D::mesh >
  mesh_ (::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 () == "mesh" &&
        n.namespace_ () == "XMLMesh1D")
    {
      ::std::auto_ptr< ::XMLMesh1D::mesh > r (
        ::xsd::cxx::tree::traits< ::XMLMesh1D::mesh, char >::create (
          e, f, 0));
      return r;
    }

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

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

#include <xsd/cxx/tree/type-serializer-map.hxx>

namespace _xsd
{
  static
  const ::xsd::cxx::tree::type_serializer_plate< 0, char >
  type_serializer_plate_init;
}

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

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

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

  ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >
  mesh_ (const ::XMLMesh1D::mesh& 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 > (
        "mesh",
        "XMLMesh1D",
        m, f));

    ::XMLMesh1D::mesh_ (*d, s, f);
    return d;
  }

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

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

      s << *b;
    }
  }

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

    // variables
    //
    if (i.variables ())
    {
      ::xercesc::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "variables",
          e));

      s << *i.variables ();
    }

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

      s << *b;
    }
  }

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

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

      a << i.name ();
    }

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

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

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

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

      a << i.x ();
    }

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

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

#include <xsd/cxx/post.hxx>

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