/home/martin/workspace/OpenStreetNav/src/xmlparse/xml/osm-pskel.cxx

Go to the documentation of this file.

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

#include "bound-pskel.hxx"

#include "node-pskel.hxx"

#include "way-pskel.hxx"

#include "relation-pskel.hxx"

// osm_pskel
//

void osm_pskel::
bound_parser (::bound_pskel& p)
{
  this->bound_parser_ = &p;
}

void osm_pskel::
node_parser (::node_pskel& p)
{
  this->node_parser_ = &p;
}

void osm_pskel::
way_parser (::way_pskel& p)
{
  this->way_parser_ = &p;
}

void osm_pskel::
relation_parser (::relation_pskel& p)
{
  this->relation_parser_ = &p;
}

void osm_pskel::
version_parser (::xml_schema::string_pskel& p)
{
  this->version_parser_ = &p;
}

void osm_pskel::
generator_parser (::xml_schema::string_pskel& p)
{
  this->generator_parser_ = &p;
}

void osm_pskel::
parsers (::bound_pskel& bound,
         ::node_pskel& node,
         ::way_pskel& way,
         ::relation_pskel& relation,
         ::xml_schema::string_pskel& version,
         ::xml_schema::string_pskel& generator)
{
  this->bound_parser_ = &bound;
  this->node_parser_ = &node;
  this->way_parser_ = &way;
  this->relation_parser_ = &relation;
  this->version_parser_ = &version;
  this->generator_parser_ = &generator;
}

osm_pskel::
osm_pskel ()
: bound_parser_ (0),
  node_parser_ (0),
  way_parser_ (0),
  relation_parser_ (0),
  version_parser_ (0),
  generator_parser_ (0),
  v_state_stack_ (sizeof (v_state_), &v_state_first_),
  v_state_attr_stack_ (sizeof (v_state_attr_), &v_state_attr_first_)
{
}

// osm_pskel
//

void osm_pskel::
bound ()
{
}

void osm_pskel::
node (const osm::Node&)
{
}

void osm_pskel::
way (const osm::Way&)
{
}

void osm_pskel::
relation (const osm::Relation&)
{
}

void osm_pskel::
version (const ::std::string&)
{
}

void osm_pskel::
generator (const ::std::string&)
{
}

void osm_pskel::
post_osm ()
{
}

#include <cassert>

// Element validation and dispatch functions for osm_pskel.
//
bool osm_pskel::
_start_element_impl (const ::xml_schema::ro_string& ns,
                     const ::xml_schema::ro_string& n,
                     const ::xml_schema::ro_string* t)
{
  XSD_UNUSED (t);

  v_state_& vs = *static_cast< v_state_* > (this->v_state_stack_.top ());
  v_state_descr_* vd = vs.data + (vs.size - 1);

  if (vd->func == 0 && vd->state == 0)
  {
    if (this->::xml_schema::complex_content::_start_element_impl (ns, n, t))
      return true;
    else
      vd->state = 1;
  }

  while (vd->func != 0)
  {
    (this->*vd->func) (vd->state, vd->count, ns, n, t, true);

    vd = vs.data + (vs.size - 1);

    if (vd->state == ~0UL)
      vd = vs.data + (--vs.size - 1);
    else
      break;
  }

  if (vd->func == 0)
  {
    if (vd->state != ~0UL)
    {
      unsigned long s = ~0UL;

      if (n == "bound" && ns.empty ())
        s = 0UL;
      else if ((n == "node" && ns.empty ()) ||
               (n == "way" && ns.empty ()) ||
               (n == "relation" && ns.empty ()))
        s = 1UL;

      if (s != ~0UL)
      {
        vd->count++;
        vd->state = ~0UL;

        vd = vs.data + vs.size++;
        vd->func = &osm_pskel::sequence_0;
        vd->state = s;
        vd->count = 0;

        this->sequence_0 (vd->state, vd->count, ns, n, t, true);
      }
      else
      {
        if (vd->count < 1UL)
          this->_expected_element (
            "", "bound",
            ns, n);
        return false;
      }
    }
    else
      return false;
  }

  return true;
}

bool osm_pskel::
_end_element_impl (const ::xml_schema::ro_string& ns,
                   const ::xml_schema::ro_string& n)
{
  v_state_& vs = *static_cast< v_state_* > (this->v_state_stack_.top ());
  v_state_descr_& vd = vs.data[vs.size - 1];

  if (vd.func == 0 && vd.state == 0)
  {
    if (!::xml_schema::complex_content::_end_element_impl (ns, n))
      assert (false);
    return true;
  }

  assert (vd.func != 0);
  (this->*vd.func) (vd.state, vd.count, ns, n, 0, false);

  if (vd.state == ~0UL)
    vs.size--;

  return true;
}

void osm_pskel::
_pre_e_validate ()
{
  this->v_state_stack_.push ();
  static_cast< v_state_* > (this->v_state_stack_.top ())->size = 0;

  v_state_& vs = *static_cast< v_state_* > (this->v_state_stack_.top ());
  v_state_descr_& vd = vs.data[vs.size++];

  vd.func = 0;
  vd.state = 0;
  vd.count = 0;
}

