/home/martin/workspace/OpenStreetNav/src/xmlparse/xml/node-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 "node-pskel.hxx"

#include "tag-pskel.hxx"

// node_pskel
//

void node_pskel::
tag_parser (::tag_pskel& p)
{
  this->tag_parser_ = &p;
}

void node_pskel::
id_parser (::xml_schema::long_pskel& p)
{
  this->id_parser_ = &p;
}

void node_pskel::
uid_parser (::xml_schema::long_pskel& p)
{
  this->uid_parser_ = &p;
}

void node_pskel::
user_parser (::xml_schema::string_pskel& p)
{
  this->user_parser_ = &p;
}

void node_pskel::
timestamp_parser (::xml_schema::date_time_pskel& p)
{
  this->timestamp_parser_ = &p;
}

void node_pskel::
changeset_parser (::xml_schema::int_pskel& p)
{
  this->changeset_parser_ = &p;
}

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

void node_pskel::
visible_parser (::xml_schema::boolean_pskel& p)
{
  this->visible_parser_ = &p;
}

void node_pskel::
lat_parser (::xml_schema::decimal_pskel& p)
{
  this->lat_parser_ = &p;
}

void node_pskel::
lon_parser (::xml_schema::decimal_pskel& p)
{
  this->lon_parser_ = &p;
}

void node_pskel::
action_parser (::xml_schema::string_pskel& p)
{
  this->action_parser_ = &p;
}

void node_pskel::
parsers (::tag_pskel& tag,
         ::xml_schema::long_pskel& id,
         ::xml_schema::long_pskel& uid,
         ::xml_schema::string_pskel& user,
         ::xml_schema::date_time_pskel& timestamp,
         ::xml_schema::int_pskel& changeset,
         ::xml_schema::int_pskel& version,
         ::xml_schema::boolean_pskel& visible,
         ::xml_schema::decimal_pskel& lat,
         ::xml_schema::decimal_pskel& lon,
         ::xml_schema::string_pskel& action)
{
  this->tag_parser_ = &tag;
  this->id_parser_ = &id;
  this->uid_parser_ = &uid;
  this->user_parser_ = &user;
  this->timestamp_parser_ = &timestamp;
  this->changeset_parser_ = &changeset;
  this->version_parser_ = &version;
  this->visible_parser_ = &visible;
  this->lat_parser_ = ⪫
  this->lon_parser_ = &lon;
  this->action_parser_ = &action;
}

node_pskel::
node_pskel ()
: tag_parser_ (0),
  id_parser_ (0),
  uid_parser_ (0),
  user_parser_ (0),
  timestamp_parser_ (0),
  changeset_parser_ (0),
  version_parser_ (0),
  visible_parser_ (0),
  lat_parser_ (0),
  lon_parser_ (0),
  action_parser_ (0),
  v_state_stack_ (sizeof (v_state_), &v_state_first_),
  v_state_attr_stack_ (sizeof (v_state_attr_), &v_state_attr_first_)
{
}

// node_pskel
//

void node_pskel::
tag (const std::pair<std::string, std::string>&)
{
}

void node_pskel::
id (long long)
{
}

void node_pskel::
uid (long long)
{
}

void node_pskel::
user (const ::std::string&)
{
}

void node_pskel::
timestamp (const ::xml_schema::date_time&)
{
}

void node_pskel::
changeset (int)
{
}

void node_pskel::
version (int)
{
}

void node_pskel::
visible (bool)
{
}

void node_pskel::
lat (double)
{
}

void node_pskel::
lon (double)
{
}

void node_pskel::
action (const ::std::string&)
{
}

#include <cassert>

// Element validation and dispatch functions for node_pskel.
//
bool node_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 == "tag" && ns.empty ())
        s = 0UL;

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

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

        this->sequence_0 (vd->state, vd->count, ns, n, t, true);
      }
      else
      {
        return false;
      }
    }
    else
      return false;
  }

  return true;
}

bool node_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 node_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 node_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);
  }


  this->v_state_stack_.pop ();
}

void node_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 == "tag" && ns.empty ())
      {
        if (start)
        {
          this->::xml_schema::complex_content::context_.top ().parser_ = this->tag_parser_;

          if (this->tag_parser_)
            this->tag_parser_->pre ();
        }
        else
        {
          if (this->tag_parser_)
          {
            const std::pair<std::string, std::string>& tmp (this->tag_parser_->post_tag ());
            this->tag (tmp);
          }

          count++;
        }

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

// Attribute validation and dispatch functions for node_pskel.
//
bool node_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 == "id" && ns.empty ())
  {
    if (this->id_parser_)
    {
      this->id_parser_->pre ();
      this->id_parser_->_pre_impl ();
      this->id_parser_->_characters (s);
      this->id_parser_->_post_impl ();
      long long tmp (this->id_parser_->post_long ());
      this->id (tmp);
    }

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

  if (n == "uid" && ns.empty ())
  {
    if (this->uid_parser_)
    {
      this->uid_parser_->pre ();
      this->uid_parser_->_pre_impl ();
      this->uid_parser_->_characters (s);
      this->uid_parser_->_post_impl ();
      long long tmp (this->uid_parser_->post_long ());
      this->uid (tmp);
    }

    return true;
  }

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

    return true;
  }

  if (n == "timestamp" && ns.empty ())
  {
    if (this->timestamp_parser_)
    {
      this->timestamp_parser_->pre ();
      this->timestamp_parser_->_pre_impl ();
      this->timestamp_parser_->_characters (s);
      this->timestamp_parser_->_post_impl ();
      const ::xml_schema::date_time& tmp (this->timestamp_parser_->post_date_time ());
      this->timestamp (tmp);
    }

    return true;
  }

  if (n == "changeset" && ns.empty ())
  {
    if (this->changeset_parser_)
    {
      this->changeset_parser_->pre ();
      this->changeset_parser_->_pre_impl ();
      this->changeset_parser_->_characters (s);
      this->changeset_parser_->_post_impl ();
      int tmp (this->changeset_parser_->post_int ());
      this->changeset (tmp);
    }

    return true;
  }

  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 ();
      int tmp (this->version_parser_->post_int ());
      this->version (tmp);
    }

    return true;
  }

  if (n == "visible" && ns.empty ())
  {
    if (this->visible_parser_)
    {
      this->visible_parser_->pre ();
      this->visible_parser_->_pre_impl ();
      this->visible_parser_->_characters (s);
      this->visible_parser_->_post_impl ();
      bool tmp (this->visible_parser_->post_boolean ());
      this->visible (tmp);
    }

    return true;
  }

  if (n == "lat" && ns.empty ())
  {
    if (this->lat_parser_)
    {
      this->lat_parser_->pre ();
      this->lat_parser_->_pre_impl ();
      this->lat_parser_->_characters (s);
      this->lat_parser_->_post_impl ();
      double tmp (this->lat_parser_->post_decimal ());
      this->lat (tmp);
    }

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

  if (n == "lon" && ns.empty ())
  {
    if (this->lon_parser_)
    {
      this->lon_parser_->pre ();
      this->lon_parser_->_pre_impl ();
      this->lon_parser_->_characters (s);
      this->lon_parser_->_post_impl ();
      double tmp (this->lon_parser_->post_decimal ());
      this->lon (tmp);
    }

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

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

    return true;
  }

  return false;
}

void node_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.id = false;
  as.lat = false;
  as.lon = false;
}

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

  if (!as.id)
    this->_expected_attribute (
      "", "id");
  if (!as.lat)
    this->_expected_attribute (
      "", "lat");
  if (!as.lon)
    this->_expected_attribute (
      "", "lon");

  this->v_state_attr_stack_.pop ();
}

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