void osm_pskel::
_post_e_validate ()
{
  v_state_& vs = *static_cast< v_state_* > (this->v_state_stack_.top ());
  v_state_descr_* vd = vs.data + (vs.size - 1);

  ::xml_schema::ro_string empty;
  while (vd->func != 0)
  {
    (this->*vd->func) (vd->state, vd->count, empty, empty, 0, true);
    assert (vd->state == ~0UL);
    vd = vs.data + (--vs.size - 1);
  }

  if (vd->count < 1UL)
    this->_expected_element (
      "", "bound");

  this->v_state_stack_.pop ();
}

void osm_pskel::
sequence_0 (unsigned long& state,
            unsigned long& count,
            const ::xml_schema::ro_string& ns,
            const ::xml_schema::ro_string& n,
            const ::xml_schema::ro_string* t,
            bool start)
{
  XSD_UNUSED (t);

  switch (state)
  {
    case 0UL:
    {
      if (n == "bound" && ns.empty ())
      {
        if (start)
        {
          this->::xml_schema::complex_content::context_.top ().parser_ = this->bound_parser_;

          if (this->bound_parser_)
            this->bound_parser_->pre ();
        }
        else
        {
          if (this->bound_parser_)
          {
            this->bound_parser_->post_bound ();
            this->bound ();
          }

          count = 0;
          state = 1UL;
        }

        break;
      }
      else
      {
        assert (start);
        count = 0;
        state = 1UL;
        // Fall through.
      }
    }
    case 1UL:
    {
      unsigned long s (~0UL);

      if (n == "node" && ns.empty ())
        s = 0UL;
      else if (n == "way" && ns.empty ())
        s = 1UL;
      else if (n == "relation" && ns.empty ())
        s = 2UL;

      if (s != ~0UL)
      {
        assert (start);
        count++;

        v_state_& vs = *static_cast< v_state_* > (this->v_state_stack_.top ());
        v_state_descr_& vd = vs.data[vs.size++];

        vd.func = &osm_pskel::choice_0;
        vd.state = s;
        vd.count = 0;

        this->choice_0 (vd.state, vd.count, ns, n, t, true);
        break;
      }
      else
      {
        assert (start);
        if (count < 1UL)
          this->_expected_element (
            "", "node",
            ns, n);
        count = 0;
        state = ~0UL;
        // Fall through.
      }
    }
    case ~0UL:
      break;
  }
}

void osm_pskel::
choice_0 (unsigned long& state,
          unsigned long& count,
          const ::xml_schema::ro_string& ns,
          const ::xml_schema::ro_string& n,
          const ::xml_schema::ro_string* t,
          bool start)
{
  XSD_UNUSED (count);
  XSD_UNUSED (ns);
  XSD_UNUSED (n);
  XSD_UNUSED (t);

  switch (state)
  {
    case 0UL:
    {
      if (start)
      {
        this->::xml_schema::complex_content::context_.top ().parser_ = this->node_parser_;

        if (this->node_parser_)
          this->node_parser_->pre ();
      }
      else
      {
        if (this->node_parser_)
        {
          const osm::Node& tmp (this->node_parser_->post_node ());
          this->node (tmp);
        }

        state = ~0UL;
      }

      break;
    }
    case 1UL:
    {
      if (start)
      {
        this->::xml_schema::complex_content::context_.top ().parser_ = this->way_parser_;

        if (this->way_parser_)
          this->way_parser_->pre ();
      }
      else
      {
        if (this->way_parser_)
        {
          const osm::Way& tmp (this->way_parser_->post_way ());
          this->way (tmp);
        }

        state = ~0UL;
      }

      break;
    }
    case 2UL:
    {
      if (start)
      {
        this->::xml_schema::complex_content::context_.top ().parser_ = this->relation_parser_;

        if (this->relation_parser_)
          this->relation_parser_->pre ();
      }
      else
      {
        if (this->relation_parser_)
        {
          const osm::Relation& tmp (this->relation_parser_->post_relation ());
          this->relation (tmp);
        }

        state = ~0UL;
      }

      break;
    }
  }
}

// Attribute validation and dispatch functions for osm_pskel.
//
bool osm_pskel::
_attribute_impl_phase_one (const ::xml_schema::ro_string& ns,
                           const ::xml_schema::ro_string& n,
                           const ::xml_schema::ro_string& s)
{
  if (n == "version" && ns.empty ())
  {
    if (this->version_parser_)
    {
      this->version_parser_->pre ();
      this->version_parser_->_pre_impl ();
      this->version_parser_->_characters (s);
      this->version_parser_->_post_impl ();
      const ::std::string& tmp (this->version_parser_->post_string ());
      this->version (tmp);
    }

    static_cast< v_state_attr_* > (this->v_state_attr_stack_.top ())->version = true;
    return true;
  }

  if (n == "generator" && ns.empty ())
  {
    if (this->generator_parser_)
    {
      this->generator_parser_->pre ();
      this->generator_parser_->_pre_impl ();
      this->generator_parser_->_characters (s);
      this->generator_parser_->_post_impl ();
      const ::std::string& tmp (this->generator_parser_->post_string ());
      this->generator (tmp);
    }

    return true;
  }

  return false;
}

void osm_pskel::
_pre_a_validate ()
{
  this->v_state_attr_stack_.push ();
  v_state_attr_& as = *static_cast< v_state_attr_* > (this->v_state_attr_stack_.top ());

  as.version = false;
}

void osm_pskel::
_post_a_validate ()
{
  v_state_attr_& as = *static_cast< v_state_attr_* > (this->v_state_attr_stack_.top ());

  if (!as.version)
    this->_expected_attribute (
      "", "version");

  this->v_state_attr_stack_.pop ();
}

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