// Copyright (C) 2005-2007 Code Synthesis Tools CC
//
// This program was generated by XML Schema Definition Compiler (XSD)
//
// 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.
//
#ifdef HAVE_CONFIG_H
#  include <dtn-config.h>
#endif
#if defined(XERCES_C_ENABLED) && defined(EXTERNAL_CL_ENABLED)
//
// End prologue.

#include <xsd/cxx/pre.hxx>

#include "clevent.h"

namespace dtn
{
  namespace clmessage
  {
    // linkTypeType
    // 

    linkTypeType::
    linkTypeType ()
    : ::xml_schema::string ()
    {
    }

    linkTypeType::
    linkTypeType (_xsd_linkTypeType v)
    : ::xml_schema::string (_xsd_linkTypeType_literals_[v])
    {
    }

    linkTypeType::
    linkTypeType (const ::xml_schema::string& _xsd_linkTypeType)
    : ::xml_schema::string (_xsd_linkTypeType)
    {
    }

    linkTypeType::
    linkTypeType (const linkTypeType& v,
                  ::xml_schema::flags f,
                  ::xml_schema::type* c)
    : ::xml_schema::string (v, f, c)
    {
    }

    linkTypeType& linkTypeType::
    operator= (_xsd_linkTypeType v)
    {
      static_cast< ::xml_schema::string& > (*this) = 
      ::xml_schema::string (_xsd_linkTypeType_literals_[v]);

      return *this;
    }


    // linkStateType
    // 

    linkStateType::
    linkStateType ()
    : ::xml_schema::string ()
    {
    }

    linkStateType::
    linkStateType (_xsd_linkStateType v)
    : ::xml_schema::string (_xsd_linkStateType_literals_[v])
    {
    }

    linkStateType::
    linkStateType (const ::xml_schema::string& _xsd_linkStateType)
    : ::xml_schema::string (_xsd_linkStateType)
    {
    }

    linkStateType::
    linkStateType (const linkStateType& v,
                   ::xml_schema::flags f,
                   ::xml_schema::type* c)
    : ::xml_schema::string (v, f, c)
    {
    }

    linkStateType& linkStateType::
    operator= (_xsd_linkStateType v)
    {
      static_cast< ::xml_schema::string& > (*this) = 
      ::xml_schema::string (_xsd_linkStateType_literals_[v]);

      return *this;
    }


    // linkReasonType
    // 

    linkReasonType::
    linkReasonType ()
    : ::xml_schema::string ()
    {
    }

    linkReasonType::
    linkReasonType (_xsd_linkReasonType v)
    : ::xml_schema::string (_xsd_linkReasonType_literals_[v])
    {
    }

    linkReasonType::
    linkReasonType (const ::xml_schema::string& _xsd_linkReasonType)
    : ::xml_schema::string (_xsd_linkReasonType)
    {
    }

    linkReasonType::
    linkReasonType (const linkReasonType& v,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::string (v, f, c)
    {
    }

    linkReasonType& linkReasonType::
    operator= (_xsd_linkReasonType v)
    {
      static_cast< ::xml_schema::string& > (*this) = 
      ::xml_schema::string (_xsd_linkReasonType_literals_[v]);

      return *this;
    }


    // bundlePassMethodType
    // 

    bundlePassMethodType::
    bundlePassMethodType ()
    : ::xml_schema::string ()
    {
    }

    bundlePassMethodType::
    bundlePassMethodType (_xsd_bundlePassMethodType v)
    : ::xml_schema::string (_xsd_bundlePassMethodType_literals_[v])
    {
    }

    bundlePassMethodType::
    bundlePassMethodType (const ::xml_schema::string& _xsd_bundlePassMethodType)
    : ::xml_schema::string (_xsd_bundlePassMethodType)
    {
    }

    bundlePassMethodType::
    bundlePassMethodType (const bundlePassMethodType& v,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::string (v, f, c)
    {
    }

    bundlePassMethodType& bundlePassMethodType::
    operator= (_xsd_bundlePassMethodType v)
    {
      static_cast< ::xml_schema::string& > (*this) = 
      ::xml_schema::string (_xsd_bundlePassMethodType_literals_[v]);

      return *this;
    }


    // percentType
    // 


    // attribute_name
    // 

    const attribute_name::value::type& attribute_name::
    value () const
    {
      return this->_xsd_value_.get ();
    }

    attribute_name::value::type& attribute_name::
    value ()
    {
      return this->_xsd_value_.get ();
    }

    void attribute_name::
    value (const value::type& value)
    {
      this->_xsd_value_.set (value);
    }

    void attribute_name::
    value (::std::auto_ptr< value::type > value)
    {
      this->_xsd_value_.set (value);
    }


    // key_value_pair
    // 

    const key_value_pair::name::type& key_value_pair::
    name () const
    {
      return this->_xsd_name_.get ();
    }

    key_value_pair::name::type& key_value_pair::
    name ()
    {
      return this->_xsd_name_.get ();
    }

    void key_value_pair::
    name (const name::type& name)
    {
      this->_xsd_name_.set (name);
    }

    void key_value_pair::
    name (::std::auto_ptr< name::type > name)
    {
      this->_xsd_name_.set (name);
    }

    const key_value_pair::value::type& key_value_pair::
    value () const
    {
      return this->_xsd_value_.get ();
    }

    key_value_pair::value::type& key_value_pair::
    value ()
    {
      return this->_xsd_value_.get ();
    }

    void key_value_pair::
    value (const value::type& value)
    {
      this->_xsd_value_.set (value);
    }

    void key_value_pair::
    value (::std::auto_ptr< value::type > value)
    {
      this->_xsd_value_.set (value);
    }


    // bundle_attributes
    // 

    const bundle_attributes::source_eid::type& bundle_attributes::
    source_eid () const
    {
      return this->_xsd_source_eid_.get ();
    }

    bundle_attributes::source_eid::type& bundle_attributes::
    source_eid ()
    {
      return this->_xsd_source_eid_.get ();
    }

    void bundle_attributes::
    source_eid (const source_eid::type& source_eid)
    {
      this->_xsd_source_eid_.set (source_eid);
    }

    void bundle_attributes::
    source_eid (::std::auto_ptr< source_eid::type > source_eid)
    {
      this->_xsd_source_eid_.set (source_eid);
    }

    const bundle_attributes::timestamp_seconds::type& bundle_attributes::
    timestamp_seconds () const
    {
      return this->_xsd_timestamp_seconds_.get ();
    }

    bundle_attributes::timestamp_seconds::type& bundle_attributes::
    timestamp_seconds ()
    {
      return this->_xsd_timestamp_seconds_.get ();
    }

    void bundle_attributes::
    timestamp_seconds (const timestamp_seconds::type& timestamp_seconds)
    {
      this->_xsd_timestamp_seconds_.set (timestamp_seconds);
    }

    const bundle_attributes::timestamp_sequence::type& bundle_attributes::
    timestamp_sequence () const
    {
      return this->_xsd_timestamp_sequence_.get ();
    }

    bundle_attributes::timestamp_sequence::type& bundle_attributes::
    timestamp_sequence ()
    {
      return this->_xsd_timestamp_sequence_.get ();
    }

    void bundle_attributes::
    timestamp_sequence (const timestamp_sequence::type& timestamp_sequence)
    {
      this->_xsd_timestamp_sequence_.set (timestamp_sequence);
    }

    const bundle_attributes::is_fragment::type& bundle_attributes::
    is_fragment () const
    {
      return this->_xsd_is_fragment_.get ();
    }

    bundle_attributes::is_fragment::type& bundle_attributes::
    is_fragment ()
    {
      return this->_xsd_is_fragment_.get ();
    }

    void bundle_attributes::
    is_fragment (const is_fragment::type& is_fragment)
    {
      this->_xsd_is_fragment_.set (is_fragment);
    }

    const bundle_attributes::fragment_length::container& bundle_attributes::
    fragment_length () const
    {
      return this->_xsd_fragment_length_;
    }

    bundle_attributes::fragment_length::container& bundle_attributes::
    fragment_length ()
    {
      return this->_xsd_fragment_length_;
    }

    void bundle_attributes::
    fragment_length (const fragment_length::type& fragment_length)
    {
      this->_xsd_fragment_length_.set (fragment_length);
    }

    void bundle_attributes::
    fragment_length (const fragment_length::container& fragment_length)
    {
      this->_xsd_fragment_length_ = fragment_length;
    }

    const bundle_attributes::fragment_offset::container& bundle_attributes::
    fragment_offset () const
    {
      return this->_xsd_fragment_offset_;
    }

    bundle_attributes::fragment_offset::container& bundle_attributes::
    fragment_offset ()
    {
      return this->_xsd_fragment_offset_;
    }

    void bundle_attributes::
    fragment_offset (const fragment_offset::type& fragment_offset)
    {
      this->_xsd_fragment_offset_.set (fragment_offset);
    }

    void bundle_attributes::
    fragment_offset (const fragment_offset::container& fragment_offset)
    {
      this->_xsd_fragment_offset_ = fragment_offset;
    }


    // link_attributes
    // 

    const link_attributes::key_value_pair::container& link_attributes::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    link_attributes::key_value_pair::container& link_attributes::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void link_attributes::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const link_attributes::type::container& link_attributes::
    type () const
    {
      return this->_xsd_type_;
    }

    link_attributes::type::container& link_attributes::
    type ()
    {
      return this->_xsd_type_;
    }

    void link_attributes::
    type (const type::type_& type)
    {
      this->_xsd_type_.set (type);
    }

    void link_attributes::
    type (const type::container& type)
    {
      this->_xsd_type_ = type;
    }

    void link_attributes::
    type (::std::auto_ptr< type::type_ > type)
    {
      this->_xsd_type_.set (type);
    }

    const link_attributes::state::container& link_attributes::
    state () const
    {
      return this->_xsd_state_;
    }

    link_attributes::state::container& link_attributes::
    state ()
    {
      return this->_xsd_state_;
    }

    void link_attributes::
    state (const state::type& state)
    {
      this->_xsd_state_.set (state);
    }

    void link_attributes::
    state (const state::container& state)
    {
      this->_xsd_state_ = state;
    }

    void link_attributes::
    state (::std::auto_ptr< state::type > state)
    {
      this->_xsd_state_.set (state);
    }

    const link_attributes::peer_eid::container& link_attributes::
    peer_eid () const
    {
      return this->_xsd_peer_eid_;
    }

    link_attributes::peer_eid::container& link_attributes::
    peer_eid ()
    {
      return this->_xsd_peer_eid_;
    }

    void link_attributes::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void link_attributes::
    peer_eid (const peer_eid::container& peer_eid)
    {
      this->_xsd_peer_eid_ = peer_eid;
    }

    void link_attributes::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    const link_attributes::is_reachable::container& link_attributes::
    is_reachable () const
    {
      return this->_xsd_is_reachable_;
    }

    link_attributes::is_reachable::container& link_attributes::
    is_reachable ()
    {
      return this->_xsd_is_reachable_;
    }

    void link_attributes::
    is_reachable (const is_reachable::type& is_reachable)
    {
      this->_xsd_is_reachable_.set (is_reachable);
    }

    void link_attributes::
    is_reachable (const is_reachable::container& is_reachable)
    {
      this->_xsd_is_reachable_ = is_reachable;
    }

    const link_attributes::is_usable::container& link_attributes::
    is_usable () const
    {
      return this->_xsd_is_usable_;
    }

    link_attributes::is_usable::container& link_attributes::
    is_usable ()
    {
      return this->_xsd_is_usable_;
    }

    void link_attributes::
    is_usable (const is_usable::type& is_usable)
    {
      this->_xsd_is_usable_.set (is_usable);
    }

    void link_attributes::
    is_usable (const is_usable::container& is_usable)
    {
      this->_xsd_is_usable_ = is_usable;
    }

    const link_attributes::how_reliable::container& link_attributes::
    how_reliable () const
    {
      return this->_xsd_how_reliable_;
    }

    link_attributes::how_reliable::container& link_attributes::
    how_reliable ()
    {
      return this->_xsd_how_reliable_;
    }

    void link_attributes::
    how_reliable (const how_reliable::type& how_reliable)
    {
      this->_xsd_how_reliable_.set (how_reliable);
    }

    void link_attributes::
    how_reliable (const how_reliable::container& how_reliable)
    {
      this->_xsd_how_reliable_ = how_reliable;
    }

    void link_attributes::
    how_reliable (::std::auto_ptr< how_reliable::type > how_reliable)
    {
      this->_xsd_how_reliable_.set (how_reliable);
    }

    const link_attributes::how_available::container& link_attributes::
    how_available () const
    {
      return this->_xsd_how_available_;
    }

    link_attributes::how_available::container& link_attributes::
    how_available ()
    {
      return this->_xsd_how_available_;
    }

    void link_attributes::
    how_available (const how_available::type& how_available)
    {
      this->_xsd_how_available_.set (how_available);
    }

    void link_attributes::
    how_available (const how_available::container& how_available)
    {
      this->_xsd_how_available_ = how_available;
    }

    void link_attributes::
    how_available (::std::auto_ptr< how_available::type > how_available)
    {
      this->_xsd_how_available_.set (how_available);
    }

    const link_attributes::reactive_fragment::container& link_attributes::
    reactive_fragment () const
    {
      return this->_xsd_reactive_fragment_;
    }

    link_attributes::reactive_fragment::container& link_attributes::
    reactive_fragment ()
    {
      return this->_xsd_reactive_fragment_;
    }

    void link_attributes::
    reactive_fragment (const reactive_fragment::type& reactive_fragment)
    {
      this->_xsd_reactive_fragment_.set (reactive_fragment);
    }

    void link_attributes::
    reactive_fragment (const reactive_fragment::container& reactive_fragment)
    {
      this->_xsd_reactive_fragment_ = reactive_fragment;
    }

    const link_attributes::nexthop::container& link_attributes::
    nexthop () const
    {
      return this->_xsd_nexthop_;
    }

    link_attributes::nexthop::container& link_attributes::
    nexthop ()
    {
      return this->_xsd_nexthop_;
    }

    void link_attributes::
    nexthop (const nexthop::type& nexthop)
    {
      this->_xsd_nexthop_.set (nexthop);
    }

    void link_attributes::
    nexthop (const nexthop::container& nexthop)
    {
      this->_xsd_nexthop_ = nexthop;
    }

    void link_attributes::
    nexthop (::std::auto_ptr< nexthop::type > nexthop)
    {
      this->_xsd_nexthop_.set (nexthop);
    }

    const link_attributes::cla_name::container& link_attributes::
    cla_name () const
    {
      return this->_xsd_cla_name_;
    }

    link_attributes::cla_name::container& link_attributes::
    cla_name ()
    {
      return this->_xsd_cla_name_;
    }

    void link_attributes::
    cla_name (const cla_name::type& cla_name)
    {
      this->_xsd_cla_name_.set (cla_name);
    }

    void link_attributes::
    cla_name (const cla_name::container& cla_name)
    {
      this->_xsd_cla_name_ = cla_name;
    }

    void link_attributes::
    cla_name (::std::auto_ptr< cla_name::type > cla_name)
    {
      this->_xsd_cla_name_.set (cla_name);
    }

    const link_attributes::high_water_mark::container& link_attributes::
    high_water_mark () const
    {
      return this->_xsd_high_water_mark_;
    }

    link_attributes::high_water_mark::container& link_attributes::
    high_water_mark ()
    {
      return this->_xsd_high_water_mark_;
    }

    void link_attributes::
    high_water_mark (const high_water_mark::type& high_water_mark)
    {
      this->_xsd_high_water_mark_.set (high_water_mark);
    }

    void link_attributes::
    high_water_mark (const high_water_mark::container& high_water_mark)
    {
      this->_xsd_high_water_mark_ = high_water_mark;
    }

    const link_attributes::low_water_mark::container& link_attributes::
    low_water_mark () const
    {
      return this->_xsd_low_water_mark_;
    }

    link_attributes::low_water_mark::container& link_attributes::
    low_water_mark ()
    {
      return this->_xsd_low_water_mark_;
    }

    void link_attributes::
    low_water_mark (const low_water_mark::type& low_water_mark)
    {
      this->_xsd_low_water_mark_.set (low_water_mark);
    }

    void link_attributes::
    low_water_mark (const low_water_mark::container& low_water_mark)
    {
      this->_xsd_low_water_mark_ = low_water_mark;
    }


    // link_config_parameters
    // 

    const link_config_parameters::key_value_pair::container& link_config_parameters::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    link_config_parameters::key_value_pair::container& link_config_parameters::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void link_config_parameters::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const link_config_parameters::is_usable::container& link_config_parameters::
    is_usable () const
    {
      return this->_xsd_is_usable_;
    }

    link_config_parameters::is_usable::container& link_config_parameters::
    is_usable ()
    {
      return this->_xsd_is_usable_;
    }

    void link_config_parameters::
    is_usable (const is_usable::type& is_usable)
    {
      this->_xsd_is_usable_.set (is_usable);
    }

    void link_config_parameters::
    is_usable (const is_usable::container& is_usable)
    {
      this->_xsd_is_usable_ = is_usable;
    }

    const link_config_parameters::reactive_fragment::container& link_config_parameters::
    reactive_fragment () const
    {
      return this->_xsd_reactive_fragment_;
    }

    link_config_parameters::reactive_fragment::container& link_config_parameters::
    reactive_fragment ()
    {
      return this->_xsd_reactive_fragment_;
    }

    void link_config_parameters::
    reactive_fragment (const reactive_fragment::type& reactive_fragment)
    {
      this->_xsd_reactive_fragment_.set (reactive_fragment);
    }

    void link_config_parameters::
    reactive_fragment (const reactive_fragment::container& reactive_fragment)
    {
      this->_xsd_reactive_fragment_ = reactive_fragment;
    }

    const link_config_parameters::nexthop::container& link_config_parameters::
    nexthop () const
    {
      return this->_xsd_nexthop_;
    }

    link_config_parameters::nexthop::container& link_config_parameters::
    nexthop ()
    {
      return this->_xsd_nexthop_;
    }

    void link_config_parameters::
    nexthop (const nexthop::type& nexthop)
    {
      this->_xsd_nexthop_.set (nexthop);
    }

    void link_config_parameters::
    nexthop (const nexthop::container& nexthop)
    {
      this->_xsd_nexthop_ = nexthop;
    }

    void link_config_parameters::
    nexthop (::std::auto_ptr< nexthop::type > nexthop)
    {
      this->_xsd_nexthop_.set (nexthop);
    }


    // contact_attributes
    // 

    const contact_attributes::start_time::type& contact_attributes::
    start_time () const
    {
      return this->_xsd_start_time_.get ();
    }

    contact_attributes::start_time::type& contact_attributes::
    start_time ()
    {
      return this->_xsd_start_time_.get ();
    }

    void contact_attributes::
    start_time (const start_time::type& start_time)
    {
      this->_xsd_start_time_.set (start_time);
    }

    const contact_attributes::duration::type& contact_attributes::
    duration () const
    {
      return this->_xsd_duration_.get ();
    }

    contact_attributes::duration::type& contact_attributes::
    duration ()
    {
      return this->_xsd_duration_.get ();
    }

    void contact_attributes::
    duration (const duration::type& duration)
    {
      this->_xsd_duration_.set (duration);
    }

    const contact_attributes::bps::type& contact_attributes::
    bps () const
    {
      return this->_xsd_bps_.get ();
    }

    contact_attributes::bps::type& contact_attributes::
    bps ()
    {
      return this->_xsd_bps_.get ();
    }

    void contact_attributes::
    bps (const bps::type& bps)
    {
      this->_xsd_bps_.set (bps);
    }

    const contact_attributes::latency::type& contact_attributes::
    latency () const
    {
      return this->_xsd_latency_.get ();
    }

    contact_attributes::latency::type& contact_attributes::
    latency ()
    {
      return this->_xsd_latency_.get ();
    }

    void contact_attributes::
    latency (const latency::type& latency)
    {
      this->_xsd_latency_.set (latency);
    }

    const contact_attributes::packet_loss_prob::type& contact_attributes::
    packet_loss_prob () const
    {
      return this->_xsd_packet_loss_prob_.get ();
    }

    contact_attributes::packet_loss_prob::type& contact_attributes::
    packet_loss_prob ()
    {
      return this->_xsd_packet_loss_prob_.get ();
    }

    void contact_attributes::
    packet_loss_prob (const packet_loss_prob::type& packet_loss_prob)
    {
      this->_xsd_packet_loss_prob_.set (packet_loss_prob);
    }

    void contact_attributes::
    packet_loss_prob (::std::auto_ptr< packet_loss_prob::type > packet_loss_prob)
    {
      this->_xsd_packet_loss_prob_.set (packet_loss_prob);
    }


    // cla_add_request
    // 

    const cla_add_request::name::type& cla_add_request::
    name () const
    {
      return this->_xsd_name_.get ();
    }

    cla_add_request::name::type& cla_add_request::
    name ()
    {
      return this->_xsd_name_.get ();
    }

    void cla_add_request::
    name (const name::type& name)
    {
      this->_xsd_name_.set (name);
    }

    void cla_add_request::
    name (::std::auto_ptr< name::type > name)
    {
      this->_xsd_name_.set (name);
    }


    // cla_delete_request
    // 

    const cla_delete_request::name::type& cla_delete_request::
    name () const
    {
      return this->_xsd_name_.get ();
    }

    cla_delete_request::name::type& cla_delete_request::
    name ()
    {
      return this->_xsd_name_.get ();
    }

    void cla_delete_request::
    name (const name::type& name)
    {
      this->_xsd_name_.set (name);
    }

    void cla_delete_request::
    name (::std::auto_ptr< name::type > name)
    {
      this->_xsd_name_.set (name);
    }


    // cla_set_params_request
    // 

    const cla_set_params_request::key_value_pair::container& cla_set_params_request::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    cla_set_params_request::key_value_pair::container& cla_set_params_request::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void cla_set_params_request::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const cla_set_params_request::local_eid::container& cla_set_params_request::
    local_eid () const
    {
      return this->_xsd_local_eid_;
    }

    cla_set_params_request::local_eid::container& cla_set_params_request::
    local_eid ()
    {
      return this->_xsd_local_eid_;
    }

    void cla_set_params_request::
    local_eid (const local_eid::type& local_eid)
    {
      this->_xsd_local_eid_.set (local_eid);
    }

    void cla_set_params_request::
    local_eid (const local_eid::container& local_eid)
    {
      this->_xsd_local_eid_ = local_eid;
    }

    void cla_set_params_request::
    local_eid (::std::auto_ptr< local_eid::type > local_eid)
    {
      this->_xsd_local_eid_.set (local_eid);
    }

    const cla_set_params_request::create_discovered_links::container& cla_set_params_request::
    create_discovered_links () const
    {
      return this->_xsd_create_discovered_links_;
    }

    cla_set_params_request::create_discovered_links::container& cla_set_params_request::
    create_discovered_links ()
    {
      return this->_xsd_create_discovered_links_;
    }

    void cla_set_params_request::
    create_discovered_links (const create_discovered_links::type& create_discovered_links)
    {
      this->_xsd_create_discovered_links_.set (create_discovered_links);
    }

    void cla_set_params_request::
    create_discovered_links (const create_discovered_links::container& create_discovered_links)
    {
      this->_xsd_create_discovered_links_ = create_discovered_links;
    }

    const cla_set_params_request::bundle_pass_method::container& cla_set_params_request::
    bundle_pass_method () const
    {
      return this->_xsd_bundle_pass_method_;
    }

    cla_set_params_request::bundle_pass_method::container& cla_set_params_request::
    bundle_pass_method ()
    {
      return this->_xsd_bundle_pass_method_;
    }

    void cla_set_params_request::
    bundle_pass_method (const bundle_pass_method::type& bundle_pass_method)
    {
      this->_xsd_bundle_pass_method_.set (bundle_pass_method);
    }

    void cla_set_params_request::
    bundle_pass_method (const bundle_pass_method::container& bundle_pass_method)
    {
      this->_xsd_bundle_pass_method_ = bundle_pass_method;
    }

    void cla_set_params_request::
    bundle_pass_method (::std::auto_ptr< bundle_pass_method::type > bundle_pass_method)
    {
      this->_xsd_bundle_pass_method_.set (bundle_pass_method);
    }

    const cla_set_params_request::reactive_fragment_enabled::container& cla_set_params_request::
    reactive_fragment_enabled () const
    {
      return this->_xsd_reactive_fragment_enabled_;
    }

    cla_set_params_request::reactive_fragment_enabled::container& cla_set_params_request::
    reactive_fragment_enabled ()
    {
      return this->_xsd_reactive_fragment_enabled_;
    }

    void cla_set_params_request::
    reactive_fragment_enabled (const reactive_fragment_enabled::type& reactive_fragment_enabled)
    {
      this->_xsd_reactive_fragment_enabled_.set (reactive_fragment_enabled);
    }

    void cla_set_params_request::
    reactive_fragment_enabled (const reactive_fragment_enabled::container& reactive_fragment_enabled)
    {
      this->_xsd_reactive_fragment_enabled_ = reactive_fragment_enabled;
    }


    // cla_params_set_event
    // 


    // interface_set_defaults_request
    // 

    const interface_set_defaults_request::key_value_pair::container& interface_set_defaults_request::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    interface_set_defaults_request::key_value_pair::container& interface_set_defaults_request::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void interface_set_defaults_request::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }


    // interface_create_request
    // 

    const interface_create_request::key_value_pair::container& interface_create_request::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    interface_create_request::key_value_pair::container& interface_create_request::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void interface_create_request::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const interface_create_request::interface_name::type& interface_create_request::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    interface_create_request::interface_name::type& interface_create_request::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void interface_create_request::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void interface_create_request::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }


    // interface_created_event
    // 

    const interface_created_event::interface_name::type& interface_created_event::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    interface_created_event::interface_name::type& interface_created_event::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void interface_created_event::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void interface_created_event::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }


    // interface_reconfigure_request
    // 

    const interface_reconfigure_request::key_value_pair::container& interface_reconfigure_request::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    interface_reconfigure_request::key_value_pair::container& interface_reconfigure_request::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void interface_reconfigure_request::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const interface_reconfigure_request::interface_name::type& interface_reconfigure_request::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    interface_reconfigure_request::interface_name::type& interface_reconfigure_request::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void interface_reconfigure_request::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void interface_reconfigure_request::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    const interface_reconfigure_request::up::container& interface_reconfigure_request::
    up () const
    {
      return this->_xsd_up_;
    }

    interface_reconfigure_request::up::container& interface_reconfigure_request::
    up ()
    {
      return this->_xsd_up_;
    }

    void interface_reconfigure_request::
    up (const up::type& up)
    {
      this->_xsd_up_.set (up);
    }

    void interface_reconfigure_request::
    up (const up::container& up)
    {
      this->_xsd_up_ = up;
    }

    const interface_reconfigure_request::discovery::container& interface_reconfigure_request::
    discovery () const
    {
      return this->_xsd_discovery_;
    }

    interface_reconfigure_request::discovery::container& interface_reconfigure_request::
    discovery ()
    {
      return this->_xsd_discovery_;
    }

    void interface_reconfigure_request::
    discovery (const discovery::type& discovery)
    {
      this->_xsd_discovery_.set (discovery);
    }

    void interface_reconfigure_request::
    discovery (const discovery::container& discovery)
    {
      this->_xsd_discovery_ = discovery;
    }


    // interface_reconfigured_event
    // 

    const interface_reconfigured_event::interface_name::type& interface_reconfigured_event::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    interface_reconfigured_event::interface_name::type& interface_reconfigured_event::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void interface_reconfigured_event::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void interface_reconfigured_event::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }


    // interface_destroy_request
    // 

    const interface_destroy_request::interface_name::type& interface_destroy_request::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    interface_destroy_request::interface_name::type& interface_destroy_request::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void interface_destroy_request::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void interface_destroy_request::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }


    // eid_reachable_event
    // 

    const eid_reachable_event::interface_name::type& eid_reachable_event::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    eid_reachable_event::interface_name::type& eid_reachable_event::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void eid_reachable_event::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void eid_reachable_event::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    const eid_reachable_event::peer_eid::type& eid_reachable_event::
    peer_eid () const
    {
      return this->_xsd_peer_eid_.get ();
    }

    eid_reachable_event::peer_eid::type& eid_reachable_event::
    peer_eid ()
    {
      return this->_xsd_peer_eid_.get ();
    }

    void eid_reachable_event::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void eid_reachable_event::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // link_set_defaults_request
    // 

    const link_set_defaults_request::link_config_parameters::type& link_set_defaults_request::
    link_config_parameters () const
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    link_set_defaults_request::link_config_parameters::type& link_set_defaults_request::
    link_config_parameters ()
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    void link_set_defaults_request::
    link_config_parameters (const link_config_parameters::type& link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    void link_set_defaults_request::
    link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }


    // link_create_request
    // 

    const link_create_request::link_config_parameters::type& link_create_request::
    link_config_parameters () const
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    link_create_request::link_config_parameters::type& link_create_request::
    link_config_parameters ()
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    void link_create_request::
    link_config_parameters (const link_config_parameters::type& link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    void link_create_request::
    link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    const link_create_request::link_name::type& link_create_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_create_request::link_name::type& link_create_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_create_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_create_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_create_request::type::type_& link_create_request::
    type () const
    {
      return this->_xsd_type_.get ();
    }

    link_create_request::type::type_& link_create_request::
    type ()
    {
      return this->_xsd_type_.get ();
    }

    void link_create_request::
    type (const type::type_& type)
    {
      this->_xsd_type_.set (type);
    }

    void link_create_request::
    type (::std::auto_ptr< type::type_ > type)
    {
      this->_xsd_type_.set (type);
    }

    const link_create_request::peer_eid::container& link_create_request::
    peer_eid () const
    {
      return this->_xsd_peer_eid_;
    }

    link_create_request::peer_eid::container& link_create_request::
    peer_eid ()
    {
      return this->_xsd_peer_eid_;
    }

    void link_create_request::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void link_create_request::
    peer_eid (const peer_eid::container& peer_eid)
    {
      this->_xsd_peer_eid_ = peer_eid;
    }

    void link_create_request::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // link_created_event
    // 

    const link_created_event::link_attributes::type& link_created_event::
    link_attributes () const
    {
      return this->_xsd_link_attributes_.get ();
    }

    link_created_event::link_attributes::type& link_created_event::
    link_attributes ()
    {
      return this->_xsd_link_attributes_.get ();
    }

    void link_created_event::
    link_attributes (const link_attributes::type& link_attributes)
    {
      this->_xsd_link_attributes_.set (link_attributes);
    }

    void link_created_event::
    link_attributes (::std::auto_ptr< link_attributes::type > link_attributes)
    {
      this->_xsd_link_attributes_.set (link_attributes);
    }

    const link_created_event::link_name::type& link_created_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_created_event::link_name::type& link_created_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_created_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_created_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_created_event::reason::type& link_created_event::
    reason () const
    {
      return this->_xsd_reason_.get ();
    }

    link_created_event::reason::type& link_created_event::
    reason ()
    {
      return this->_xsd_reason_.get ();
    }

    void link_created_event::
    reason (const reason::type& reason)
    {
      this->_xsd_reason_.set (reason);
    }

    void link_created_event::
    reason (::std::auto_ptr< reason::type > reason)
    {
      this->_xsd_reason_.set (reason);
    }


    // link_open_request
    // 

    const link_open_request::link_name::type& link_open_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_open_request::link_name::type& link_open_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_open_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_open_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_opened_event
    // 

    const link_opened_event::contact_attributes::type& link_opened_event::
    contact_attributes () const
    {
      return this->_xsd_contact_attributes_.get ();
    }

    link_opened_event::contact_attributes::type& link_opened_event::
    contact_attributes ()
    {
      return this->_xsd_contact_attributes_.get ();
    }

    void link_opened_event::
    contact_attributes (const contact_attributes::type& contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    void link_opened_event::
    contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    const link_opened_event::link_name::type& link_opened_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_opened_event::link_name::type& link_opened_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_opened_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_opened_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_close_request
    // 

    const link_close_request::link_name::type& link_close_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_close_request::link_name::type& link_close_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_close_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_close_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_closed_event
    // 

    const link_closed_event::contact_attributes::type& link_closed_event::
    contact_attributes () const
    {
      return this->_xsd_contact_attributes_.get ();
    }

    link_closed_event::contact_attributes::type& link_closed_event::
    contact_attributes ()
    {
      return this->_xsd_contact_attributes_.get ();
    }

    void link_closed_event::
    contact_attributes (const contact_attributes::type& contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    void link_closed_event::
    contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    const link_closed_event::link_name::type& link_closed_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_closed_event::link_name::type& link_closed_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_closed_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_closed_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_state_changed_event
    // 

    const link_state_changed_event::link_name::type& link_state_changed_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_state_changed_event::link_name::type& link_state_changed_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_state_changed_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_state_changed_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_state_changed_event::new_state::type& link_state_changed_event::
    new_state () const
    {
      return this->_xsd_new_state_.get ();
    }

    link_state_changed_event::new_state::type& link_state_changed_event::
    new_state ()
    {
      return this->_xsd_new_state_.get ();
    }

    void link_state_changed_event::
    new_state (const new_state::type& new_state)
    {
      this->_xsd_new_state_.set (new_state);
    }

    void link_state_changed_event::
    new_state (::std::auto_ptr< new_state::type > new_state)
    {
      this->_xsd_new_state_.set (new_state);
    }

    const link_state_changed_event::reason::type& link_state_changed_event::
    reason () const
    {
      return this->_xsd_reason_.get ();
    }

    link_state_changed_event::reason::type& link_state_changed_event::
    reason ()
    {
      return this->_xsd_reason_.get ();
    }

    void link_state_changed_event::
    reason (const reason::type& reason)
    {
      this->_xsd_reason_.set (reason);
    }

    void link_state_changed_event::
    reason (::std::auto_ptr< reason::type > reason)
    {
      this->_xsd_reason_.set (reason);
    }


    // link_reconfigure_request
    // 

    const link_reconfigure_request::link_config_parameters::type& link_reconfigure_request::
    link_config_parameters () const
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    link_reconfigure_request::link_config_parameters::type& link_reconfigure_request::
    link_config_parameters ()
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    void link_reconfigure_request::
    link_config_parameters (const link_config_parameters::type& link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    void link_reconfigure_request::
    link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    const link_reconfigure_request::link_name::type& link_reconfigure_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_reconfigure_request::link_name::type& link_reconfigure_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_reconfigure_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_reconfigure_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_delete_request
    // 

    const link_delete_request::link_name::type& link_delete_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_delete_request::link_name::type& link_delete_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_delete_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_delete_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // link_deleted_event
    // 

    const link_deleted_event::link_name::type& link_deleted_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_deleted_event::link_name::type& link_deleted_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_deleted_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_deleted_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_deleted_event::reason::type& link_deleted_event::
    reason () const
    {
      return this->_xsd_reason_.get ();
    }

    link_deleted_event::reason::type& link_deleted_event::
    reason ()
    {
      return this->_xsd_reason_.get ();
    }

    void link_deleted_event::
    reason (const reason::type& reason)
    {
      this->_xsd_reason_.set (reason);
    }

    void link_deleted_event::
    reason (::std::auto_ptr< reason::type > reason)
    {
      this->_xsd_reason_.set (reason);
    }


    // link_attribute_changed_event
    // 

    const link_attribute_changed_event::link_attributes::type& link_attribute_changed_event::
    link_attributes () const
    {
      return this->_xsd_link_attributes_.get ();
    }

    link_attribute_changed_event::link_attributes::type& link_attribute_changed_event::
    link_attributes ()
    {
      return this->_xsd_link_attributes_.get ();
    }

    void link_attribute_changed_event::
    link_attributes (const link_attributes::type& link_attributes)
    {
      this->_xsd_link_attributes_.set (link_attributes);
    }

    void link_attribute_changed_event::
    link_attributes (::std::auto_ptr< link_attributes::type > link_attributes)
    {
      this->_xsd_link_attributes_.set (link_attributes);
    }

    const link_attribute_changed_event::link_name::type& link_attribute_changed_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_attribute_changed_event::link_name::type& link_attribute_changed_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_attribute_changed_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_attribute_changed_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_attribute_changed_event::reason::type& link_attribute_changed_event::
    reason () const
    {
      return this->_xsd_reason_.get ();
    }

    link_attribute_changed_event::reason::type& link_attribute_changed_event::
    reason ()
    {
      return this->_xsd_reason_.get ();
    }

    void link_attribute_changed_event::
    reason (const reason::type& reason)
    {
      this->_xsd_reason_.set (reason);
    }

    void link_attribute_changed_event::
    reason (::std::auto_ptr< reason::type > reason)
    {
      this->_xsd_reason_.set (reason);
    }


    // contact_attribute_changed_event
    // 

    const contact_attribute_changed_event::contact_attributes::type& contact_attribute_changed_event::
    contact_attributes () const
    {
      return this->_xsd_contact_attributes_.get ();
    }

    contact_attribute_changed_event::contact_attributes::type& contact_attribute_changed_event::
    contact_attributes ()
    {
      return this->_xsd_contact_attributes_.get ();
    }

    void contact_attribute_changed_event::
    contact_attributes (const contact_attributes::type& contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    void contact_attribute_changed_event::
    contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes)
    {
      this->_xsd_contact_attributes_.set (contact_attributes);
    }

    const contact_attribute_changed_event::link_name::type& contact_attribute_changed_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    contact_attribute_changed_event::link_name::type& contact_attribute_changed_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void contact_attribute_changed_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void contact_attribute_changed_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const contact_attribute_changed_event::reason::type& contact_attribute_changed_event::
    reason () const
    {
      return this->_xsd_reason_.get ();
    }

    contact_attribute_changed_event::reason::type& contact_attribute_changed_event::
    reason ()
    {
      return this->_xsd_reason_.get ();
    }

    void contact_attribute_changed_event::
    reason (const reason::type& reason)
    {
      this->_xsd_reason_.set (reason);
    }

    void contact_attribute_changed_event::
    reason (::std::auto_ptr< reason::type > reason)
    {
      this->_xsd_reason_.set (reason);
    }


    // link_add_reachable_event
    // 

    const link_add_reachable_event::link_config_parameters::type& link_add_reachable_event::
    link_config_parameters () const
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    link_add_reachable_event::link_config_parameters::type& link_add_reachable_event::
    link_config_parameters ()
    {
      return this->_xsd_link_config_parameters_.get ();
    }

    void link_add_reachable_event::
    link_config_parameters (const link_config_parameters::type& link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    void link_add_reachable_event::
    link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters)
    {
      this->_xsd_link_config_parameters_.set (link_config_parameters);
    }

    const link_add_reachable_event::link_name::type& link_add_reachable_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    link_add_reachable_event::link_name::type& link_add_reachable_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void link_add_reachable_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void link_add_reachable_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const link_add_reachable_event::peer_eid::type& link_add_reachable_event::
    peer_eid () const
    {
      return this->_xsd_peer_eid_.get ();
    }

    link_add_reachable_event::peer_eid::type& link_add_reachable_event::
    peer_eid ()
    {
      return this->_xsd_peer_eid_.get ();
    }

    void link_add_reachable_event::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void link_add_reachable_event::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // bundle_send_request
    // 

    const bundle_send_request::bundle_attributes::type& bundle_send_request::
    bundle_attributes () const
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    bundle_send_request::bundle_attributes::type& bundle_send_request::
    bundle_attributes ()
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    void bundle_send_request::
    bundle_attributes (const bundle_attributes::type& bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    void bundle_send_request::
    bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    const bundle_send_request::link_name::type& bundle_send_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    bundle_send_request::link_name::type& bundle_send_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void bundle_send_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void bundle_send_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const bundle_send_request::location::type& bundle_send_request::
    location () const
    {
      return this->_xsd_location_.get ();
    }

    bundle_send_request::location::type& bundle_send_request::
    location ()
    {
      return this->_xsd_location_.get ();
    }

    void bundle_send_request::
    location (const location::type& location)
    {
      this->_xsd_location_.set (location);
    }

    void bundle_send_request::
    location (::std::auto_ptr< location::type > location)
    {
      this->_xsd_location_.set (location);
    }


    // bundle_receive_started_event
    // 

    const bundle_receive_started_event::location::type& bundle_receive_started_event::
    location () const
    {
      return this->_xsd_location_.get ();
    }

    bundle_receive_started_event::location::type& bundle_receive_started_event::
    location ()
    {
      return this->_xsd_location_.get ();
    }

    void bundle_receive_started_event::
    location (const location::type& location)
    {
      this->_xsd_location_.set (location);
    }

    void bundle_receive_started_event::
    location (::std::auto_ptr< location::type > location)
    {
      this->_xsd_location_.set (location);
    }

    const bundle_receive_started_event::peer_eid::container& bundle_receive_started_event::
    peer_eid () const
    {
      return this->_xsd_peer_eid_;
    }

    bundle_receive_started_event::peer_eid::container& bundle_receive_started_event::
    peer_eid ()
    {
      return this->_xsd_peer_eid_;
    }

    void bundle_receive_started_event::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void bundle_receive_started_event::
    peer_eid (const peer_eid::container& peer_eid)
    {
      this->_xsd_peer_eid_ = peer_eid;
    }

    void bundle_receive_started_event::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // bundle_received_event
    // 

    const bundle_received_event::location::type& bundle_received_event::
    location () const
    {
      return this->_xsd_location_.get ();
    }

    bundle_received_event::location::type& bundle_received_event::
    location ()
    {
      return this->_xsd_location_.get ();
    }

    void bundle_received_event::
    location (const location::type& location)
    {
      this->_xsd_location_.set (location);
    }

    void bundle_received_event::
    location (::std::auto_ptr< location::type > location)
    {
      this->_xsd_location_.set (location);
    }

    const bundle_received_event::bytes_received::type& bundle_received_event::
    bytes_received () const
    {
      return this->_xsd_bytes_received_.get ();
    }

    bundle_received_event::bytes_received::type& bundle_received_event::
    bytes_received ()
    {
      return this->_xsd_bytes_received_.get ();
    }

    void bundle_received_event::
    bytes_received (const bytes_received::type& bytes_received)
    {
      this->_xsd_bytes_received_.set (bytes_received);
    }

    const bundle_received_event::peer_eid::container& bundle_received_event::
    peer_eid () const
    {
      return this->_xsd_peer_eid_;
    }

    bundle_received_event::peer_eid::container& bundle_received_event::
    peer_eid ()
    {
      return this->_xsd_peer_eid_;
    }

    void bundle_received_event::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void bundle_received_event::
    peer_eid (const peer_eid::container& peer_eid)
    {
      this->_xsd_peer_eid_ = peer_eid;
    }

    void bundle_received_event::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // bundle_transmitted_event
    // 

    const bundle_transmitted_event::bundle_attributes::type& bundle_transmitted_event::
    bundle_attributes () const
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    bundle_transmitted_event::bundle_attributes::type& bundle_transmitted_event::
    bundle_attributes ()
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    void bundle_transmitted_event::
    bundle_attributes (const bundle_attributes::type& bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    void bundle_transmitted_event::
    bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    const bundle_transmitted_event::link_name::type& bundle_transmitted_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    bundle_transmitted_event::link_name::type& bundle_transmitted_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void bundle_transmitted_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void bundle_transmitted_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const bundle_transmitted_event::bytes_sent::type& bundle_transmitted_event::
    bytes_sent () const
    {
      return this->_xsd_bytes_sent_.get ();
    }

    bundle_transmitted_event::bytes_sent::type& bundle_transmitted_event::
    bytes_sent ()
    {
      return this->_xsd_bytes_sent_.get ();
    }

    void bundle_transmitted_event::
    bytes_sent (const bytes_sent::type& bytes_sent)
    {
      this->_xsd_bytes_sent_.set (bytes_sent);
    }

    const bundle_transmitted_event::reliably_sent::type& bundle_transmitted_event::
    reliably_sent () const
    {
      return this->_xsd_reliably_sent_.get ();
    }

    bundle_transmitted_event::reliably_sent::type& bundle_transmitted_event::
    reliably_sent ()
    {
      return this->_xsd_reliably_sent_.get ();
    }

    void bundle_transmitted_event::
    reliably_sent (const reliably_sent::type& reliably_sent)
    {
      this->_xsd_reliably_sent_.set (reliably_sent);
    }


    // bundle_cancel_request
    // 

    const bundle_cancel_request::bundle_attributes::type& bundle_cancel_request::
    bundle_attributes () const
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    bundle_cancel_request::bundle_attributes::type& bundle_cancel_request::
    bundle_attributes ()
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    void bundle_cancel_request::
    bundle_attributes (const bundle_attributes::type& bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    void bundle_cancel_request::
    bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    const bundle_cancel_request::link_name::type& bundle_cancel_request::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    bundle_cancel_request::link_name::type& bundle_cancel_request::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void bundle_cancel_request::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void bundle_cancel_request::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // bundle_canceled_event
    // 

    const bundle_canceled_event::bundle_attributes::type& bundle_canceled_event::
    bundle_attributes () const
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    bundle_canceled_event::bundle_attributes::type& bundle_canceled_event::
    bundle_attributes ()
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    void bundle_canceled_event::
    bundle_attributes (const bundle_attributes::type& bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    void bundle_canceled_event::
    bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    const bundle_canceled_event::link_name::type& bundle_canceled_event::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    bundle_canceled_event::link_name::type& bundle_canceled_event::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void bundle_canceled_event::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void bundle_canceled_event::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // query_bundle_queued
    // 

    const query_bundle_queued::bundle_attributes::type& query_bundle_queued::
    bundle_attributes () const
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    query_bundle_queued::bundle_attributes::type& query_bundle_queued::
    bundle_attributes ()
    {
      return this->_xsd_bundle_attributes_.get ();
    }

    void query_bundle_queued::
    bundle_attributes (const bundle_attributes::type& bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    void query_bundle_queued::
    bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes)
    {
      this->_xsd_bundle_attributes_.set (bundle_attributes);
    }

    const query_bundle_queued::query_id::type& query_bundle_queued::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    query_bundle_queued::query_id::type& query_bundle_queued::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void query_bundle_queued::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void query_bundle_queued::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    const query_bundle_queued::link_name::type& query_bundle_queued::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    query_bundle_queued::link_name::type& query_bundle_queued::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void query_bundle_queued::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void query_bundle_queued::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }


    // report_bundle_queued
    // 

    const report_bundle_queued::query_id::type& report_bundle_queued::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    report_bundle_queued::query_id::type& report_bundle_queued::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void report_bundle_queued::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void report_bundle_queued::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    const report_bundle_queued::is_queued::type& report_bundle_queued::
    is_queued () const
    {
      return this->_xsd_is_queued_.get ();
    }

    report_bundle_queued::is_queued::type& report_bundle_queued::
    is_queued ()
    {
      return this->_xsd_is_queued_.get ();
    }

    void report_bundle_queued::
    is_queued (const is_queued::type& is_queued)
    {
      this->_xsd_is_queued_.set (is_queued);
    }


    // query_eid_reachable
    // 

    const query_eid_reachable::query_id::type& query_eid_reachable::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    query_eid_reachable::query_id::type& query_eid_reachable::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void query_eid_reachable::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void query_eid_reachable::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    const query_eid_reachable::interface_name::type& query_eid_reachable::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    query_eid_reachable::interface_name::type& query_eid_reachable::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void query_eid_reachable::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void query_eid_reachable::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    const query_eid_reachable::peer_eid::type& query_eid_reachable::
    peer_eid () const
    {
      return this->_xsd_peer_eid_.get ();
    }

    query_eid_reachable::peer_eid::type& query_eid_reachable::
    peer_eid ()
    {
      return this->_xsd_peer_eid_.get ();
    }

    void query_eid_reachable::
    peer_eid (const peer_eid::type& peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }

    void query_eid_reachable::
    peer_eid (::std::auto_ptr< peer_eid::type > peer_eid)
    {
      this->_xsd_peer_eid_.set (peer_eid);
    }


    // report_eid_reachable
    // 

    const report_eid_reachable::query_id::type& report_eid_reachable::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    report_eid_reachable::query_id::type& report_eid_reachable::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void report_eid_reachable::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void report_eid_reachable::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    const report_eid_reachable::is_reachable::type& report_eid_reachable::
    is_reachable () const
    {
      return this->_xsd_is_reachable_.get ();
    }

    report_eid_reachable::is_reachable::type& report_eid_reachable::
    is_reachable ()
    {
      return this->_xsd_is_reachable_.get ();
    }

    void report_eid_reachable::
    is_reachable (const is_reachable::type& is_reachable)
    {
      this->_xsd_is_reachable_.set (is_reachable);
    }


    // query_link_attributes
    // 

    const query_link_attributes::attribute_name::container& query_link_attributes::
    attribute_name () const
    {
      return this->_xsd_attribute_name_;
    }

    query_link_attributes::attribute_name::container& query_link_attributes::
    attribute_name ()
    {
      return this->_xsd_attribute_name_;
    }

    void query_link_attributes::
    attribute_name (const attribute_name::container& attribute_name)
    {
      this->_xsd_attribute_name_ = attribute_name;
    }

    const query_link_attributes::link_name::type& query_link_attributes::
    link_name () const
    {
      return this->_xsd_link_name_.get ();
    }

    query_link_attributes::link_name::type& query_link_attributes::
    link_name ()
    {
      return this->_xsd_link_name_.get ();
    }

    void query_link_attributes::
    link_name (const link_name::type& link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    void query_link_attributes::
    link_name (::std::auto_ptr< link_name::type > link_name)
    {
      this->_xsd_link_name_.set (link_name);
    }

    const query_link_attributes::query_id::type& query_link_attributes::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    query_link_attributes::query_id::type& query_link_attributes::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void query_link_attributes::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void query_link_attributes::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // report_link_attributes
    // 

    const report_link_attributes::key_value_pair::container& report_link_attributes::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    report_link_attributes::key_value_pair::container& report_link_attributes::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void report_link_attributes::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const report_link_attributes::query_id::type& report_link_attributes::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    report_link_attributes::query_id::type& report_link_attributes::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void report_link_attributes::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void report_link_attributes::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // query_interface_attributes
    // 

    const query_interface_attributes::attribute_name::container& query_interface_attributes::
    attribute_name () const
    {
      return this->_xsd_attribute_name_;
    }

    query_interface_attributes::attribute_name::container& query_interface_attributes::
    attribute_name ()
    {
      return this->_xsd_attribute_name_;
    }

    void query_interface_attributes::
    attribute_name (const attribute_name::container& attribute_name)
    {
      this->_xsd_attribute_name_ = attribute_name;
    }

    const query_interface_attributes::interface_name::type& query_interface_attributes::
    interface_name () const
    {
      return this->_xsd_interface_name_.get ();
    }

    query_interface_attributes::interface_name::type& query_interface_attributes::
    interface_name ()
    {
      return this->_xsd_interface_name_.get ();
    }

    void query_interface_attributes::
    interface_name (const interface_name::type& interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    void query_interface_attributes::
    interface_name (::std::auto_ptr< interface_name::type > interface_name)
    {
      this->_xsd_interface_name_.set (interface_name);
    }

    const query_interface_attributes::query_id::type& query_interface_attributes::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    query_interface_attributes::query_id::type& query_interface_attributes::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void query_interface_attributes::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void query_interface_attributes::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // report_interface_attributes
    // 

    const report_interface_attributes::key_value_pair::container& report_interface_attributes::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    report_interface_attributes::key_value_pair::container& report_interface_attributes::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void report_interface_attributes::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const report_interface_attributes::query_id::type& report_interface_attributes::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    report_interface_attributes::query_id::type& report_interface_attributes::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void report_interface_attributes::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void report_interface_attributes::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // query_cla_parameters
    // 

    const query_cla_parameters::attribute_name::container& query_cla_parameters::
    attribute_name () const
    {
      return this->_xsd_attribute_name_;
    }

    query_cla_parameters::attribute_name::container& query_cla_parameters::
    attribute_name ()
    {
      return this->_xsd_attribute_name_;
    }

    void query_cla_parameters::
    attribute_name (const attribute_name::container& attribute_name)
    {
      this->_xsd_attribute_name_ = attribute_name;
    }

    const query_cla_parameters::query_id::type& query_cla_parameters::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    query_cla_parameters::query_id::type& query_cla_parameters::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void query_cla_parameters::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void query_cla_parameters::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // report_cla_parameters
    // 

    const report_cla_parameters::key_value_pair::container& report_cla_parameters::
    key_value_pair () const
    {
      return this->_xsd_key_value_pair_;
    }

    report_cla_parameters::key_value_pair::container& report_cla_parameters::
    key_value_pair ()
    {
      return this->_xsd_key_value_pair_;
    }

    void report_cla_parameters::
    key_value_pair (const key_value_pair::container& key_value_pair)
    {
      this->_xsd_key_value_pair_ = key_value_pair;
    }

    const report_cla_parameters::query_id::type& report_cla_parameters::
    query_id () const
    {
      return this->_xsd_query_id_.get ();
    }

    report_cla_parameters::query_id::type& report_cla_parameters::
    query_id ()
    {
      return this->_xsd_query_id_.get ();
    }

    void report_cla_parameters::
    query_id (const query_id::type& query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }

    void report_cla_parameters::
    query_id (::std::auto_ptr< query_id::type > query_id)
    {
      this->_xsd_query_id_.set (query_id);
    }


    // cl_message
    // 

    const cl_message::cla_add_request::container& cl_message::
    cla_add_request () const
    {
      return this->_xsd_cla_add_request_;
    }

    cl_message::cla_add_request::container& cl_message::
    cla_add_request ()
    {
      return this->_xsd_cla_add_request_;
    }

    void cl_message::
    cla_add_request (const cla_add_request::type& cla_add_request)
    {
      this->_xsd_cla_add_request_.set (cla_add_request);
    }

    void cl_message::
    cla_add_request (const cla_add_request::container& cla_add_request)
    {
      this->_xsd_cla_add_request_ = cla_add_request;
    }

    void cl_message::
    cla_add_request (::std::auto_ptr< cla_add_request::type > cla_add_request)
    {
      this->_xsd_cla_add_request_.set (cla_add_request);
    }

    const cl_message::cla_delete_request::container& cl_message::
    cla_delete_request () const
    {
      return this->_xsd_cla_delete_request_;
    }

    cl_message::cla_delete_request::container& cl_message::
    cla_delete_request ()
    {
      return this->_xsd_cla_delete_request_;
    }

    void cl_message::
    cla_delete_request (const cla_delete_request::type& cla_delete_request)
    {
      this->_xsd_cla_delete_request_.set (cla_delete_request);
    }

    void cl_message::
    cla_delete_request (const cla_delete_request::container& cla_delete_request)
    {
      this->_xsd_cla_delete_request_ = cla_delete_request;
    }

    void cl_message::
    cla_delete_request (::std::auto_ptr< cla_delete_request::type > cla_delete_request)
    {
      this->_xsd_cla_delete_request_.set (cla_delete_request);
    }

    const cl_message::cla_set_params_request::container& cl_message::
    cla_set_params_request () const
    {
      return this->_xsd_cla_set_params_request_;
    }

    cl_message::cla_set_params_request::container& cl_message::
    cla_set_params_request ()
    {
      return this->_xsd_cla_set_params_request_;
    }

    void cl_message::
    cla_set_params_request (const cla_set_params_request::type& cla_set_params_request)
    {
      this->_xsd_cla_set_params_request_.set (cla_set_params_request);
    }

    void cl_message::
    cla_set_params_request (const cla_set_params_request::container& cla_set_params_request)
    {
      this->_xsd_cla_set_params_request_ = cla_set_params_request;
    }

    void cl_message::
    cla_set_params_request (::std::auto_ptr< cla_set_params_request::type > cla_set_params_request)
    {
      this->_xsd_cla_set_params_request_.set (cla_set_params_request);
    }

    const cl_message::cla_params_set_event::container& cl_message::
    cla_params_set_event () const
    {
      return this->_xsd_cla_params_set_event_;
    }

    cl_message::cla_params_set_event::container& cl_message::
    cla_params_set_event ()
    {
      return this->_xsd_cla_params_set_event_;
    }

    void cl_message::
    cla_params_set_event (const cla_params_set_event::type& cla_params_set_event)
    {
      this->_xsd_cla_params_set_event_.set (cla_params_set_event);
    }

    void cl_message::
    cla_params_set_event (const cla_params_set_event::container& cla_params_set_event)
    {
      this->_xsd_cla_params_set_event_ = cla_params_set_event;
    }

    void cl_message::
    cla_params_set_event (::std::auto_ptr< cla_params_set_event::type > cla_params_set_event)
    {
      this->_xsd_cla_params_set_event_.set (cla_params_set_event);
    }

    const cl_message::interface_set_defaults_request::container& cl_message::
    interface_set_defaults_request () const
    {
      return this->_xsd_interface_set_defaults_request_;
    }

    cl_message::interface_set_defaults_request::container& cl_message::
    interface_set_defaults_request ()
    {
      return this->_xsd_interface_set_defaults_request_;
    }

    void cl_message::
    interface_set_defaults_request (const interface_set_defaults_request::type& interface_set_defaults_request)
    {
      this->_xsd_interface_set_defaults_request_.set (interface_set_defaults_request);
    }

    void cl_message::
    interface_set_defaults_request (const interface_set_defaults_request::container& interface_set_defaults_request)
    {
      this->_xsd_interface_set_defaults_request_ = interface_set_defaults_request;
    }

    void cl_message::
    interface_set_defaults_request (::std::auto_ptr< interface_set_defaults_request::type > interface_set_defaults_request)
    {
      this->_xsd_interface_set_defaults_request_.set (interface_set_defaults_request);
    }

    const cl_message::interface_create_request::container& cl_message::
    interface_create_request () const
    {
      return this->_xsd_interface_create_request_;
    }

    cl_message::interface_create_request::container& cl_message::
    interface_create_request ()
    {
      return this->_xsd_interface_create_request_;
    }

    void cl_message::
    interface_create_request (const interface_create_request::type& interface_create_request)
    {
      this->_xsd_interface_create_request_.set (interface_create_request);
    }

    void cl_message::
    interface_create_request (const interface_create_request::container& interface_create_request)
    {
      this->_xsd_interface_create_request_ = interface_create_request;
    }

    void cl_message::
    interface_create_request (::std::auto_ptr< interface_create_request::type > interface_create_request)
    {
      this->_xsd_interface_create_request_.set (interface_create_request);
    }

    const cl_message::interface_created_event::container& cl_message::
    interface_created_event () const
    {
      return this->_xsd_interface_created_event_;
    }

    cl_message::interface_created_event::container& cl_message::
    interface_created_event ()
    {
      return this->_xsd_interface_created_event_;
    }

    void cl_message::
    interface_created_event (const interface_created_event::type& interface_created_event)
    {
      this->_xsd_interface_created_event_.set (interface_created_event);
    }

    void cl_message::
    interface_created_event (const interface_created_event::container& interface_created_event)
    {
      this->_xsd_interface_created_event_ = interface_created_event;
    }

    void cl_message::
    interface_created_event (::std::auto_ptr< interface_created_event::type > interface_created_event)
    {
      this->_xsd_interface_created_event_.set (interface_created_event);
    }

    const cl_message::interface_reconfigure_request::container& cl_message::
    interface_reconfigure_request () const
    {
      return this->_xsd_interface_reconfigure_request_;
    }

    cl_message::interface_reconfigure_request::container& cl_message::
    interface_reconfigure_request ()
    {
      return this->_xsd_interface_reconfigure_request_;
    }

    void cl_message::
    interface_reconfigure_request (const interface_reconfigure_request::type& interface_reconfigure_request)
    {
      this->_xsd_interface_reconfigure_request_.set (interface_reconfigure_request);
    }

    void cl_message::
    interface_reconfigure_request (const interface_reconfigure_request::container& interface_reconfigure_request)
    {
      this->_xsd_interface_reconfigure_request_ = interface_reconfigure_request;
    }

    void cl_message::
    interface_reconfigure_request (::std::auto_ptr< interface_reconfigure_request::type > interface_reconfigure_request)
    {
      this->_xsd_interface_reconfigure_request_.set (interface_reconfigure_request);
    }

    const cl_message::interface_reconfigured_event::container& cl_message::
    interface_reconfigured_event () const
    {
      return this->_xsd_interface_reconfigured_event_;
    }

    cl_message::interface_reconfigured_event::container& cl_message::
    interface_reconfigured_event ()
    {
      return this->_xsd_interface_reconfigured_event_;
    }

    void cl_message::
    interface_reconfigured_event (const interface_reconfigured_event::type& interface_reconfigured_event)
    {
      this->_xsd_interface_reconfigured_event_.set (interface_reconfigured_event);
    }

    void cl_message::
    interface_reconfigured_event (const interface_reconfigured_event::container& interface_reconfigured_event)
    {
      this->_xsd_interface_reconfigured_event_ = interface_reconfigured_event;
    }

    void cl_message::
    interface_reconfigured_event (::std::auto_ptr< interface_reconfigured_event::type > interface_reconfigured_event)
    {
      this->_xsd_interface_reconfigured_event_.set (interface_reconfigured_event);
    }

    const cl_message::interface_destroy_request::container& cl_message::
    interface_destroy_request () const
    {
      return this->_xsd_interface_destroy_request_;
    }

    cl_message::interface_destroy_request::container& cl_message::
    interface_destroy_request ()
    {
      return this->_xsd_interface_destroy_request_;
    }

    void cl_message::
    interface_destroy_request (const interface_destroy_request::type& interface_destroy_request)
    {
      this->_xsd_interface_destroy_request_.set (interface_destroy_request);
    }

    void cl_message::
    interface_destroy_request (const interface_destroy_request::container& interface_destroy_request)
    {
      this->_xsd_interface_destroy_request_ = interface_destroy_request;
    }

    void cl_message::
    interface_destroy_request (::std::auto_ptr< interface_destroy_request::type > interface_destroy_request)
    {
      this->_xsd_interface_destroy_request_.set (interface_destroy_request);
    }

    const cl_message::eid_reachable_event::container& cl_message::
    eid_reachable_event () const
    {
      return this->_xsd_eid_reachable_event_;
    }

    cl_message::eid_reachable_event::container& cl_message::
    eid_reachable_event ()
    {
      return this->_xsd_eid_reachable_event_;
    }

    void cl_message::
    eid_reachable_event (const eid_reachable_event::type& eid_reachable_event)
    {
      this->_xsd_eid_reachable_event_.set (eid_reachable_event);
    }

    void cl_message::
    eid_reachable_event (const eid_reachable_event::container& eid_reachable_event)
    {
      this->_xsd_eid_reachable_event_ = eid_reachable_event;
    }

    void cl_message::
    eid_reachable_event (::std::auto_ptr< eid_reachable_event::type > eid_reachable_event)
    {
      this->_xsd_eid_reachable_event_.set (eid_reachable_event);
    }

    const cl_message::link_set_defaults_request::container& cl_message::
    link_set_defaults_request () const
    {
      return this->_xsd_link_set_defaults_request_;
    }

    cl_message::link_set_defaults_request::container& cl_message::
    link_set_defaults_request ()
    {
      return this->_xsd_link_set_defaults_request_;
    }

    void cl_message::
    link_set_defaults_request (const link_set_defaults_request::type& link_set_defaults_request)
    {
      this->_xsd_link_set_defaults_request_.set (link_set_defaults_request);
    }

    void cl_message::
    link_set_defaults_request (const link_set_defaults_request::container& link_set_defaults_request)
    {
      this->_xsd_link_set_defaults_request_ = link_set_defaults_request;
    }

    void cl_message::
    link_set_defaults_request (::std::auto_ptr< link_set_defaults_request::type > link_set_defaults_request)
    {
      this->_xsd_link_set_defaults_request_.set (link_set_defaults_request);
    }

    const cl_message::link_create_request::container& cl_message::
    link_create_request () const
    {
      return this->_xsd_link_create_request_;
    }

    cl_message::link_create_request::container& cl_message::
    link_create_request ()
    {
      return this->_xsd_link_create_request_;
    }

    void cl_message::
    link_create_request (const link_create_request::type& link_create_request)
    {
      this->_xsd_link_create_request_.set (link_create_request);
    }

    void cl_message::
    link_create_request (const link_create_request::container& link_create_request)
    {
      this->_xsd_link_create_request_ = link_create_request;
    }

    void cl_message::
    link_create_request (::std::auto_ptr< link_create_request::type > link_create_request)
    {
      this->_xsd_link_create_request_.set (link_create_request);
    }

    const cl_message::link_created_event::container& cl_message::
    link_created_event () const
    {
      return this->_xsd_link_created_event_;
    }

    cl_message::link_created_event::container& cl_message::
    link_created_event ()
    {
      return this->_xsd_link_created_event_;
    }

    void cl_message::
    link_created_event (const link_created_event::type& link_created_event)
    {
      this->_xsd_link_created_event_.set (link_created_event);
    }

    void cl_message::
    link_created_event (const link_created_event::container& link_created_event)
    {
      this->_xsd_link_created_event_ = link_created_event;
    }

    void cl_message::
    link_created_event (::std::auto_ptr< link_created_event::type > link_created_event)
    {
      this->_xsd_link_created_event_.set (link_created_event);
    }

    const cl_message::link_open_request::container& cl_message::
    link_open_request () const
    {
      return this->_xsd_link_open_request_;
    }

    cl_message::link_open_request::container& cl_message::
    link_open_request ()
    {
      return this->_xsd_link_open_request_;
    }

    void cl_message::
    link_open_request (const link_open_request::type& link_open_request)
    {
      this->_xsd_link_open_request_.set (link_open_request);
    }

    void cl_message::
    link_open_request (const link_open_request::container& link_open_request)
    {
      this->_xsd_link_open_request_ = link_open_request;
    }

    void cl_message::
    link_open_request (::std::auto_ptr< link_open_request::type > link_open_request)
    {
      this->_xsd_link_open_request_.set (link_open_request);
    }

    const cl_message::link_opened_event::container& cl_message::
    link_opened_event () const
    {
      return this->_xsd_link_opened_event_;
    }

    cl_message::link_opened_event::container& cl_message::
    link_opened_event ()
    {
      return this->_xsd_link_opened_event_;
    }

    void cl_message::
    link_opened_event (const link_opened_event::type& link_opened_event)
    {
      this->_xsd_link_opened_event_.set (link_opened_event);
    }

    void cl_message::
    link_opened_event (const link_opened_event::container& link_opened_event)
    {
      this->_xsd_link_opened_event_ = link_opened_event;
    }

    void cl_message::
    link_opened_event (::std::auto_ptr< link_opened_event::type > link_opened_event)
    {
      this->_xsd_link_opened_event_.set (link_opened_event);
    }

    const cl_message::link_close_request::container& cl_message::
    link_close_request () const
    {
      return this->_xsd_link_close_request_;
    }

    cl_message::link_close_request::container& cl_message::
    link_close_request ()
    {
      return this->_xsd_link_close_request_;
    }

    void cl_message::
    link_close_request (const link_close_request::type& link_close_request)
    {
      this->_xsd_link_close_request_.set (link_close_request);
    }

    void cl_message::
    link_close_request (const link_close_request::container& link_close_request)
    {
      this->_xsd_link_close_request_ = link_close_request;
    }

    void cl_message::
    link_close_request (::std::auto_ptr< link_close_request::type > link_close_request)
    {
      this->_xsd_link_close_request_.set (link_close_request);
    }

    const cl_message::link_closed_event::container& cl_message::
    link_closed_event () const
    {
      return this->_xsd_link_closed_event_;
    }

    cl_message::link_closed_event::container& cl_message::
    link_closed_event ()
    {
      return this->_xsd_link_closed_event_;
    }

    void cl_message::
    link_closed_event (const link_closed_event::type& link_closed_event)
    {
      this->_xsd_link_closed_event_.set (link_closed_event);
    }

    void cl_message::
    link_closed_event (const link_closed_event::container& link_closed_event)
    {
      this->_xsd_link_closed_event_ = link_closed_event;
    }

    void cl_message::
    link_closed_event (::std::auto_ptr< link_closed_event::type > link_closed_event)
    {
      this->_xsd_link_closed_event_.set (link_closed_event);
    }

    const cl_message::link_state_changed_event::container& cl_message::
    link_state_changed_event () const
    {
      return this->_xsd_link_state_changed_event_;
    }

    cl_message::link_state_changed_event::container& cl_message::
    link_state_changed_event ()
    {
      return this->_xsd_link_state_changed_event_;
    }

    void cl_message::
    link_state_changed_event (const link_state_changed_event::type& link_state_changed_event)
    {
      this->_xsd_link_state_changed_event_.set (link_state_changed_event);
    }

    void cl_message::
    link_state_changed_event (const link_state_changed_event::container& link_state_changed_event)
    {
      this->_xsd_link_state_changed_event_ = link_state_changed_event;
    }

    void cl_message::
    link_state_changed_event (::std::auto_ptr< link_state_changed_event::type > link_state_changed_event)
    {
      this->_xsd_link_state_changed_event_.set (link_state_changed_event);
    }

    const cl_message::link_reconfigure_request::container& cl_message::
    link_reconfigure_request () const
    {
      return this->_xsd_link_reconfigure_request_;
    }

    cl_message::link_reconfigure_request::container& cl_message::
    link_reconfigure_request ()
    {
      return this->_xsd_link_reconfigure_request_;
    }

    void cl_message::
    link_reconfigure_request (const link_reconfigure_request::type& link_reconfigure_request)
    {
      this->_xsd_link_reconfigure_request_.set (link_reconfigure_request);
    }

    void cl_message::
    link_reconfigure_request (const link_reconfigure_request::container& link_reconfigure_request)
    {
      this->_xsd_link_reconfigure_request_ = link_reconfigure_request;
    }

    void cl_message::
    link_reconfigure_request (::std::auto_ptr< link_reconfigure_request::type > link_reconfigure_request)
    {
      this->_xsd_link_reconfigure_request_.set (link_reconfigure_request);
    }

    const cl_message::link_delete_request::container& cl_message::
    link_delete_request () const
    {
      return this->_xsd_link_delete_request_;
    }

    cl_message::link_delete_request::container& cl_message::
    link_delete_request ()
    {
      return this->_xsd_link_delete_request_;
    }

    void cl_message::
    link_delete_request (const link_delete_request::type& link_delete_request)
    {
      this->_xsd_link_delete_request_.set (link_delete_request);
    }

    void cl_message::
    link_delete_request (const link_delete_request::container& link_delete_request)
    {
      this->_xsd_link_delete_request_ = link_delete_request;
    }

    void cl_message::
    link_delete_request (::std::auto_ptr< link_delete_request::type > link_delete_request)
    {
      this->_xsd_link_delete_request_.set (link_delete_request);
    }

    const cl_message::link_deleted_event::container& cl_message::
    link_deleted_event () const
    {
      return this->_xsd_link_deleted_event_;
    }

    cl_message::link_deleted_event::container& cl_message::
    link_deleted_event ()
    {
      return this->_xsd_link_deleted_event_;
    }

    void cl_message::
    link_deleted_event (const link_deleted_event::type& link_deleted_event)
    {
      this->_xsd_link_deleted_event_.set (link_deleted_event);
    }

    void cl_message::
    link_deleted_event (const link_deleted_event::container& link_deleted_event)
    {
      this->_xsd_link_deleted_event_ = link_deleted_event;
    }

    void cl_message::
    link_deleted_event (::std::auto_ptr< link_deleted_event::type > link_deleted_event)
    {
      this->_xsd_link_deleted_event_.set (link_deleted_event);
    }

    const cl_message::link_attribute_changed_event::container& cl_message::
    link_attribute_changed_event () const
    {
      return this->_xsd_link_attribute_changed_event_;
    }

    cl_message::link_attribute_changed_event::container& cl_message::
    link_attribute_changed_event ()
    {
      return this->_xsd_link_attribute_changed_event_;
    }

    void cl_message::
    link_attribute_changed_event (const link_attribute_changed_event::type& link_attribute_changed_event)
    {
      this->_xsd_link_attribute_changed_event_.set (link_attribute_changed_event);
    }

    void cl_message::
    link_attribute_changed_event (const link_attribute_changed_event::container& link_attribute_changed_event)
    {
      this->_xsd_link_attribute_changed_event_ = link_attribute_changed_event;
    }

    void cl_message::
    link_attribute_changed_event (::std::auto_ptr< link_attribute_changed_event::type > link_attribute_changed_event)
    {
      this->_xsd_link_attribute_changed_event_.set (link_attribute_changed_event);
    }

    const cl_message::contact_attribute_changed_event::container& cl_message::
    contact_attribute_changed_event () const
    {
      return this->_xsd_contact_attribute_changed_event_;
    }

    cl_message::contact_attribute_changed_event::container& cl_message::
    contact_attribute_changed_event ()
    {
      return this->_xsd_contact_attribute_changed_event_;
    }

    void cl_message::
    contact_attribute_changed_event (const contact_attribute_changed_event::type& contact_attribute_changed_event)
    {
      this->_xsd_contact_attribute_changed_event_.set (contact_attribute_changed_event);
    }

    void cl_message::
    contact_attribute_changed_event (const contact_attribute_changed_event::container& contact_attribute_changed_event)
    {
      this->_xsd_contact_attribute_changed_event_ = contact_attribute_changed_event;
    }

    void cl_message::
    contact_attribute_changed_event (::std::auto_ptr< contact_attribute_changed_event::type > contact_attribute_changed_event)
    {
      this->_xsd_contact_attribute_changed_event_.set (contact_attribute_changed_event);
    }

    const cl_message::link_add_reachable_event::container& cl_message::
    link_add_reachable_event () const
    {
      return this->_xsd_link_add_reachable_event_;
    }

    cl_message::link_add_reachable_event::container& cl_message::
    link_add_reachable_event ()
    {
      return this->_xsd_link_add_reachable_event_;
    }

    void cl_message::
    link_add_reachable_event (const link_add_reachable_event::type& link_add_reachable_event)
    {
      this->_xsd_link_add_reachable_event_.set (link_add_reachable_event);
    }

    void cl_message::
    link_add_reachable_event (const link_add_reachable_event::container& link_add_reachable_event)
    {
      this->_xsd_link_add_reachable_event_ = link_add_reachable_event;
    }

    void cl_message::
    link_add_reachable_event (::std::auto_ptr< link_add_reachable_event::type > link_add_reachable_event)
    {
      this->_xsd_link_add_reachable_event_.set (link_add_reachable_event);
    }

    const cl_message::bundle_send_request::container& cl_message::
    bundle_send_request () const
    {
      return this->_xsd_bundle_send_request_;
    }

    cl_message::bundle_send_request::container& cl_message::
    bundle_send_request ()
    {
      return this->_xsd_bundle_send_request_;
    }

    void cl_message::
    bundle_send_request (const bundle_send_request::type& bundle_send_request)
    {
      this->_xsd_bundle_send_request_.set (bundle_send_request);
    }

    void cl_message::
    bundle_send_request (const bundle_send_request::container& bundle_send_request)
    {
      this->_xsd_bundle_send_request_ = bundle_send_request;
    }

    void cl_message::
    bundle_send_request (::std::auto_ptr< bundle_send_request::type > bundle_send_request)
    {
      this->_xsd_bundle_send_request_.set (bundle_send_request);
    }

    const cl_message::bundle_receive_started_event::container& cl_message::
    bundle_receive_started_event () const
    {
      return this->_xsd_bundle_receive_started_event_;
    }

    cl_message::bundle_receive_started_event::container& cl_message::
    bundle_receive_started_event ()
    {
      return this->_xsd_bundle_receive_started_event_;
    }

    void cl_message::
    bundle_receive_started_event (const bundle_receive_started_event::type& bundle_receive_started_event)
    {
      this->_xsd_bundle_receive_started_event_.set (bundle_receive_started_event);
    }

    void cl_message::
    bundle_receive_started_event (const bundle_receive_started_event::container& bundle_receive_started_event)
    {
      this->_xsd_bundle_receive_started_event_ = bundle_receive_started_event;
    }

    void cl_message::
    bundle_receive_started_event (::std::auto_ptr< bundle_receive_started_event::type > bundle_receive_started_event)
    {
      this->_xsd_bundle_receive_started_event_.set (bundle_receive_started_event);
    }

    const cl_message::bundle_received_event::container& cl_message::
    bundle_received_event () const
    {
      return this->_xsd_bundle_received_event_;
    }

    cl_message::bundle_received_event::container& cl_message::
    bundle_received_event ()
    {
      return this->_xsd_bundle_received_event_;
    }

    void cl_message::
    bundle_received_event (const bundle_received_event::type& bundle_received_event)
    {
      this->_xsd_bundle_received_event_.set (bundle_received_event);
    }

    void cl_message::
    bundle_received_event (const bundle_received_event::container& bundle_received_event)
    {
      this->_xsd_bundle_received_event_ = bundle_received_event;
    }

    void cl_message::
    bundle_received_event (::std::auto_ptr< bundle_received_event::type > bundle_received_event)
    {
      this->_xsd_bundle_received_event_.set (bundle_received_event);
    }

    const cl_message::bundle_transmitted_event::container& cl_message::
    bundle_transmitted_event () const
    {
      return this->_xsd_bundle_transmitted_event_;
    }

    cl_message::bundle_transmitted_event::container& cl_message::
    bundle_transmitted_event ()
    {
      return this->_xsd_bundle_transmitted_event_;
    }

    void cl_message::
    bundle_transmitted_event (const bundle_transmitted_event::type& bundle_transmitted_event)
    {
      this->_xsd_bundle_transmitted_event_.set (bundle_transmitted_event);
    }

    void cl_message::
    bundle_transmitted_event (const bundle_transmitted_event::container& bundle_transmitted_event)
    {
      this->_xsd_bundle_transmitted_event_ = bundle_transmitted_event;
    }

    void cl_message::
    bundle_transmitted_event (::std::auto_ptr< bundle_transmitted_event::type > bundle_transmitted_event)
    {
      this->_xsd_bundle_transmitted_event_.set (bundle_transmitted_event);
    }

    const cl_message::bundle_cancel_request::container& cl_message::
    bundle_cancel_request () const
    {
      return this->_xsd_bundle_cancel_request_;
    }

    cl_message::bundle_cancel_request::container& cl_message::
    bundle_cancel_request ()
    {
      return this->_xsd_bundle_cancel_request_;
    }

    void cl_message::
    bundle_cancel_request (const bundle_cancel_request::type& bundle_cancel_request)
    {
      this->_xsd_bundle_cancel_request_.set (bundle_cancel_request);
    }

    void cl_message::
    bundle_cancel_request (const bundle_cancel_request::container& bundle_cancel_request)
    {
      this->_xsd_bundle_cancel_request_ = bundle_cancel_request;
    }

    void cl_message::
    bundle_cancel_request (::std::auto_ptr< bundle_cancel_request::type > bundle_cancel_request)
    {
      this->_xsd_bundle_cancel_request_.set (bundle_cancel_request);
    }

    const cl_message::bundle_canceled_event::container& cl_message::
    bundle_canceled_event () const
    {
      return this->_xsd_bundle_canceled_event_;
    }

    cl_message::bundle_canceled_event::container& cl_message::
    bundle_canceled_event ()
    {
      return this->_xsd_bundle_canceled_event_;
    }

    void cl_message::
    bundle_canceled_event (const bundle_canceled_event::type& bundle_canceled_event)
    {
      this->_xsd_bundle_canceled_event_.set (bundle_canceled_event);
    }

    void cl_message::
    bundle_canceled_event (const bundle_canceled_event::container& bundle_canceled_event)
    {
      this->_xsd_bundle_canceled_event_ = bundle_canceled_event;
    }

    void cl_message::
    bundle_canceled_event (::std::auto_ptr< bundle_canceled_event::type > bundle_canceled_event)
    {
      this->_xsd_bundle_canceled_event_.set (bundle_canceled_event);
    }

    const cl_message::query_bundle_queued::container& cl_message::
    query_bundle_queued () const
    {
      return this->_xsd_query_bundle_queued_;
    }

    cl_message::query_bundle_queued::container& cl_message::
    query_bundle_queued ()
    {
      return this->_xsd_query_bundle_queued_;
    }

    void cl_message::
    query_bundle_queued (const query_bundle_queued::type& query_bundle_queued)
    {
      this->_xsd_query_bundle_queued_.set (query_bundle_queued);
    }

    void cl_message::
    query_bundle_queued (const query_bundle_queued::container& query_bundle_queued)
    {
      this->_xsd_query_bundle_queued_ = query_bundle_queued;
    }

    void cl_message::
    query_bundle_queued (::std::auto_ptr< query_bundle_queued::type > query_bundle_queued)
    {
      this->_xsd_query_bundle_queued_.set (query_bundle_queued);
    }

    const cl_message::report_bundle_queued::container& cl_message::
    report_bundle_queued () const
    {
      return this->_xsd_report_bundle_queued_;
    }

    cl_message::report_bundle_queued::container& cl_message::
    report_bundle_queued ()
    {
      return this->_xsd_report_bundle_queued_;
    }

    void cl_message::
    report_bundle_queued (const report_bundle_queued::type& report_bundle_queued)
    {
      this->_xsd_report_bundle_queued_.set (report_bundle_queued);
    }

    void cl_message::
    report_bundle_queued (const report_bundle_queued::container& report_bundle_queued)
    {
      this->_xsd_report_bundle_queued_ = report_bundle_queued;
    }

    void cl_message::
    report_bundle_queued (::std::auto_ptr< report_bundle_queued::type > report_bundle_queued)
    {
      this->_xsd_report_bundle_queued_.set (report_bundle_queued);
    }

    const cl_message::query_eid_reachable::container& cl_message::
    query_eid_reachable () const
    {
      return this->_xsd_query_eid_reachable_;
    }

    cl_message::query_eid_reachable::container& cl_message::
    query_eid_reachable ()
    {
      return this->_xsd_query_eid_reachable_;
    }

    void cl_message::
    query_eid_reachable (const query_eid_reachable::type& query_eid_reachable)
    {
      this->_xsd_query_eid_reachable_.set (query_eid_reachable);
    }

    void cl_message::
    query_eid_reachable (const query_eid_reachable::container& query_eid_reachable)
    {
      this->_xsd_query_eid_reachable_ = query_eid_reachable;
    }

    void cl_message::
    query_eid_reachable (::std::auto_ptr< query_eid_reachable::type > query_eid_reachable)
    {
      this->_xsd_query_eid_reachable_.set (query_eid_reachable);
    }

    const cl_message::report_eid_reachable::container& cl_message::
    report_eid_reachable () const
    {
      return this->_xsd_report_eid_reachable_;
    }

    cl_message::report_eid_reachable::container& cl_message::
    report_eid_reachable ()
    {
      return this->_xsd_report_eid_reachable_;
    }

    void cl_message::
    report_eid_reachable (const report_eid_reachable::type& report_eid_reachable)
    {
      this->_xsd_report_eid_reachable_.set (report_eid_reachable);
    }

    void cl_message::
    report_eid_reachable (const report_eid_reachable::container& report_eid_reachable)
    {
      this->_xsd_report_eid_reachable_ = report_eid_reachable;
    }

    void cl_message::
    report_eid_reachable (::std::auto_ptr< report_eid_reachable::type > report_eid_reachable)
    {
      this->_xsd_report_eid_reachable_.set (report_eid_reachable);
    }

    const cl_message::query_link_attributes::container& cl_message::
    query_link_attributes () const
    {
      return this->_xsd_query_link_attributes_;
    }

    cl_message::query_link_attributes::container& cl_message::
    query_link_attributes ()
    {
      return this->_xsd_query_link_attributes_;
    }

    void cl_message::
    query_link_attributes (const query_link_attributes::type& query_link_attributes)
    {
      this->_xsd_query_link_attributes_.set (query_link_attributes);
    }

    void cl_message::
    query_link_attributes (const query_link_attributes::container& query_link_attributes)
    {
      this->_xsd_query_link_attributes_ = query_link_attributes;
    }

    void cl_message::
    query_link_attributes (::std::auto_ptr< query_link_attributes::type > query_link_attributes)
    {
      this->_xsd_query_link_attributes_.set (query_link_attributes);
    }

    const cl_message::report_link_attributes::container& cl_message::
    report_link_attributes () const
    {
      return this->_xsd_report_link_attributes_;
    }

    cl_message::report_link_attributes::container& cl_message::
    report_link_attributes ()
    {
      return this->_xsd_report_link_attributes_;
    }

    void cl_message::
    report_link_attributes (const report_link_attributes::type& report_link_attributes)
    {
      this->_xsd_report_link_attributes_.set (report_link_attributes);
    }

    void cl_message::
    report_link_attributes (const report_link_attributes::container& report_link_attributes)
    {
      this->_xsd_report_link_attributes_ = report_link_attributes;
    }

    void cl_message::
    report_link_attributes (::std::auto_ptr< report_link_attributes::type > report_link_attributes)
    {
      this->_xsd_report_link_attributes_.set (report_link_attributes);
    }

    const cl_message::query_interface_attributes::container& cl_message::
    query_interface_attributes () const
    {
      return this->_xsd_query_interface_attributes_;
    }

    cl_message::query_interface_attributes::container& cl_message::
    query_interface_attributes ()
    {
      return this->_xsd_query_interface_attributes_;
    }

    void cl_message::
    query_interface_attributes (const query_interface_attributes::type& query_interface_attributes)
    {
      this->_xsd_query_interface_attributes_.set (query_interface_attributes);
    }

    void cl_message::
    query_interface_attributes (const query_interface_attributes::container& query_interface_attributes)
    {
      this->_xsd_query_interface_attributes_ = query_interface_attributes;
    }

    void cl_message::
    query_interface_attributes (::std::auto_ptr< query_interface_attributes::type > query_interface_attributes)
    {
      this->_xsd_query_interface_attributes_.set (query_interface_attributes);
    }

    const cl_message::report_interface_attributes::container& cl_message::
    report_interface_attributes () const
    {
      return this->_xsd_report_interface_attributes_;
    }

    cl_message::report_interface_attributes::container& cl_message::
    report_interface_attributes ()
    {
      return this->_xsd_report_interface_attributes_;
    }

    void cl_message::
    report_interface_attributes (const report_interface_attributes::type& report_interface_attributes)
    {
      this->_xsd_report_interface_attributes_.set (report_interface_attributes);
    }

    void cl_message::
    report_interface_attributes (const report_interface_attributes::container& report_interface_attributes)
    {
      this->_xsd_report_interface_attributes_ = report_interface_attributes;
    }

    void cl_message::
    report_interface_attributes (::std::auto_ptr< report_interface_attributes::type > report_interface_attributes)
    {
      this->_xsd_report_interface_attributes_.set (report_interface_attributes);
    }

    const cl_message::query_cla_parameters::container& cl_message::
    query_cla_parameters () const
    {
      return this->_xsd_query_cla_parameters_;
    }

    cl_message::query_cla_parameters::container& cl_message::
    query_cla_parameters ()
    {
      return this->_xsd_query_cla_parameters_;
    }

    void cl_message::
    query_cla_parameters (const query_cla_parameters::type& query_cla_parameters)
    {
      this->_xsd_query_cla_parameters_.set (query_cla_parameters);
    }

    void cl_message::
    query_cla_parameters (const query_cla_parameters::container& query_cla_parameters)
    {
      this->_xsd_query_cla_parameters_ = query_cla_parameters;
    }

    void cl_message::
    query_cla_parameters (::std::auto_ptr< query_cla_parameters::type > query_cla_parameters)
    {
      this->_xsd_query_cla_parameters_.set (query_cla_parameters);
    }

    const cl_message::report_cla_parameters::container& cl_message::
    report_cla_parameters () const
    {
      return this->_xsd_report_cla_parameters_;
    }

    cl_message::report_cla_parameters::container& cl_message::
    report_cla_parameters ()
    {
      return this->_xsd_report_cla_parameters_;
    }

    void cl_message::
    report_cla_parameters (const report_cla_parameters::type& report_cla_parameters)
    {
      this->_xsd_report_cla_parameters_.set (report_cla_parameters);
    }

    void cl_message::
    report_cla_parameters (const report_cla_parameters::container& report_cla_parameters)
    {
      this->_xsd_report_cla_parameters_ = report_cla_parameters;
    }

    void cl_message::
    report_cla_parameters (::std::auto_ptr< report_cla_parameters::type > report_cla_parameters)
    {
      this->_xsd_report_cla_parameters_.set (report_cla_parameters);
    }
  }
}

#include <xsd/cxx/xml/dom/elements.hxx>
#include <xsd/cxx/xml/dom/parser.hxx>

namespace dtn
{
  namespace clmessage
  {
    // linkTypeType
    //

    linkTypeType::
    linkTypeType (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f,
                  ::xml_schema::type* c)
    : ::xml_schema::string (e, f, c)
    {
      _xsd_linkTypeType_convert ();
    }

    linkTypeType::
    linkTypeType (const ::xercesc::DOMAttr& a,
                  ::xml_schema::flags f,
                  ::xml_schema::type* c)
    : ::xml_schema::string (a, f, c)
    {
      _xsd_linkTypeType_convert ();
    }

    linkTypeType::
    linkTypeType (const ::std::basic_string< char >& s,
                  const ::xercesc::DOMElement* e,
                  ::xml_schema::flags f,
                  ::xml_schema::type* c)
    : ::xml_schema::string (s, e, f, c)
    {
      _xsd_linkTypeType_convert ();
    }

    linkTypeType* linkTypeType::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new linkTypeType (*this, f, c);
    }

    linkTypeType::_xsd_linkTypeType linkTypeType::
    _xsd_linkTypeType_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkTypeType_literals_);
      const _xsd_linkTypeType* i (::std::lower_bound (
                                    _xsd_linkTypeType_indexes_,
                                    _xsd_linkTypeType_indexes_ + 5,
                                    *this,
                                    c));

      if (i == _xsd_linkTypeType_indexes_ + 5 || _xsd_linkTypeType_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const linkTypeType::
    _xsd_linkTypeType_literals_[5] =
    {
      "alwayson",
      "ondemand",
      "scheduled",
      "predicted",
      "opportunistic"
    };

    const linkTypeType::_xsd_linkTypeType linkTypeType::
    _xsd_linkTypeType_indexes_[5] =
    {
      ::dtn::clmessage::linkTypeType::alwayson,
      ::dtn::clmessage::linkTypeType::ondemand,
      ::dtn::clmessage::linkTypeType::opportunistic,
      ::dtn::clmessage::linkTypeType::predicted,
      ::dtn::clmessage::linkTypeType::scheduled
    };

    // linkStateType
    //

    linkStateType::
    linkStateType (const ::xercesc::DOMElement& e,
                   ::xml_schema::flags f,
                   ::xml_schema::type* c)
    : ::xml_schema::string (e, f, c)
    {
      _xsd_linkStateType_convert ();
    }

    linkStateType::
    linkStateType (const ::xercesc::DOMAttr& a,
                   ::xml_schema::flags f,
                   ::xml_schema::type* c)
    : ::xml_schema::string (a, f, c)
    {
      _xsd_linkStateType_convert ();
    }

    linkStateType::
    linkStateType (const ::std::basic_string< char >& s,
                   const ::xercesc::DOMElement* e,
                   ::xml_schema::flags f,
                   ::xml_schema::type* c)
    : ::xml_schema::string (s, e, f, c)
    {
      _xsd_linkStateType_convert ();
    }

    linkStateType* linkStateType::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new linkStateType (*this, f, c);
    }

    linkStateType::_xsd_linkStateType linkStateType::
    _xsd_linkStateType_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkStateType_literals_);
      const _xsd_linkStateType* i (::std::lower_bound (
                                     _xsd_linkStateType_indexes_,
                                     _xsd_linkStateType_indexes_ + 6,
                                     *this,
                                     c));

      if (i == _xsd_linkStateType_indexes_ + 6 || _xsd_linkStateType_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const linkStateType::
    _xsd_linkStateType_literals_[6] =
    {
      "unavailable",
      "available",
      "opening",
      "open",
      "busy",
      "closed"
    };

    const linkStateType::_xsd_linkStateType linkStateType::
    _xsd_linkStateType_indexes_[6] =
    {
      ::dtn::clmessage::linkStateType::available,
      ::dtn::clmessage::linkStateType::busy,
      ::dtn::clmessage::linkStateType::closed,
      ::dtn::clmessage::linkStateType::open,
      ::dtn::clmessage::linkStateType::opening,
      ::dtn::clmessage::linkStateType::unavailable
    };

    // linkReasonType
    //

    linkReasonType::
    linkReasonType (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::string (e, f, c)
    {
      _xsd_linkReasonType_convert ();
    }

    linkReasonType::
    linkReasonType (const ::xercesc::DOMAttr& a,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::string (a, f, c)
    {
      _xsd_linkReasonType_convert ();
    }

    linkReasonType::
    linkReasonType (const ::std::basic_string< char >& s,
                    const ::xercesc::DOMElement* e,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::string (s, e, f, c)
    {
      _xsd_linkReasonType_convert ();
    }

    linkReasonType* linkReasonType::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new linkReasonType (*this, f, c);
    }

    linkReasonType::_xsd_linkReasonType linkReasonType::
    _xsd_linkReasonType_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkReasonType_literals_);
      const _xsd_linkReasonType* i (::std::lower_bound (
                                      _xsd_linkReasonType_indexes_,
                                      _xsd_linkReasonType_indexes_ + 8,
                                      *this,
                                      c));

      if (i == _xsd_linkReasonType_indexes_ + 8 || _xsd_linkReasonType_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const linkReasonType::
    _xsd_linkReasonType_literals_[8] =
    {
      "no_info",
      "user",
      "broken",
      "shutdown",
      "reconnect",
      "idle",
      "timeout",
      "unblocked"
    };

    const linkReasonType::_xsd_linkReasonType linkReasonType::
    _xsd_linkReasonType_indexes_[8] =
    {
      ::dtn::clmessage::linkReasonType::broken,
      ::dtn::clmessage::linkReasonType::idle,
      ::dtn::clmessage::linkReasonType::no_info,
      ::dtn::clmessage::linkReasonType::reconnect,
      ::dtn::clmessage::linkReasonType::shutdown,
      ::dtn::clmessage::linkReasonType::timeout,
      ::dtn::clmessage::linkReasonType::unblocked,
      ::dtn::clmessage::linkReasonType::user
    };

    // bundlePassMethodType
    //

    bundlePassMethodType::
    bundlePassMethodType (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::string (e, f, c)
    {
      _xsd_bundlePassMethodType_convert ();
    }

    bundlePassMethodType::
    bundlePassMethodType (const ::xercesc::DOMAttr& a,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::string (a, f, c)
    {
      _xsd_bundlePassMethodType_convert ();
    }

    bundlePassMethodType::
    bundlePassMethodType (const ::std::basic_string< char >& s,
                          const ::xercesc::DOMElement* e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::string (s, e, f, c)
    {
      _xsd_bundlePassMethodType_convert ();
    }

    bundlePassMethodType* bundlePassMethodType::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundlePassMethodType (*this, f, c);
    }

    bundlePassMethodType::_xsd_bundlePassMethodType bundlePassMethodType::
    _xsd_bundlePassMethodType_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundlePassMethodType_literals_);
      const _xsd_bundlePassMethodType* i (::std::lower_bound (
                                            _xsd_bundlePassMethodType_indexes_,
                                            _xsd_bundlePassMethodType_indexes_ + 2,
                                            *this,
                                            c));

      if (i == _xsd_bundlePassMethodType_indexes_ + 2 || _xsd_bundlePassMethodType_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const bundlePassMethodType::
    _xsd_bundlePassMethodType_literals_[2] =
    {
      "unknown",
      "filesystem"
    };

    const bundlePassMethodType::_xsd_bundlePassMethodType bundlePassMethodType::
    _xsd_bundlePassMethodType_indexes_[2] =
    {
      ::dtn::clmessage::bundlePassMethodType::filesystem,
      ::dtn::clmessage::bundlePassMethodType::unknown
    };

    // percentType
    //

    percentType::
    percentType ()
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > ()
    {
    }

    percentType::
    percentType (const _xsd_percentType::base_& _xsd_percentType)
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (_xsd_percentType)
    {
    }

    percentType::
    percentType (const percentType& _xsd_percentType,
                 ::xml_schema::flags f,
                 ::xml_schema::type* c)
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (_xsd_percentType, f, c)
    {
    }

    percentType::
    percentType (const ::xercesc::DOMElement& e,
                 ::xml_schema::flags f,
                 ::xml_schema::type* c)
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (e, f, c)
    {
    }

    percentType::
    percentType (const ::xercesc::DOMAttr& a,
                 ::xml_schema::flags f,
                 ::xml_schema::type* c)
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (a, f, c)
    {
    }

    percentType::
    percentType (const ::std::basic_string< char >& s,
                 const ::xercesc::DOMElement* e,
                 ::xml_schema::flags f,
                 ::xml_schema::type* c)
    : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (s, e, f, c)
    {
    }

    percentType* percentType::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new percentType (*this, f, c);
    }

    // attribute_name
    //

    attribute_name::
    attribute_name ()
    : ::xml_schema::type (),
    _xsd_value_ (::xml_schema::flags (), this)
    {
    }

    attribute_name::
    attribute_name (const value::type& _xsd_value)
    : ::xml_schema::type (),
    _xsd_value_ (_xsd_value,
                 ::xml_schema::flags (),
                 this)
    {
    }

    attribute_name::
    attribute_name (const attribute_name& _xsd_attribute_name,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_attribute_name, f, c),
    _xsd_value_ (_xsd_attribute_name._xsd_value_,
                 f | ::xml_schema::flags::not_root,
                 this)
    {
    }

    attribute_name::
    attribute_name (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_value_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void attribute_name::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "value" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< value::type > r (
            value::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->value (r);
          continue;
        }
      }

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

    attribute_name* attribute_name::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new attribute_name (*this, f, c);
    }

    // key_value_pair
    //

    key_value_pair::
    key_value_pair ()
    : ::xml_schema::type (),
    _xsd_name_ (::xml_schema::flags (), this),
    _xsd_value_ (::xml_schema::flags (), this)
    {
    }

    key_value_pair::
    key_value_pair (const name::type& _xsd_name,
                    const value::type& _xsd_value)
    : ::xml_schema::type (),
    _xsd_name_ (_xsd_name,
                ::xml_schema::flags (),
                this),
    _xsd_value_ (_xsd_value,
                 ::xml_schema::flags (),
                 this)
    {
    }

    key_value_pair::
    key_value_pair (const key_value_pair& _xsd_key_value_pair,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_key_value_pair, f, c),
    _xsd_name_ (_xsd_key_value_pair._xsd_name_,
                f | ::xml_schema::flags::not_root,
                this),
    _xsd_value_ (_xsd_key_value_pair._xsd_value_,
                 f | ::xml_schema::flags::not_root,
                 this)
    {
    }

    key_value_pair::
    key_value_pair (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_value_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void key_value_pair::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< name::type > r (
            name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->name (r);
          continue;
        }

        if (a.name () == "value" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< value::type > r (
            value::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->value (r);
          continue;
        }
      }

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

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

    key_value_pair* key_value_pair::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new key_value_pair (*this, f, c);
    }

    // bundle_attributes
    //

    bundle_attributes::
    bundle_attributes ()
    : ::xml_schema::type (),
    _xsd_source_eid_ (::xml_schema::flags (), this),
    _xsd_timestamp_seconds_ (::xml_schema::flags (), this),
    _xsd_timestamp_sequence_ (::xml_schema::flags (), this),
    _xsd_is_fragment_ (::xml_schema::flags (), this),
    _xsd_fragment_length_ (::xml_schema::flags (), this),
    _xsd_fragment_offset_ (::xml_schema::flags (), this)
    {
    }

    bundle_attributes::
    bundle_attributes (const source_eid::type& _xsd_source_eid,
                       const timestamp_seconds::type& _xsd_timestamp_seconds,
                       const timestamp_sequence::type& _xsd_timestamp_sequence,
                       const is_fragment::type& _xsd_is_fragment)
    : ::xml_schema::type (),
    _xsd_source_eid_ (_xsd_source_eid,
                      ::xml_schema::flags (),
                      this),
    _xsd_timestamp_seconds_ (_xsd_timestamp_seconds,
                             ::xml_schema::flags (),
                             this),
    _xsd_timestamp_sequence_ (_xsd_timestamp_sequence,
                              ::xml_schema::flags (),
                              this),
    _xsd_is_fragment_ (_xsd_is_fragment,
                       ::xml_schema::flags (),
                       this),
    _xsd_fragment_length_ (::xml_schema::flags (), this),
    _xsd_fragment_offset_ (::xml_schema::flags (), this)
    {
    }

    bundle_attributes::
    bundle_attributes (const bundle_attributes& _xsd_bundle_attributes,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_attributes, f, c),
    _xsd_source_eid_ (_xsd_bundle_attributes._xsd_source_eid_,
                      f | ::xml_schema::flags::not_root,
                      this),
    _xsd_timestamp_seconds_ (_xsd_bundle_attributes._xsd_timestamp_seconds_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_timestamp_sequence_ (_xsd_bundle_attributes._xsd_timestamp_sequence_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_is_fragment_ (_xsd_bundle_attributes._xsd_is_fragment_,
                       f | ::xml_schema::flags::not_root,
                       this),
    _xsd_fragment_length_ (_xsd_bundle_attributes._xsd_fragment_length_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_fragment_offset_ (_xsd_bundle_attributes._xsd_fragment_offset_,
                           f | ::xml_schema::flags::not_root,
                           this)
    {
    }

    bundle_attributes::
    bundle_attributes (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_source_eid_ (f | ::xml_schema::flags::not_root, this),
    _xsd_timestamp_seconds_ (f | ::xml_schema::flags::not_root, this),
    _xsd_timestamp_sequence_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_fragment_ (f | ::xml_schema::flags::not_root, this),
    _xsd_fragment_length_ (f | ::xml_schema::flags::not_root, this),
    _xsd_fragment_offset_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "source_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< source_eid::type > r (
            source_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->source_eid (r);
          continue;
        }

        if (a.name () == "timestamp_seconds" && a.namespace_ ().empty ())
        {
          this->timestamp_seconds (
            timestamp_seconds::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "timestamp_sequence" && a.namespace_ ().empty ())
        {
          this->timestamp_sequence (
            timestamp_sequence::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "is_fragment" && a.namespace_ ().empty ())
        {
          this->is_fragment (
            is_fragment::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "fragment_length" && a.namespace_ ().empty ())
        {
          this->fragment_length (
            fragment_length::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "fragment_offset" && a.namespace_ ().empty ())
        {
          this->fragment_offset (
            fragment_offset::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }

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

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

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

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

    bundle_attributes* bundle_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_attributes (*this, f, c);
    }

    // link_attributes
    //

    link_attributes::
    link_attributes ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_type_ (::xml_schema::flags (), this),
    _xsd_state_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this),
    _xsd_is_reachable_ (::xml_schema::flags (), this),
    _xsd_is_usable_ (::xml_schema::flags (), this),
    _xsd_how_reliable_ (::xml_schema::flags (), this),
    _xsd_how_available_ (::xml_schema::flags (), this),
    _xsd_reactive_fragment_ (::xml_schema::flags (), this),
    _xsd_nexthop_ (::xml_schema::flags (), this),
    _xsd_cla_name_ (::xml_schema::flags (), this),
    _xsd_high_water_mark_ (::xml_schema::flags (), this),
    _xsd_low_water_mark_ (::xml_schema::flags (), this)
    {
    }

    link_attributes::
    link_attributes (const link_attributes& _xsd_link_attributes,
                     ::xml_schema::flags f,
                     ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_attributes, f, c),
    _xsd_key_value_pair_ (_xsd_link_attributes._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_type_ (_xsd_link_attributes._xsd_type_,
                f | ::xml_schema::flags::not_root,
                this),
    _xsd_state_ (_xsd_link_attributes._xsd_state_,
                 f | ::xml_schema::flags::not_root,
                 this),
    _xsd_peer_eid_ (_xsd_link_attributes._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_is_reachable_ (_xsd_link_attributes._xsd_is_reachable_,
                        f | ::xml_schema::flags::not_root,
                        this),
    _xsd_is_usable_ (_xsd_link_attributes._xsd_is_usable_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_how_reliable_ (_xsd_link_attributes._xsd_how_reliable_,
                        f | ::xml_schema::flags::not_root,
                        this),
    _xsd_how_available_ (_xsd_link_attributes._xsd_how_available_,
                         f | ::xml_schema::flags::not_root,
                         this),
    _xsd_reactive_fragment_ (_xsd_link_attributes._xsd_reactive_fragment_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_nexthop_ (_xsd_link_attributes._xsd_nexthop_,
                   f | ::xml_schema::flags::not_root,
                   this),
    _xsd_cla_name_ (_xsd_link_attributes._xsd_cla_name_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_high_water_mark_ (_xsd_link_attributes._xsd_high_water_mark_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_low_water_mark_ (_xsd_link_attributes._xsd_low_water_mark_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    link_attributes::
    link_attributes (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f,
                     ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_type_ (f | ::xml_schema::flags::not_root, this),
    _xsd_state_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_reachable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_usable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_how_reliable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_how_available_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reactive_fragment_ (f | ::xml_schema::flags::not_root, this),
    _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this),
    _xsd_cla_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_high_water_mark_ (f | ::xml_schema::flags::not_root, this),
    _xsd_low_water_mark_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "type" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< type::type_ > r (
            type::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->type (r);
          continue;
        }

        if (a.name () == "state" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< state::type > r (
            state::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->state (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }

        if (a.name () == "is_reachable" && a.namespace_ ().empty ())
        {
          this->is_reachable (
            is_reachable::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "is_usable" && a.namespace_ ().empty ())
        {
          this->is_usable (
            is_usable::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "how_reliable" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< how_reliable::type > r (
            how_reliable::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->how_reliable (r);
          continue;
        }

        if (a.name () == "how_available" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< how_available::type > r (
            how_available::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->how_available (r);
          continue;
        }

        if (a.name () == "reactive_fragment" && a.namespace_ ().empty ())
        {
          this->reactive_fragment (
            reactive_fragment::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "nexthop" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< nexthop::type > r (
            nexthop::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->nexthop (r);
          continue;
        }

        if (a.name () == "cla_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< cla_name::type > r (
            cla_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->cla_name (r);
          continue;
        }

        if (a.name () == "high_water_mark" && a.namespace_ ().empty ())
        {
          this->high_water_mark (
            high_water_mark::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "low_water_mark" && a.namespace_ ().empty ())
        {
          this->low_water_mark (
            low_water_mark::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }
    }

    link_attributes* link_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_attributes (*this, f, c);
    }

    // link_config_parameters
    //

    link_config_parameters::
    link_config_parameters ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_is_usable_ (::xml_schema::flags (), this),
    _xsd_reactive_fragment_ (::xml_schema::flags (), this),
    _xsd_nexthop_ (::xml_schema::flags (), this)
    {
    }

    link_config_parameters::
    link_config_parameters (const link_config_parameters& _xsd_link_config_parameters,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_config_parameters, f, c),
    _xsd_key_value_pair_ (_xsd_link_config_parameters._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_is_usable_ (_xsd_link_config_parameters._xsd_is_usable_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reactive_fragment_ (_xsd_link_config_parameters._xsd_reactive_fragment_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_nexthop_ (_xsd_link_config_parameters._xsd_nexthop_,
                   f | ::xml_schema::flags::not_root,
                   this)
    {
    }

    link_config_parameters::
    link_config_parameters (const ::xercesc::DOMElement& e,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_usable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reactive_fragment_ (f | ::xml_schema::flags::not_root, this),
    _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_config_parameters::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "is_usable" && a.namespace_ ().empty ())
        {
          this->is_usable (
            is_usable::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "reactive_fragment" && a.namespace_ ().empty ())
        {
          this->reactive_fragment (
            reactive_fragment::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "nexthop" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< nexthop::type > r (
            nexthop::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->nexthop (r);
          continue;
        }
      }
    }

    link_config_parameters* link_config_parameters::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_config_parameters (*this, f, c);
    }

    // contact_attributes
    //

    contact_attributes::
    contact_attributes ()
    : ::xml_schema::type (),
    _xsd_start_time_ (::xml_schema::flags (), this),
    _xsd_duration_ (::xml_schema::flags (), this),
    _xsd_bps_ (::xml_schema::flags (), this),
    _xsd_latency_ (::xml_schema::flags (), this),
    _xsd_packet_loss_prob_ (::xml_schema::flags (), this)
    {
    }

    contact_attributes::
    contact_attributes (const start_time::type& _xsd_start_time,
                        const duration::type& _xsd_duration,
                        const bps::type& _xsd_bps,
                        const latency::type& _xsd_latency,
                        const packet_loss_prob::type& _xsd_packet_loss_prob)
    : ::xml_schema::type (),
    _xsd_start_time_ (_xsd_start_time,
                      ::xml_schema::flags (),
                      this),
    _xsd_duration_ (_xsd_duration,
                    ::xml_schema::flags (),
                    this),
    _xsd_bps_ (_xsd_bps,
               ::xml_schema::flags (),
               this),
    _xsd_latency_ (_xsd_latency,
                   ::xml_schema::flags (),
                   this),
    _xsd_packet_loss_prob_ (_xsd_packet_loss_prob,
                            ::xml_schema::flags (),
                            this)
    {
    }

    contact_attributes::
    contact_attributes (const contact_attributes& _xsd_contact_attributes,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_contact_attributes, f, c),
    _xsd_start_time_ (_xsd_contact_attributes._xsd_start_time_,
                      f | ::xml_schema::flags::not_root,
                      this),
    _xsd_duration_ (_xsd_contact_attributes._xsd_duration_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_bps_ (_xsd_contact_attributes._xsd_bps_,
               f | ::xml_schema::flags::not_root,
               this),
    _xsd_latency_ (_xsd_contact_attributes._xsd_latency_,
                   f | ::xml_schema::flags::not_root,
                   this),
    _xsd_packet_loss_prob_ (_xsd_contact_attributes._xsd_packet_loss_prob_,
                            f | ::xml_schema::flags::not_root,
                            this)
    {
    }

    contact_attributes::
    contact_attributes (const ::xercesc::DOMElement& e,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_start_time_ (f | ::xml_schema::flags::not_root, this),
    _xsd_duration_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bps_ (f | ::xml_schema::flags::not_root, this),
    _xsd_latency_ (f | ::xml_schema::flags::not_root, this),
    _xsd_packet_loss_prob_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void contact_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "start_time" && a.namespace_ ().empty ())
        {
          this->start_time (
            start_time::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "duration" && a.namespace_ ().empty ())
        {
          this->duration (
            duration::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "bps" && a.namespace_ ().empty ())
        {
          this->bps (
            bps::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "latency" && a.namespace_ ().empty ())
        {
          this->latency (
            latency::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "packet_loss_prob" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< packet_loss_prob::type > r (
            packet_loss_prob::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->packet_loss_prob (r);
          continue;
        }
      }

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

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

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

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

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

    contact_attributes* contact_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new contact_attributes (*this, f, c);
    }

    // cla_add_request
    //

    cla_add_request::
    cla_add_request ()
    : ::xml_schema::type (),
    _xsd_name_ (::xml_schema::flags (), this)
    {
    }

    cla_add_request::
    cla_add_request (const name::type& _xsd_name)
    : ::xml_schema::type (),
    _xsd_name_ (_xsd_name,
                ::xml_schema::flags (),
                this)
    {
    }

    cla_add_request::
    cla_add_request (const cla_add_request& _xsd_cla_add_request,
                     ::xml_schema::flags f,
                     ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_cla_add_request, f, c),
    _xsd_name_ (_xsd_cla_add_request._xsd_name_,
                f | ::xml_schema::flags::not_root,
                this)
    {
    }

    cla_add_request::
    cla_add_request (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f,
                     ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void cla_add_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< name::type > r (
            name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->name (r);
          continue;
        }
      }

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

    cla_add_request* cla_add_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new cla_add_request (*this, f, c);
    }

    // cla_delete_request
    //

    cla_delete_request::
    cla_delete_request ()
    : ::xml_schema::type (),
    _xsd_name_ (::xml_schema::flags (), this)
    {
    }

    cla_delete_request::
    cla_delete_request (const name::type& _xsd_name)
    : ::xml_schema::type (),
    _xsd_name_ (_xsd_name,
                ::xml_schema::flags (),
                this)
    {
    }

    cla_delete_request::
    cla_delete_request (const cla_delete_request& _xsd_cla_delete_request,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_cla_delete_request, f, c),
    _xsd_name_ (_xsd_cla_delete_request._xsd_name_,
                f | ::xml_schema::flags::not_root,
                this)
    {
    }

    cla_delete_request::
    cla_delete_request (const ::xercesc::DOMElement& e,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void cla_delete_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< name::type > r (
            name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->name (r);
          continue;
        }
      }

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

    cla_delete_request* cla_delete_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new cla_delete_request (*this, f, c);
    }

    // cla_set_params_request
    //

    cla_set_params_request::
    cla_set_params_request ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_local_eid_ (::xml_schema::flags (), this),
    _xsd_create_discovered_links_ (::xml_schema::flags (), this),
    _xsd_bundle_pass_method_ (::xml_schema::flags (), this),
    _xsd_reactive_fragment_enabled_ (::xml_schema::flags (), this)
    {
    }

    cla_set_params_request::
    cla_set_params_request (const cla_set_params_request& _xsd_cla_set_params_request,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_cla_set_params_request, f, c),
    _xsd_key_value_pair_ (_xsd_cla_set_params_request._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_local_eid_ (_xsd_cla_set_params_request._xsd_local_eid_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_create_discovered_links_ (_xsd_cla_set_params_request._xsd_create_discovered_links_,
                                   f | ::xml_schema::flags::not_root,
                                   this),
    _xsd_bundle_pass_method_ (_xsd_cla_set_params_request._xsd_bundle_pass_method_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_reactive_fragment_enabled_ (_xsd_cla_set_params_request._xsd_reactive_fragment_enabled_,
                                     f | ::xml_schema::flags::not_root,
                                     this)
    {
    }

    cla_set_params_request::
    cla_set_params_request (const ::xercesc::DOMElement& e,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_local_eid_ (f | ::xml_schema::flags::not_root, this),
    _xsd_create_discovered_links_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_pass_method_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reactive_fragment_enabled_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void cla_set_params_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "local_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< local_eid::type > r (
            local_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->local_eid (r);
          continue;
        }

        if (a.name () == "create_discovered_links" && a.namespace_ ().empty ())
        {
          this->create_discovered_links (
            create_discovered_links::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "bundle_pass_method" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< bundle_pass_method::type > r (
            bundle_pass_method::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->bundle_pass_method (r);
          continue;
        }

        if (a.name () == "reactive_fragment_enabled" && a.namespace_ ().empty ())
        {
          this->reactive_fragment_enabled (
            reactive_fragment_enabled::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }
    }

    cla_set_params_request* cla_set_params_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new cla_set_params_request (*this, f, c);
    }

    // cla_params_set_event
    //

    cla_params_set_event::
    cla_params_set_event ()
    : ::xml_schema::type ()
    {
    }

    cla_params_set_event::
    cla_params_set_event (const cla_params_set_event& _xsd_cla_params_set_event,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_cla_params_set_event, f, c)
    {
    }

    cla_params_set_event::
    cla_params_set_event (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c)
    {
    }

    cla_params_set_event::
    cla_params_set_event (const ::xercesc::DOMAttr& a,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (a, f, c)
    {
    }

    cla_params_set_event::
    cla_params_set_event (const ::std::basic_string< char >& s,
                          const ::xercesc::DOMElement* e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (s, e, f, c)
    {
    }

    cla_params_set_event* cla_params_set_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new cla_params_set_event (*this, f, c);
    }

    // interface_set_defaults_request
    //

    interface_set_defaults_request::
    interface_set_defaults_request ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this)
    {
    }

    interface_set_defaults_request::
    interface_set_defaults_request (const interface_set_defaults_request& _xsd_interface_set_defaults_request,
                                    ::xml_schema::flags f,
                                    ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_set_defaults_request, f, c),
    _xsd_key_value_pair_ (_xsd_interface_set_defaults_request._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    interface_set_defaults_request::
    interface_set_defaults_request (const ::xercesc::DOMElement& e,
                                    ::xml_schema::flags f,
                                    ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_set_defaults_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

    interface_set_defaults_request* interface_set_defaults_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_set_defaults_request (*this, f, c);
    }

    // interface_create_request
    //

    interface_create_request::
    interface_create_request ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (::xml_schema::flags (), this)
    {
    }

    interface_create_request::
    interface_create_request (const interface_name::type& _xsd_interface_name)
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this)
    {
    }

    interface_create_request::
    interface_create_request (const interface_create_request& _xsd_interface_create_request,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_create_request, f, c),
    _xsd_key_value_pair_ (_xsd_interface_create_request._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_interface_name_ (_xsd_interface_create_request._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    interface_create_request::
    interface_create_request (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_create_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }
      }

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

    interface_create_request* interface_create_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_create_request (*this, f, c);
    }

    // interface_created_event
    //

    interface_created_event::
    interface_created_event ()
    : ::xml_schema::type (),
    _xsd_interface_name_ (::xml_schema::flags (), this)
    {
    }

    interface_created_event::
    interface_created_event (const interface_name::type& _xsd_interface_name)
    : ::xml_schema::type (),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this)
    {
    }

    interface_created_event::
    interface_created_event (const interface_created_event& _xsd_interface_created_event,
                             ::xml_schema::flags f,
                             ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_created_event, f, c),
    _xsd_interface_name_ (_xsd_interface_created_event._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    interface_created_event::
    interface_created_event (const ::xercesc::DOMElement& e,
                             ::xml_schema::flags f,
                             ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_created_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }
      }

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

    interface_created_event* interface_created_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_created_event (*this, f, c);
    }

    // interface_reconfigure_request
    //

    interface_reconfigure_request::
    interface_reconfigure_request ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (::xml_schema::flags (), this),
    _xsd_up_ (::xml_schema::flags (), this),
    _xsd_discovery_ (::xml_schema::flags (), this)
    {
    }

    interface_reconfigure_request::
    interface_reconfigure_request (const interface_name::type& _xsd_interface_name)
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this),
    _xsd_up_ (::xml_schema::flags (), this),
    _xsd_discovery_ (::xml_schema::flags (), this)
    {
    }

    interface_reconfigure_request::
    interface_reconfigure_request (const interface_reconfigure_request& _xsd_interface_reconfigure_request,
                                   ::xml_schema::flags f,
                                   ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_reconfigure_request, f, c),
    _xsd_key_value_pair_ (_xsd_interface_reconfigure_request._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_interface_name_ (_xsd_interface_reconfigure_request._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_up_ (_xsd_interface_reconfigure_request._xsd_up_,
              f | ::xml_schema::flags::not_root,
              this),
    _xsd_discovery_ (_xsd_interface_reconfigure_request._xsd_discovery_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    interface_reconfigure_request::
    interface_reconfigure_request (const ::xercesc::DOMElement& e,
                                   ::xml_schema::flags f,
                                   ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_up_ (f | ::xml_schema::flags::not_root, this),
    _xsd_discovery_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_reconfigure_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }

        if (a.name () == "up" && a.namespace_ ().empty ())
        {
          this->up (
            up::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "discovery" && a.namespace_ ().empty ())
        {
          this->discovery (
            discovery::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }

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

    interface_reconfigure_request* interface_reconfigure_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_reconfigure_request (*this, f, c);
    }

    // interface_reconfigured_event
    //

    interface_reconfigured_event::
    interface_reconfigured_event ()
    : ::xml_schema::type (),
    _xsd_interface_name_ (::xml_schema::flags (), this)
    {
    }

    interface_reconfigured_event::
    interface_reconfigured_event (const interface_name::type& _xsd_interface_name)
    : ::xml_schema::type (),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this)
    {
    }

    interface_reconfigured_event::
    interface_reconfigured_event (const interface_reconfigured_event& _xsd_interface_reconfigured_event,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_reconfigured_event, f, c),
    _xsd_interface_name_ (_xsd_interface_reconfigured_event._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    interface_reconfigured_event::
    interface_reconfigured_event (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_reconfigured_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }
      }

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

    interface_reconfigured_event* interface_reconfigured_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_reconfigured_event (*this, f, c);
    }

    // interface_destroy_request
    //

    interface_destroy_request::
    interface_destroy_request ()
    : ::xml_schema::type (),
    _xsd_interface_name_ (::xml_schema::flags (), this)
    {
    }

    interface_destroy_request::
    interface_destroy_request (const interface_name::type& _xsd_interface_name)
    : ::xml_schema::type (),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this)
    {
    }

    interface_destroy_request::
    interface_destroy_request (const interface_destroy_request& _xsd_interface_destroy_request,
                               ::xml_schema::flags f,
                               ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_interface_destroy_request, f, c),
    _xsd_interface_name_ (_xsd_interface_destroy_request._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this)
    {
    }

    interface_destroy_request::
    interface_destroy_request (const ::xercesc::DOMElement& e,
                               ::xml_schema::flags f,
                               ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void interface_destroy_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }
      }

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

    interface_destroy_request* interface_destroy_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new interface_destroy_request (*this, f, c);
    }

    // eid_reachable_event
    //

    eid_reachable_event::
    eid_reachable_event ()
    : ::xml_schema::type (),
    _xsd_interface_name_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    eid_reachable_event::
    eid_reachable_event (const interface_name::type& _xsd_interface_name,
                         const peer_eid::type& _xsd_peer_eid)
    : ::xml_schema::type (),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this),
    _xsd_peer_eid_ (_xsd_peer_eid,
                    ::xml_schema::flags (),
                    this)
    {
    }

    eid_reachable_event::
    eid_reachable_event (const eid_reachable_event& _xsd_eid_reachable_event,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_eid_reachable_event, f, c),
    _xsd_interface_name_ (_xsd_eid_reachable_event._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_peer_eid_ (_xsd_eid_reachable_event._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    eid_reachable_event::
    eid_reachable_event (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void eid_reachable_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

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

    eid_reachable_event* eid_reachable_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new eid_reachable_event (*this, f, c);
    }

    // link_set_defaults_request
    //

    link_set_defaults_request::
    link_set_defaults_request ()
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (::xml_schema::flags (), this)
    {
    }

    link_set_defaults_request::
    link_set_defaults_request (const link_config_parameters::type& _xsd_link_config_parameters)
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (_xsd_link_config_parameters,
                                  ::xml_schema::flags (),
                                  this)
    {
    }

    link_set_defaults_request::
    link_set_defaults_request (const link_set_defaults_request& _xsd_link_set_defaults_request,
                               ::xml_schema::flags f,
                               ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_set_defaults_request, f, c),
    _xsd_link_config_parameters_ (_xsd_link_set_defaults_request._xsd_link_config_parameters_,
                                  f | ::xml_schema::flags::not_root,
                                  this)
    {
    }

    link_set_defaults_request::
    link_set_defaults_request (const ::xercesc::DOMElement& e,
                               ::xml_schema::flags f,
                               ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_set_defaults_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_config_parameters
        //
        {
          if (e.name () == "link_config_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_config_parameters::type > r (
              link_config_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_config_parameters_.present ())
              continue;
            this->link_config_parameters (r);
            continue;
          }
        }
      }

      if (!_xsd_link_config_parameters_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_config_parameters",
          "");
      }
    }

    link_set_defaults_request* link_set_defaults_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_set_defaults_request (*this, f, c);
    }

    // link_create_request
    //

    link_create_request::
    link_create_request ()
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_type_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    link_create_request::
    link_create_request (const link_config_parameters::type& _xsd_link_config_parameters,
                         const link_name::type& _xsd_link_name,
                         const type::type_& _xsd_type)
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (_xsd_link_config_parameters,
                                  ::xml_schema::flags (),
                                  this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_type_ (_xsd_type,
                ::xml_schema::flags (),
                this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    link_create_request::
    link_create_request (const link_create_request& _xsd_link_create_request,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_create_request, f, c),
    _xsd_link_config_parameters_ (_xsd_link_create_request._xsd_link_config_parameters_,
                                  f | ::xml_schema::flags::not_root,
                                  this),
    _xsd_link_name_ (_xsd_link_create_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_type_ (_xsd_link_create_request._xsd_type_,
                f | ::xml_schema::flags::not_root,
                this),
    _xsd_peer_eid_ (_xsd_link_create_request._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    link_create_request::
    link_create_request (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_type_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_create_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_config_parameters
        //
        {
          if (e.name () == "link_config_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_config_parameters::type > r (
              link_config_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_config_parameters_.present ())
              continue;
            this->link_config_parameters (r);
            continue;
          }
        }
      }

      if (!_xsd_link_config_parameters_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_config_parameters",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "type" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< type::type_ > r (
            type::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->type (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

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

    link_create_request* link_create_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_create_request (*this, f, c);
    }

    // link_created_event
    //

    link_created_event::
    link_created_event ()
    : ::xml_schema::type (),
    _xsd_link_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_created_event::
    link_created_event (const link_attributes::type& _xsd_link_attributes,
                        const link_name::type& _xsd_link_name,
                        const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_link_attributes_ (_xsd_link_attributes,
                           ::xml_schema::flags (),
                           this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_reason_ (_xsd_reason,
                  ::xml_schema::flags (),
                  this)
    {
    }

    link_created_event::
    link_created_event (const link_created_event& _xsd_link_created_event,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_created_event, f, c),
    _xsd_link_attributes_ (_xsd_link_created_event._xsd_link_attributes_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_link_name_ (_xsd_link_created_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reason_ (_xsd_link_created_event._xsd_reason_,
                  f | ::xml_schema::flags::not_root,
                  this)
    {
    }

    link_created_event::
    link_created_event (const ::xercesc::DOMElement& e,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reason_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_created_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_attributes
        //
        {
          if (e.name () == "link_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_attributes::type > r (
              link_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_attributes_.present ())
              continue;
            this->link_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_link_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "reason" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< reason::type > r (
            reason::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->reason (r);
          continue;
        }
      }

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

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

    link_created_event* link_created_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_created_event (*this, f, c);
    }

    // link_open_request
    //

    link_open_request::
    link_open_request ()
    : ::xml_schema::type (),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_open_request::
    link_open_request (const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_open_request::
    link_open_request (const link_open_request& _xsd_link_open_request,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_open_request, f, c),
    _xsd_link_name_ (_xsd_link_open_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_open_request::
    link_open_request (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_open_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_open_request* link_open_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_open_request (*this, f, c);
    }

    // link_opened_event
    //

    link_opened_event::
    link_opened_event ()
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_opened_event::
    link_opened_event (const contact_attributes::type& _xsd_contact_attributes,
                       const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (_xsd_contact_attributes,
                              ::xml_schema::flags (),
                              this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_opened_event::
    link_opened_event (const link_opened_event& _xsd_link_opened_event,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_opened_event, f, c),
    _xsd_contact_attributes_ (_xsd_link_opened_event._xsd_contact_attributes_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_name_ (_xsd_link_opened_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_opened_event::
    link_opened_event (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_opened_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // contact_attributes
        //
        {
          if (e.name () == "contact_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< contact_attributes::type > r (
              contact_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_contact_attributes_.present ())
              continue;
            this->contact_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contact_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contact_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_opened_event* link_opened_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_opened_event (*this, f, c);
    }

    // link_close_request
    //

    link_close_request::
    link_close_request ()
    : ::xml_schema::type (),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_close_request::
    link_close_request (const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_close_request::
    link_close_request (const link_close_request& _xsd_link_close_request,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_close_request, f, c),
    _xsd_link_name_ (_xsd_link_close_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_close_request::
    link_close_request (const ::xercesc::DOMElement& e,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_close_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_close_request* link_close_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_close_request (*this, f, c);
    }

    // link_closed_event
    //

    link_closed_event::
    link_closed_event ()
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_closed_event::
    link_closed_event (const contact_attributes::type& _xsd_contact_attributes,
                       const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (_xsd_contact_attributes,
                              ::xml_schema::flags (),
                              this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_closed_event::
    link_closed_event (const link_closed_event& _xsd_link_closed_event,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_closed_event, f, c),
    _xsd_contact_attributes_ (_xsd_link_closed_event._xsd_contact_attributes_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_name_ (_xsd_link_closed_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_closed_event::
    link_closed_event (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_closed_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // contact_attributes
        //
        {
          if (e.name () == "contact_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< contact_attributes::type > r (
              contact_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_contact_attributes_.present ())
              continue;
            this->contact_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contact_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contact_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_closed_event* link_closed_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_closed_event (*this, f, c);
    }

    // link_state_changed_event
    //

    link_state_changed_event::
    link_state_changed_event ()
    : ::xml_schema::type (),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_new_state_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_state_changed_event::
    link_state_changed_event (const link_name::type& _xsd_link_name,
                              const new_state::type& _xsd_new_state,
                              const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_new_state_ (_xsd_new_state,
                     ::xml_schema::flags (),
                     this),
    _xsd_reason_ (_xsd_reason,
                  ::xml_schema::flags (),
                  this)
    {
    }

    link_state_changed_event::
    link_state_changed_event (const link_state_changed_event& _xsd_link_state_changed_event,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_state_changed_event, f, c),
    _xsd_link_name_ (_xsd_link_state_changed_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_new_state_ (_xsd_link_state_changed_event._xsd_new_state_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reason_ (_xsd_link_state_changed_event._xsd_reason_,
                  f | ::xml_schema::flags::not_root,
                  this)
    {
    }

    link_state_changed_event::
    link_state_changed_event (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_new_state_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reason_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_state_changed_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "new_state" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< new_state::type > r (
            new_state::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->new_state (r);
          continue;
        }

        if (a.name () == "reason" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< reason::type > r (
            reason::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->reason (r);
          continue;
        }
      }

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

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

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

    link_state_changed_event* link_state_changed_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_state_changed_event (*this, f, c);
    }

    // link_reconfigure_request
    //

    link_reconfigure_request::
    link_reconfigure_request ()
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_reconfigure_request::
    link_reconfigure_request (const link_config_parameters::type& _xsd_link_config_parameters,
                              const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (_xsd_link_config_parameters,
                                  ::xml_schema::flags (),
                                  this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_reconfigure_request::
    link_reconfigure_request (const link_reconfigure_request& _xsd_link_reconfigure_request,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_reconfigure_request, f, c),
    _xsd_link_config_parameters_ (_xsd_link_reconfigure_request._xsd_link_config_parameters_,
                                  f | ::xml_schema::flags::not_root,
                                  this),
    _xsd_link_name_ (_xsd_link_reconfigure_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_reconfigure_request::
    link_reconfigure_request (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_reconfigure_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_config_parameters
        //
        {
          if (e.name () == "link_config_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_config_parameters::type > r (
              link_config_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_config_parameters_.present ())
              continue;
            this->link_config_parameters (r);
            continue;
          }
        }
      }

      if (!_xsd_link_config_parameters_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_config_parameters",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_reconfigure_request* link_reconfigure_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_reconfigure_request (*this, f, c);
    }

    // link_delete_request
    //

    link_delete_request::
    link_delete_request ()
    : ::xml_schema::type (),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_delete_request::
    link_delete_request (const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    link_delete_request::
    link_delete_request (const link_delete_request& _xsd_link_delete_request,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_delete_request, f, c),
    _xsd_link_name_ (_xsd_link_delete_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    link_delete_request::
    link_delete_request (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_delete_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    link_delete_request* link_delete_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_delete_request (*this, f, c);
    }

    // link_deleted_event
    //

    link_deleted_event::
    link_deleted_event ()
    : ::xml_schema::type (),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_deleted_event::
    link_deleted_event (const link_name::type& _xsd_link_name,
                        const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_reason_ (_xsd_reason,
                  ::xml_schema::flags (),
                  this)
    {
    }

    link_deleted_event::
    link_deleted_event (const link_deleted_event& _xsd_link_deleted_event,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_deleted_event, f, c),
    _xsd_link_name_ (_xsd_link_deleted_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reason_ (_xsd_link_deleted_event._xsd_reason_,
                  f | ::xml_schema::flags::not_root,
                  this)
    {
    }

    link_deleted_event::
    link_deleted_event (const ::xercesc::DOMElement& e,
                        ::xml_schema::flags f,
                        ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reason_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_deleted_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "reason" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< reason::type > r (
            reason::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->reason (r);
          continue;
        }
      }

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

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

    link_deleted_event* link_deleted_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_deleted_event (*this, f, c);
    }

    // link_attribute_changed_event
    //

    link_attribute_changed_event::
    link_attribute_changed_event ()
    : ::xml_schema::type (),
    _xsd_link_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_attribute_changed_event::
    link_attribute_changed_event (const link_attributes::type& _xsd_link_attributes,
                                  const link_name::type& _xsd_link_name,
                                  const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_link_attributes_ (_xsd_link_attributes,
                           ::xml_schema::flags (),
                           this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_reason_ (_xsd_reason,
                  ::xml_schema::flags (),
                  this)
    {
    }

    link_attribute_changed_event::
    link_attribute_changed_event (const link_attribute_changed_event& _xsd_link_attribute_changed_event,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_attribute_changed_event, f, c),
    _xsd_link_attributes_ (_xsd_link_attribute_changed_event._xsd_link_attributes_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_link_name_ (_xsd_link_attribute_changed_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reason_ (_xsd_link_attribute_changed_event._xsd_reason_,
                  f | ::xml_schema::flags::not_root,
                  this)
    {
    }

    link_attribute_changed_event::
    link_attribute_changed_event (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reason_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_attribute_changed_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_attributes
        //
        {
          if (e.name () == "link_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_attributes::type > r (
              link_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_attributes_.present ())
              continue;
            this->link_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_link_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "reason" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< reason::type > r (
            reason::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->reason (r);
          continue;
        }
      }

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

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

    link_attribute_changed_event* link_attribute_changed_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_attribute_changed_event (*this, f, c);
    }

    // contact_attribute_changed_event
    //

    contact_attribute_changed_event::
    contact_attribute_changed_event ()
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    contact_attribute_changed_event::
    contact_attribute_changed_event (const contact_attributes::type& _xsd_contact_attributes,
                                     const link_name::type& _xsd_link_name,
                                     const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_contact_attributes_ (_xsd_contact_attributes,
                              ::xml_schema::flags (),
                              this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_reason_ (_xsd_reason,
                  ::xml_schema::flags (),
                  this)
    {
    }

    contact_attribute_changed_event::
    contact_attribute_changed_event (const contact_attribute_changed_event& _xsd_contact_attribute_changed_event,
                                     ::xml_schema::flags f,
                                     ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_contact_attribute_changed_event, f, c),
    _xsd_contact_attributes_ (_xsd_contact_attribute_changed_event._xsd_contact_attributes_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_name_ (_xsd_contact_attribute_changed_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_reason_ (_xsd_contact_attribute_changed_event._xsd_reason_,
                  f | ::xml_schema::flags::not_root,
                  this)
    {
    }

    contact_attribute_changed_event::
    contact_attribute_changed_event (const ::xercesc::DOMElement& e,
                                     ::xml_schema::flags f,
                                     ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reason_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void contact_attribute_changed_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // contact_attributes
        //
        {
          if (e.name () == "contact_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< contact_attributes::type > r (
              contact_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_contact_attributes_.present ())
              continue;
            this->contact_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contact_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contact_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "reason" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< reason::type > r (
            reason::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->reason (r);
          continue;
        }
      }

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

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

    contact_attribute_changed_event* contact_attribute_changed_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new contact_attribute_changed_event (*this, f, c);
    }

    // link_add_reachable_event
    //

    link_add_reachable_event::
    link_add_reachable_event ()
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    link_add_reachable_event::
    link_add_reachable_event (const link_config_parameters::type& _xsd_link_config_parameters,
                              const link_name::type& _xsd_link_name,
                              const peer_eid::type& _xsd_peer_eid)
    : ::xml_schema::type (),
    _xsd_link_config_parameters_ (_xsd_link_config_parameters,
                                  ::xml_schema::flags (),
                                  this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_peer_eid_ (_xsd_peer_eid,
                    ::xml_schema::flags (),
                    this)
    {
    }

    link_add_reachable_event::
    link_add_reachable_event (const link_add_reachable_event& _xsd_link_add_reachable_event,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_add_reachable_event, f, c),
    _xsd_link_config_parameters_ (_xsd_link_add_reachable_event._xsd_link_config_parameters_,
                                  f | ::xml_schema::flags::not_root,
                                  this),
    _xsd_link_name_ (_xsd_link_add_reachable_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_peer_eid_ (_xsd_link_add_reachable_event._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    link_add_reachable_event::
    link_add_reachable_event (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void link_add_reachable_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // link_config_parameters
        //
        {
          if (e.name () == "link_config_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_config_parameters::type > r (
              link_config_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_link_config_parameters_.present ())
              continue;
            this->link_config_parameters (r);
            continue;
          }
        }
      }

      if (!_xsd_link_config_parameters_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "link_config_parameters",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

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

    link_add_reachable_event* link_add_reachable_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_add_reachable_event (*this, f, c);
    }

    // bundle_send_request
    //

    bundle_send_request::
    bundle_send_request ()
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_location_ (::xml_schema::flags (), this)
    {
    }

    bundle_send_request::
    bundle_send_request (const bundle_attributes::type& _xsd_bundle_attributes,
                         const link_name::type& _xsd_link_name,
                         const location::type& _xsd_location)
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (_xsd_bundle_attributes,
                             ::xml_schema::flags (),
                             this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_location_ (_xsd_location,
                    ::xml_schema::flags (),
                    this)
    {
    }

    bundle_send_request::
    bundle_send_request (const bundle_send_request& _xsd_bundle_send_request,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_send_request, f, c),
    _xsd_bundle_attributes_ (_xsd_bundle_send_request._xsd_bundle_attributes_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_name_ (_xsd_bundle_send_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_location_ (_xsd_bundle_send_request._xsd_location_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    bundle_send_request::
    bundle_send_request (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_location_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_send_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // bundle_attributes
        //
        {
          if (e.name () == "bundle_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_attributes::type > r (
              bundle_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_bundle_attributes_.present ())
              continue;
            this->bundle_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundle_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundle_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "location" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< location::type > r (
            location::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->location (r);
          continue;
        }
      }

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

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

    bundle_send_request* bundle_send_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_send_request (*this, f, c);
    }

    // bundle_receive_started_event
    //

    bundle_receive_started_event::
    bundle_receive_started_event ()
    : ::xml_schema::type (),
    _xsd_location_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    bundle_receive_started_event::
    bundle_receive_started_event (const location::type& _xsd_location)
    : ::xml_schema::type (),
    _xsd_location_ (_xsd_location,
                    ::xml_schema::flags (),
                    this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    bundle_receive_started_event::
    bundle_receive_started_event (const bundle_receive_started_event& _xsd_bundle_receive_started_event,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_receive_started_event, f, c),
    _xsd_location_ (_xsd_bundle_receive_started_event._xsd_location_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_peer_eid_ (_xsd_bundle_receive_started_event._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    bundle_receive_started_event::
    bundle_receive_started_event (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f,
                                  ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_location_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_receive_started_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "location" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< location::type > r (
            location::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->location (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

    bundle_receive_started_event* bundle_receive_started_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_receive_started_event (*this, f, c);
    }

    // bundle_received_event
    //

    bundle_received_event::
    bundle_received_event ()
    : ::xml_schema::type (),
    _xsd_location_ (::xml_schema::flags (), this),
    _xsd_bytes_received_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    bundle_received_event::
    bundle_received_event (const location::type& _xsd_location,
                           const bytes_received::type& _xsd_bytes_received)
    : ::xml_schema::type (),
    _xsd_location_ (_xsd_location,
                    ::xml_schema::flags (),
                    this),
    _xsd_bytes_received_ (_xsd_bytes_received,
                          ::xml_schema::flags (),
                          this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    bundle_received_event::
    bundle_received_event (const bundle_received_event& _xsd_bundle_received_event,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_received_event, f, c),
    _xsd_location_ (_xsd_bundle_received_event._xsd_location_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_bytes_received_ (_xsd_bundle_received_event._xsd_bytes_received_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_peer_eid_ (_xsd_bundle_received_event._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    bundle_received_event::
    bundle_received_event (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_location_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bytes_received_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_received_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "location" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< location::type > r (
            location::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->location (r);
          continue;
        }

        if (a.name () == "bytes_received" && a.namespace_ ().empty ())
        {
          this->bytes_received (
            bytes_received::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

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

    bundle_received_event* bundle_received_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_received_event (*this, f, c);
    }

    // bundle_transmitted_event
    //

    bundle_transmitted_event::
    bundle_transmitted_event ()
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_bytes_sent_ (::xml_schema::flags (), this),
    _xsd_reliably_sent_ (::xml_schema::flags (), this)
    {
    }

    bundle_transmitted_event::
    bundle_transmitted_event (const bundle_attributes::type& _xsd_bundle_attributes,
                              const link_name::type& _xsd_link_name,
                              const bytes_sent::type& _xsd_bytes_sent,
                              const reliably_sent::type& _xsd_reliably_sent)
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (_xsd_bundle_attributes,
                             ::xml_schema::flags (),
                             this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_bytes_sent_ (_xsd_bytes_sent,
                      ::xml_schema::flags (),
                      this),
    _xsd_reliably_sent_ (_xsd_reliably_sent,
                         ::xml_schema::flags (),
                         this)
    {
    }

    bundle_transmitted_event::
    bundle_transmitted_event (const bundle_transmitted_event& _xsd_bundle_transmitted_event,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_transmitted_event, f, c),
    _xsd_bundle_attributes_ (_xsd_bundle_transmitted_event._xsd_bundle_attributes_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_name_ (_xsd_bundle_transmitted_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_bytes_sent_ (_xsd_bundle_transmitted_event._xsd_bytes_sent_,
                      f | ::xml_schema::flags::not_root,
                      this),
    _xsd_reliably_sent_ (_xsd_bundle_transmitted_event._xsd_reliably_sent_,
                         f | ::xml_schema::flags::not_root,
                         this)
    {
    }

    bundle_transmitted_event::
    bundle_transmitted_event (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bytes_sent_ (f | ::xml_schema::flags::not_root, this),
    _xsd_reliably_sent_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_transmitted_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // bundle_attributes
        //
        {
          if (e.name () == "bundle_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_attributes::type > r (
              bundle_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_bundle_attributes_.present ())
              continue;
            this->bundle_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundle_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundle_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "bytes_sent" && a.namespace_ ().empty ())
        {
          this->bytes_sent (
            bytes_sent::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }

        if (a.name () == "reliably_sent" && a.namespace_ ().empty ())
        {
          this->reliably_sent (
            reliably_sent::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }

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

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

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

    bundle_transmitted_event* bundle_transmitted_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_transmitted_event (*this, f, c);
    }

    // bundle_cancel_request
    //

    bundle_cancel_request::
    bundle_cancel_request ()
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    bundle_cancel_request::
    bundle_cancel_request (const bundle_attributes::type& _xsd_bundle_attributes,
                           const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (_xsd_bundle_attributes,
                             ::xml_schema::flags (),
                             this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    bundle_cancel_request::
    bundle_cancel_request (const bundle_cancel_request& _xsd_bundle_cancel_request,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_cancel_request, f, c),
    _xsd_bundle_attributes_ (_xsd_bundle_cancel_request._xsd_bundle_attributes_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_name_ (_xsd_bundle_cancel_request._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    bundle_cancel_request::
    bundle_cancel_request (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_cancel_request::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // bundle_attributes
        //
        {
          if (e.name () == "bundle_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_attributes::type > r (
              bundle_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_bundle_attributes_.present ())
              continue;
            this->bundle_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundle_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundle_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    bundle_cancel_request* bundle_cancel_request::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_cancel_request (*this, f, c);
    }

    // bundle_canceled_event
    //

    bundle_canceled_event::
    bundle_canceled_event ()
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    bundle_canceled_event::
    bundle_canceled_event (const bundle_attributes::type& _xsd_bundle_attributes,
                           const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (_xsd_bundle_attributes,
                             ::xml_schema::flags (),
                             this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    bundle_canceled_event::
    bundle_canceled_event (const bundle_canceled_event& _xsd_bundle_canceled_event,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_canceled_event, f, c),
    _xsd_bundle_attributes_ (_xsd_bundle_canceled_event._xsd_bundle_attributes_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_name_ (_xsd_bundle_canceled_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    bundle_canceled_event::
    bundle_canceled_event (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void bundle_canceled_event::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // bundle_attributes
        //
        {
          if (e.name () == "bundle_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_attributes::type > r (
              bundle_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_bundle_attributes_.present ())
              continue;
            this->bundle_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundle_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundle_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

    bundle_canceled_event* bundle_canceled_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_canceled_event (*this, f, c);
    }

    // query_bundle_queued
    //

    query_bundle_queued::
    query_bundle_queued ()
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    query_bundle_queued::
    query_bundle_queued (const bundle_attributes::type& _xsd_bundle_attributes,
                         const query_id::type& _xsd_query_id,
                         const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_bundle_attributes_ (_xsd_bundle_attributes,
                             ::xml_schema::flags (),
                             this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    query_bundle_queued::
    query_bundle_queued (const query_bundle_queued& _xsd_query_bundle_queued,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_query_bundle_queued, f, c),
    _xsd_bundle_attributes_ (_xsd_query_bundle_queued._xsd_bundle_attributes_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_query_id_ (_xsd_query_bundle_queued._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_link_name_ (_xsd_query_bundle_queued._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    query_bundle_queued::
    query_bundle_queued (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void query_bundle_queued::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // bundle_attributes
        //
        {
          if (e.name () == "bundle_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_attributes::type > r (
              bundle_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (_xsd_bundle_attributes_.present ())
              continue;
            this->bundle_attributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundle_attributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundle_attributes",
          "");
      }

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }
      }

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

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

    query_bundle_queued* query_bundle_queued::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new query_bundle_queued (*this, f, c);
    }

    // report_bundle_queued
    //

    report_bundle_queued::
    report_bundle_queued ()
    : ::xml_schema::type (),
    _xsd_query_id_ (::xml_schema::flags (), this),
    _xsd_is_queued_ (::xml_schema::flags (), this)
    {
    }

    report_bundle_queued::
    report_bundle_queued (const query_id::type& _xsd_query_id,
                          const is_queued::type& _xsd_is_queued)
    : ::xml_schema::type (),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this),
    _xsd_is_queued_ (_xsd_is_queued,
                     ::xml_schema::flags (),
                     this)
    {
    }

    report_bundle_queued::
    report_bundle_queued (const report_bundle_queued& _xsd_report_bundle_queued,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_report_bundle_queued, f, c),
    _xsd_query_id_ (_xsd_report_bundle_queued._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_is_queued_ (_xsd_report_bundle_queued._xsd_is_queued_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

    report_bundle_queued::
    report_bundle_queued (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_queued_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void report_bundle_queued::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }

        if (a.name () == "is_queued" && a.namespace_ ().empty ())
        {
          this->is_queued (
            is_queued::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }

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

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

    report_bundle_queued* report_bundle_queued::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new report_bundle_queued (*this, f, c);
    }

    // query_eid_reachable
    //

    query_eid_reachable::
    query_eid_reachable ()
    : ::xml_schema::type (),
    _xsd_query_id_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    query_eid_reachable::
    query_eid_reachable (const query_id::type& _xsd_query_id,
                         const interface_name::type& _xsd_interface_name,
                         const peer_eid::type& _xsd_peer_eid)
    : ::xml_schema::type (),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this),
    _xsd_peer_eid_ (_xsd_peer_eid,
                    ::xml_schema::flags (),
                    this)
    {
    }

    query_eid_reachable::
    query_eid_reachable (const query_eid_reachable& _xsd_query_eid_reachable,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_query_eid_reachable, f, c),
    _xsd_query_id_ (_xsd_query_eid_reachable._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_interface_name_ (_xsd_query_eid_reachable._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_peer_eid_ (_xsd_query_eid_reachable._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    query_eid_reachable::
    query_eid_reachable (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void query_eid_reachable::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }

        if (a.name () == "peer_eid" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< peer_eid::type > r (
            peer_eid::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->peer_eid (r);
          continue;
        }
      }

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

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

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

    query_eid_reachable* query_eid_reachable::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new query_eid_reachable (*this, f, c);
    }

    // report_eid_reachable
    //

    report_eid_reachable::
    report_eid_reachable ()
    : ::xml_schema::type (),
    _xsd_query_id_ (::xml_schema::flags (), this),
    _xsd_is_reachable_ (::xml_schema::flags (), this)
    {
    }

    report_eid_reachable::
    report_eid_reachable (const query_id::type& _xsd_query_id,
                          const is_reachable::type& _xsd_is_reachable)
    : ::xml_schema::type (),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this),
    _xsd_is_reachable_ (_xsd_is_reachable,
                        ::xml_schema::flags (),
                        this)
    {
    }

    report_eid_reachable::
    report_eid_reachable (const report_eid_reachable& _xsd_report_eid_reachable,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_report_eid_reachable, f, c),
    _xsd_query_id_ (_xsd_report_eid_reachable._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_is_reachable_ (_xsd_report_eid_reachable._xsd_is_reachable_,
                        f | ::xml_schema::flags::not_root,
                        this)
    {
    }

    report_eid_reachable::
    report_eid_reachable (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this),
    _xsd_is_reachable_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void report_eid_reachable::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }

        if (a.name () == "is_reachable" && a.namespace_ ().empty ())
        {
          this->is_reachable (
            is_reachable::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));
          continue;
        }
      }

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

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

    report_eid_reachable* report_eid_reachable::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new report_eid_reachable (*this, f, c);
    }

    // query_link_attributes
    //

    query_link_attributes::
    query_link_attributes ()
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    query_link_attributes::
    query_link_attributes (const link_name::type& _xsd_link_name,
                           const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    query_link_attributes::
    query_link_attributes (const query_link_attributes& _xsd_query_link_attributes,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_query_link_attributes, f, c),
    _xsd_attribute_name_ (_xsd_query_link_attributes._xsd_attribute_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_link_name_ (_xsd_query_link_attributes._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_query_id_ (_xsd_query_link_attributes._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    query_link_attributes::
    query_link_attributes (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void query_link_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // attribute_name
        //
        {
          if (e.name () == "attribute_name" && e.namespace_ () == "")
          {
            ::std::auto_ptr< attribute_name::type > r (
              attribute_name::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "link_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< link_name::type > r (
            link_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->link_name (r);
          continue;
        }

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

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

    query_link_attributes* query_link_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new query_link_attributes (*this, f, c);
    }

    // report_link_attributes
    //

    report_link_attributes::
    report_link_attributes ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    report_link_attributes::
    report_link_attributes (const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    report_link_attributes::
    report_link_attributes (const report_link_attributes& _xsd_report_link_attributes,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_report_link_attributes, f, c),
    _xsd_key_value_pair_ (_xsd_report_link_attributes._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_query_id_ (_xsd_report_link_attributes._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    report_link_attributes::
    report_link_attributes (const ::xercesc::DOMElement& e,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void report_link_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

    report_link_attributes* report_link_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new report_link_attributes (*this, f, c);
    }

    // query_interface_attributes
    //

    query_interface_attributes::
    query_interface_attributes ()
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    query_interface_attributes::
    query_interface_attributes (const interface_name::type& _xsd_interface_name,
                                const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_interface_name_ (_xsd_interface_name,
                          ::xml_schema::flags (),
                          this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    query_interface_attributes::
    query_interface_attributes (const query_interface_attributes& _xsd_query_interface_attributes,
                                ::xml_schema::flags f,
                                ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_query_interface_attributes, f, c),
    _xsd_attribute_name_ (_xsd_query_interface_attributes._xsd_attribute_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_interface_name_ (_xsd_query_interface_attributes._xsd_interface_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_query_id_ (_xsd_query_interface_attributes._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    query_interface_attributes::
    query_interface_attributes (const ::xercesc::DOMElement& e,
                                ::xml_schema::flags f,
                                ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void query_interface_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // attribute_name
        //
        {
          if (e.name () == "attribute_name" && e.namespace_ () == "")
          {
            ::std::auto_ptr< attribute_name::type > r (
              attribute_name::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "interface_name" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< interface_name::type > r (
            interface_name::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->interface_name (r);
          continue;
        }

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

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

    query_interface_attributes* query_interface_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new query_interface_attributes (*this, f, c);
    }

    // report_interface_attributes
    //

    report_interface_attributes::
    report_interface_attributes ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    report_interface_attributes::
    report_interface_attributes (const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    report_interface_attributes::
    report_interface_attributes (const report_interface_attributes& _xsd_report_interface_attributes,
                                 ::xml_schema::flags f,
                                 ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_report_interface_attributes, f, c),
    _xsd_key_value_pair_ (_xsd_report_interface_attributes._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_query_id_ (_xsd_report_interface_attributes._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    report_interface_attributes::
    report_interface_attributes (const ::xercesc::DOMElement& e,
                                 ::xml_schema::flags f,
                                 ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void report_interface_attributes::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

    report_interface_attributes* report_interface_attributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new report_interface_attributes (*this, f, c);
    }

    // query_cla_parameters
    //

    query_cla_parameters::
    query_cla_parameters ()
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    query_cla_parameters::
    query_cla_parameters (const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_attribute_name_ (::xml_schema::flags (), this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    query_cla_parameters::
    query_cla_parameters (const query_cla_parameters& _xsd_query_cla_parameters,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_query_cla_parameters, f, c),
    _xsd_attribute_name_ (_xsd_query_cla_parameters._xsd_attribute_name_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_query_id_ (_xsd_query_cla_parameters._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    query_cla_parameters::
    query_cla_parameters (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void query_cla_parameters::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // attribute_name
        //
        {
          if (e.name () == "attribute_name" && e.namespace_ () == "")
          {
            ::std::auto_ptr< attribute_name::type > r (
              attribute_name::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

    query_cla_parameters* query_cla_parameters::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new query_cla_parameters (*this, f, c);
    }

    // report_cla_parameters
    //

    report_cla_parameters::
    report_cla_parameters ()
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (::xml_schema::flags (), this)
    {
    }

    report_cla_parameters::
    report_cla_parameters (const query_id::type& _xsd_query_id)
    : ::xml_schema::type (),
    _xsd_key_value_pair_ (::xml_schema::flags (), this),
    _xsd_query_id_ (_xsd_query_id,
                    ::xml_schema::flags (),
                    this)
    {
    }

    report_cla_parameters::
    report_cla_parameters (const report_cla_parameters& _xsd_report_cla_parameters,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_report_cla_parameters, f, c),
    _xsd_key_value_pair_ (_xsd_report_cla_parameters._xsd_key_value_pair_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _xsd_query_id_ (_xsd_report_cla_parameters._xsd_query_id_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    report_cla_parameters::
    report_cla_parameters (const ::xercesc::DOMElement& e,
                           ::xml_schema::flags f,
                           ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_id_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void report_cla_parameters::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // key_value_pair
        //
        {
          if (e.name () == "key_value_pair" && e.namespace_ () == "")
          {
            ::std::auto_ptr< key_value_pair::type > r (
              key_value_pair::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

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

      while (p.more_attributes ())
      {
        const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ());

        if (a.name () == "query_id" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< query_id::type > r (
            query_id::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->query_id (r);
          continue;
        }
      }

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

    report_cla_parameters* report_cla_parameters::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new report_cla_parameters (*this, f, c);
    }

    // cl_message
    //

    cl_message::
    cl_message ()
    : ::xml_schema::type (),
    _xsd_cla_add_request_ (::xml_schema::flags (), this),
    _xsd_cla_delete_request_ (::xml_schema::flags (), this),
    _xsd_cla_set_params_request_ (::xml_schema::flags (), this),
    _xsd_cla_params_set_event_ (::xml_schema::flags (), this),
    _xsd_interface_set_defaults_request_ (::xml_schema::flags (), this),
    _xsd_interface_create_request_ (::xml_schema::flags (), this),
    _xsd_interface_created_event_ (::xml_schema::flags (), this),
    _xsd_interface_reconfigure_request_ (::xml_schema::flags (), this),
    _xsd_interface_reconfigured_event_ (::xml_schema::flags (), this),
    _xsd_interface_destroy_request_ (::xml_schema::flags (), this),
    _xsd_eid_reachable_event_ (::xml_schema::flags (), this),
    _xsd_link_set_defaults_request_ (::xml_schema::flags (), this),
    _xsd_link_create_request_ (::xml_schema::flags (), this),
    _xsd_link_created_event_ (::xml_schema::flags (), this),
    _xsd_link_open_request_ (::xml_schema::flags (), this),
    _xsd_link_opened_event_ (::xml_schema::flags (), this),
    _xsd_link_close_request_ (::xml_schema::flags (), this),
    _xsd_link_closed_event_ (::xml_schema::flags (), this),
    _xsd_link_state_changed_event_ (::xml_schema::flags (), this),
    _xsd_link_reconfigure_request_ (::xml_schema::flags (), this),
    _xsd_link_delete_request_ (::xml_schema::flags (), this),
    _xsd_link_deleted_event_ (::xml_schema::flags (), this),
    _xsd_link_attribute_changed_event_ (::xml_schema::flags (), this),
    _xsd_contact_attribute_changed_event_ (::xml_schema::flags (), this),
    _xsd_link_add_reachable_event_ (::xml_schema::flags (), this),
    _xsd_bundle_send_request_ (::xml_schema::flags (), this),
    _xsd_bundle_receive_started_event_ (::xml_schema::flags (), this),
    _xsd_bundle_received_event_ (::xml_schema::flags (), this),
    _xsd_bundle_transmitted_event_ (::xml_schema::flags (), this),
    _xsd_bundle_cancel_request_ (::xml_schema::flags (), this),
    _xsd_bundle_canceled_event_ (::xml_schema::flags (), this),
    _xsd_query_bundle_queued_ (::xml_schema::flags (), this),
    _xsd_report_bundle_queued_ (::xml_schema::flags (), this),
    _xsd_query_eid_reachable_ (::xml_schema::flags (), this),
    _xsd_report_eid_reachable_ (::xml_schema::flags (), this),
    _xsd_query_link_attributes_ (::xml_schema::flags (), this),
    _xsd_report_link_attributes_ (::xml_schema::flags (), this),
    _xsd_query_interface_attributes_ (::xml_schema::flags (), this),
    _xsd_report_interface_attributes_ (::xml_schema::flags (), this),
    _xsd_query_cla_parameters_ (::xml_schema::flags (), this),
    _xsd_report_cla_parameters_ (::xml_schema::flags (), this)
    {
    }

    cl_message::
    cl_message (const cl_message& _xsd_cl_message,
                ::xml_schema::flags f,
                ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_cl_message, f, c),
    _xsd_cla_add_request_ (_xsd_cl_message._xsd_cla_add_request_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_cla_delete_request_ (_xsd_cl_message._xsd_cla_delete_request_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_cla_set_params_request_ (_xsd_cl_message._xsd_cla_set_params_request_,
                                  f | ::xml_schema::flags::not_root,
                                  this),
    _xsd_cla_params_set_event_ (_xsd_cl_message._xsd_cla_params_set_event_,
                                f | ::xml_schema::flags::not_root,
                                this),
    _xsd_interface_set_defaults_request_ (_xsd_cl_message._xsd_interface_set_defaults_request_,
                                          f | ::xml_schema::flags::not_root,
                                          this),
    _xsd_interface_create_request_ (_xsd_cl_message._xsd_interface_create_request_,
                                    f | ::xml_schema::flags::not_root,
                                    this),
    _xsd_interface_created_event_ (_xsd_cl_message._xsd_interface_created_event_,
                                   f | ::xml_schema::flags::not_root,
                                   this),
    _xsd_interface_reconfigure_request_ (_xsd_cl_message._xsd_interface_reconfigure_request_,
                                         f | ::xml_schema::flags::not_root,
                                         this),
    _xsd_interface_reconfigured_event_ (_xsd_cl_message._xsd_interface_reconfigured_event_,
                                        f | ::xml_schema::flags::not_root,
                                        this),
    _xsd_interface_destroy_request_ (_xsd_cl_message._xsd_interface_destroy_request_,
                                     f | ::xml_schema::flags::not_root,
                                     this),
    _xsd_eid_reachable_event_ (_xsd_cl_message._xsd_eid_reachable_event_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_link_set_defaults_request_ (_xsd_cl_message._xsd_link_set_defaults_request_,
                                     f | ::xml_schema::flags::not_root,
                                     this),
    _xsd_link_create_request_ (_xsd_cl_message._xsd_link_create_request_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_link_created_event_ (_xsd_cl_message._xsd_link_created_event_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_open_request_ (_xsd_cl_message._xsd_link_open_request_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_opened_event_ (_xsd_cl_message._xsd_link_opened_event_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_close_request_ (_xsd_cl_message._xsd_link_close_request_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_closed_event_ (_xsd_cl_message._xsd_link_closed_event_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_link_state_changed_event_ (_xsd_cl_message._xsd_link_state_changed_event_,
                                    f | ::xml_schema::flags::not_root,
                                    this),
    _xsd_link_reconfigure_request_ (_xsd_cl_message._xsd_link_reconfigure_request_,
                                    f | ::xml_schema::flags::not_root,
                                    this),
    _xsd_link_delete_request_ (_xsd_cl_message._xsd_link_delete_request_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_link_deleted_event_ (_xsd_cl_message._xsd_link_deleted_event_,
                              f | ::xml_schema::flags::not_root,
                              this),
    _xsd_link_attribute_changed_event_ (_xsd_cl_message._xsd_link_attribute_changed_event_,
                                        f | ::xml_schema::flags::not_root,
                                        this),
    _xsd_contact_attribute_changed_event_ (_xsd_cl_message._xsd_contact_attribute_changed_event_,
                                           f | ::xml_schema::flags::not_root,
                                           this),
    _xsd_link_add_reachable_event_ (_xsd_cl_message._xsd_link_add_reachable_event_,
                                    f | ::xml_schema::flags::not_root,
                                    this),
    _xsd_bundle_send_request_ (_xsd_cl_message._xsd_bundle_send_request_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_bundle_receive_started_event_ (_xsd_cl_message._xsd_bundle_receive_started_event_,
                                        f | ::xml_schema::flags::not_root,
                                        this),
    _xsd_bundle_received_event_ (_xsd_cl_message._xsd_bundle_received_event_,
                                 f | ::xml_schema::flags::not_root,
                                 this),
    _xsd_bundle_transmitted_event_ (_xsd_cl_message._xsd_bundle_transmitted_event_,
                                    f | ::xml_schema::flags::not_root,
                                    this),
    _xsd_bundle_cancel_request_ (_xsd_cl_message._xsd_bundle_cancel_request_,
                                 f | ::xml_schema::flags::not_root,
                                 this),
    _xsd_bundle_canceled_event_ (_xsd_cl_message._xsd_bundle_canceled_event_,
                                 f | ::xml_schema::flags::not_root,
                                 this),
    _xsd_query_bundle_queued_ (_xsd_cl_message._xsd_query_bundle_queued_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_report_bundle_queued_ (_xsd_cl_message._xsd_report_bundle_queued_,
                                f | ::xml_schema::flags::not_root,
                                this),
    _xsd_query_eid_reachable_ (_xsd_cl_message._xsd_query_eid_reachable_,
                               f | ::xml_schema::flags::not_root,
                               this),
    _xsd_report_eid_reachable_ (_xsd_cl_message._xsd_report_eid_reachable_,
                                f | ::xml_schema::flags::not_root,
                                this),
    _xsd_query_link_attributes_ (_xsd_cl_message._xsd_query_link_attributes_,
                                 f | ::xml_schema::flags::not_root,
                                 this),
    _xsd_report_link_attributes_ (_xsd_cl_message._xsd_report_link_attributes_,
                                  f | ::xml_schema::flags::not_root,
                                  this),
    _xsd_query_interface_attributes_ (_xsd_cl_message._xsd_query_interface_attributes_,
                                      f | ::xml_schema::flags::not_root,
                                      this),
    _xsd_report_interface_attributes_ (_xsd_cl_message._xsd_report_interface_attributes_,
                                       f | ::xml_schema::flags::not_root,
                                       this),
    _xsd_query_cla_parameters_ (_xsd_cl_message._xsd_query_cla_parameters_,
                                f | ::xml_schema::flags::not_root,
                                this),
    _xsd_report_cla_parameters_ (_xsd_cl_message._xsd_report_cla_parameters_,
                                 f | ::xml_schema::flags::not_root,
                                 this)
    {
    }

    cl_message::
    cl_message (const ::xercesc::DOMElement& e,
                ::xml_schema::flags f,
                ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_cla_add_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_cla_delete_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_cla_set_params_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_cla_params_set_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_set_defaults_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_create_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_created_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_reconfigure_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_reconfigured_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_interface_destroy_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_eid_reachable_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_set_defaults_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_create_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_created_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_open_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_opened_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_close_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_closed_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_state_changed_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_reconfigure_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_delete_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_deleted_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_attribute_changed_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_contact_attribute_changed_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_link_add_reachable_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_send_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_receive_started_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_received_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_transmitted_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_cancel_request_ (f | ::xml_schema::flags::not_root, this),
    _xsd_bundle_canceled_event_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_bundle_queued_ (f | ::xml_schema::flags::not_root, this),
    _xsd_report_bundle_queued_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_eid_reachable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_report_eid_reachable_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_link_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_report_link_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_interface_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_report_interface_attributes_ (f | ::xml_schema::flags::not_root, this),
    _xsd_query_cla_parameters_ (f | ::xml_schema::flags::not_root, this),
    _xsd_report_cla_parameters_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void cl_message::
    parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e);

      while (p.more_elements ())
      {
        const ::xsd::cxx::xml::dom::element< char > e (p.next_element ());

        // cla_add_request
        //
        {
          if (e.name () == "cla_add_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< cla_add_request::type > r (
              cla_add_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->cla_add_request ())
              continue;
            this->cla_add_request (r);
            continue;
          }
        }

        // cla_delete_request
        //
        {
          if (e.name () == "cla_delete_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< cla_delete_request::type > r (
              cla_delete_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->cla_delete_request ())
              continue;
            this->cla_delete_request (r);
            continue;
          }
        }

        // cla_set_params_request
        //
        {
          if (e.name () == "cla_set_params_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< cla_set_params_request::type > r (
              cla_set_params_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->cla_set_params_request ())
              continue;
            this->cla_set_params_request (r);
            continue;
          }
        }

        // cla_params_set_event
        //
        {
          if (e.name () == "cla_params_set_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< cla_params_set_event::type > r (
              cla_params_set_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->cla_params_set_event ())
              continue;
            this->cla_params_set_event (r);
            continue;
          }
        }

        // interface_set_defaults_request
        //
        {
          if (e.name () == "interface_set_defaults_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_set_defaults_request::type > r (
              interface_set_defaults_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_set_defaults_request ())
              continue;
            this->interface_set_defaults_request (r);
            continue;
          }
        }

        // interface_create_request
        //
        {
          if (e.name () == "interface_create_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_create_request::type > r (
              interface_create_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_create_request ())
              continue;
            this->interface_create_request (r);
            continue;
          }
        }

        // interface_created_event
        //
        {
          if (e.name () == "interface_created_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_created_event::type > r (
              interface_created_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_created_event ())
              continue;
            this->interface_created_event (r);
            continue;
          }
        }

        // interface_reconfigure_request
        //
        {
          if (e.name () == "interface_reconfigure_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_reconfigure_request::type > r (
              interface_reconfigure_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_reconfigure_request ())
              continue;
            this->interface_reconfigure_request (r);
            continue;
          }
        }

        // interface_reconfigured_event
        //
        {
          if (e.name () == "interface_reconfigured_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_reconfigured_event::type > r (
              interface_reconfigured_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_reconfigured_event ())
              continue;
            this->interface_reconfigured_event (r);
            continue;
          }
        }

        // interface_destroy_request
        //
        {
          if (e.name () == "interface_destroy_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< interface_destroy_request::type > r (
              interface_destroy_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->interface_destroy_request ())
              continue;
            this->interface_destroy_request (r);
            continue;
          }
        }

        // eid_reachable_event
        //
        {
          if (e.name () == "eid_reachable_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< eid_reachable_event::type > r (
              eid_reachable_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->eid_reachable_event ())
              continue;
            this->eid_reachable_event (r);
            continue;
          }
        }

        // link_set_defaults_request
        //
        {
          if (e.name () == "link_set_defaults_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_set_defaults_request::type > r (
              link_set_defaults_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_set_defaults_request ())
              continue;
            this->link_set_defaults_request (r);
            continue;
          }
        }

        // link_create_request
        //
        {
          if (e.name () == "link_create_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_create_request::type > r (
              link_create_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_create_request ())
              continue;
            this->link_create_request (r);
            continue;
          }
        }

        // link_created_event
        //
        {
          if (e.name () == "link_created_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_created_event::type > r (
              link_created_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_created_event ())
              continue;
            this->link_created_event (r);
            continue;
          }
        }

        // link_open_request
        //
        {
          if (e.name () == "link_open_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_open_request::type > r (
              link_open_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_open_request ())
              continue;
            this->link_open_request (r);
            continue;
          }
        }

        // link_opened_event
        //
        {
          if (e.name () == "link_opened_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_opened_event::type > r (
              link_opened_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_opened_event ())
              continue;
            this->link_opened_event (r);
            continue;
          }
        }

        // link_close_request
        //
        {
          if (e.name () == "link_close_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_close_request::type > r (
              link_close_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_close_request ())
              continue;
            this->link_close_request (r);
            continue;
          }
        }

        // link_closed_event
        //
        {
          if (e.name () == "link_closed_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_closed_event::type > r (
              link_closed_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_closed_event ())
              continue;
            this->link_closed_event (r);
            continue;
          }
        }

        // link_state_changed_event
        //
        {
          if (e.name () == "link_state_changed_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_state_changed_event::type > r (
              link_state_changed_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_state_changed_event ())
              continue;
            this->link_state_changed_event (r);
            continue;
          }
        }

        // link_reconfigure_request
        //
        {
          if (e.name () == "link_reconfigure_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_reconfigure_request::type > r (
              link_reconfigure_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_reconfigure_request ())
              continue;
            this->link_reconfigure_request (r);
            continue;
          }
        }

        // link_delete_request
        //
        {
          if (e.name () == "link_delete_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_delete_request::type > r (
              link_delete_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_delete_request ())
              continue;
            this->link_delete_request (r);
            continue;
          }
        }

        // link_deleted_event
        //
        {
          if (e.name () == "link_deleted_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_deleted_event::type > r (
              link_deleted_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_deleted_event ())
              continue;
            this->link_deleted_event (r);
            continue;
          }
        }

        // link_attribute_changed_event
        //
        {
          if (e.name () == "link_attribute_changed_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_attribute_changed_event::type > r (
              link_attribute_changed_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_attribute_changed_event ())
              continue;
            this->link_attribute_changed_event (r);
            continue;
          }
        }

        // contact_attribute_changed_event
        //
        {
          if (e.name () == "contact_attribute_changed_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< contact_attribute_changed_event::type > r (
              contact_attribute_changed_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->contact_attribute_changed_event ())
              continue;
            this->contact_attribute_changed_event (r);
            continue;
          }
        }

        // link_add_reachable_event
        //
        {
          if (e.name () == "link_add_reachable_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_add_reachable_event::type > r (
              link_add_reachable_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_add_reachable_event ())
              continue;
            this->link_add_reachable_event (r);
            continue;
          }
        }

        // bundle_send_request
        //
        {
          if (e.name () == "bundle_send_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_send_request::type > r (
              bundle_send_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_send_request ())
              continue;
            this->bundle_send_request (r);
            continue;
          }
        }

        // bundle_receive_started_event
        //
        {
          if (e.name () == "bundle_receive_started_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_receive_started_event::type > r (
              bundle_receive_started_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_receive_started_event ())
              continue;
            this->bundle_receive_started_event (r);
            continue;
          }
        }

        // bundle_received_event
        //
        {
          if (e.name () == "bundle_received_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_received_event::type > r (
              bundle_received_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_received_event ())
              continue;
            this->bundle_received_event (r);
            continue;
          }
        }

        // bundle_transmitted_event
        //
        {
          if (e.name () == "bundle_transmitted_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_transmitted_event::type > r (
              bundle_transmitted_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_transmitted_event ())
              continue;
            this->bundle_transmitted_event (r);
            continue;
          }
        }

        // bundle_cancel_request
        //
        {
          if (e.name () == "bundle_cancel_request" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_cancel_request::type > r (
              bundle_cancel_request::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_cancel_request ())
              continue;
            this->bundle_cancel_request (r);
            continue;
          }
        }

        // bundle_canceled_event
        //
        {
          if (e.name () == "bundle_canceled_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_canceled_event::type > r (
              bundle_canceled_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_canceled_event ())
              continue;
            this->bundle_canceled_event (r);
            continue;
          }
        }

        // query_bundle_queued
        //
        {
          if (e.name () == "query_bundle_queued" && e.namespace_ () == "")
          {
            ::std::auto_ptr< query_bundle_queued::type > r (
              query_bundle_queued::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->query_bundle_queued ())
              continue;
            this->query_bundle_queued (r);
            continue;
          }
        }

        // report_bundle_queued
        //
        {
          if (e.name () == "report_bundle_queued" && e.namespace_ () == "")
          {
            ::std::auto_ptr< report_bundle_queued::type > r (
              report_bundle_queued::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->report_bundle_queued ())
              continue;
            this->report_bundle_queued (r);
            continue;
          }
        }

        // query_eid_reachable
        //
        {
          if (e.name () == "query_eid_reachable" && e.namespace_ () == "")
          {
            ::std::auto_ptr< query_eid_reachable::type > r (
              query_eid_reachable::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->query_eid_reachable ())
              continue;
            this->query_eid_reachable (r);
            continue;
          }
        }

        // report_eid_reachable
        //
        {
          if (e.name () == "report_eid_reachable" && e.namespace_ () == "")
          {
            ::std::auto_ptr< report_eid_reachable::type > r (
              report_eid_reachable::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->report_eid_reachable ())
              continue;
            this->report_eid_reachable (r);
            continue;
          }
        }

        // query_link_attributes
        //
        {
          if (e.name () == "query_link_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< query_link_attributes::type > r (
              query_link_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->query_link_attributes ())
              continue;
            this->query_link_attributes (r);
            continue;
          }
        }

        // report_link_attributes
        //
        {
          if (e.name () == "report_link_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< report_link_attributes::type > r (
              report_link_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->report_link_attributes ())
              continue;
            this->report_link_attributes (r);
            continue;
          }
        }

        // query_interface_attributes
        //
        {
          if (e.name () == "query_interface_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< query_interface_attributes::type > r (
              query_interface_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->query_interface_attributes ())
              continue;
            this->query_interface_attributes (r);
            continue;
          }
        }

        // report_interface_attributes
        //
        {
          if (e.name () == "report_interface_attributes" && e.namespace_ () == "")
          {
            ::std::auto_ptr< report_interface_attributes::type > r (
              report_interface_attributes::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->report_interface_attributes ())
              continue;
            this->report_interface_attributes (r);
            continue;
          }
        }

        // query_cla_parameters
        //
        {
          if (e.name () == "query_cla_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< query_cla_parameters::type > r (
              query_cla_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->query_cla_parameters ())
              continue;
            this->query_cla_parameters (r);
            continue;
          }
        }

        // report_cla_parameters
        //
        {
          if (e.name () == "report_cla_parameters" && e.namespace_ () == "")
          {
            ::std::auto_ptr< report_cla_parameters::type > r (
              report_cla_parameters::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->report_cla_parameters ())
              continue;
            this->report_cla_parameters (r);
            continue;
          }
        }
      }
    }

    cl_message* cl_message::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new cl_message (*this, f, c);
    }
  }
}

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

namespace dtn
{
  namespace clmessage
  {
    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::std::basic_string< char >& u,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& 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;

      ::xsd::cxx::xml::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 > > ();

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::std::basic_string< char >& u,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

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

      if (!d)
      {
        throw ::xsd::cxx::tree::parsing< char > ();
      }

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::std::basic_string< char >& u,
                 ::xercesc::DOMErrorHandler& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (u, h, p, f));

      if (!d)
      {
        throw ::xsd::cxx::tree::parsing< char > ();
      }

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& 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);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& 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);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, h, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 ::xercesc::DOMErrorHandler& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::sax::std_input_source isrc (is);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, h, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 const ::std::basic_string< char >& sid,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& 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);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 const ::std::basic_string< char >& sid,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& 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);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, h, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (::std::istream& is,
                 const ::std::basic_string< char >& sid,
                 ::xercesc::DOMErrorHandler& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
      ::xercesc::Wrapper4InputSource wrap (&isrc, false);
      return ::dtn::clmessage::cl_message_ (wrap, h, f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::xercesc::DOMInputSource& i,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::tree::error_handler< char > h;

      ::xsd::cxx::xml::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 > > ();

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::xercesc::DOMInputSource& i,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (i, h, p, f));

      if (!d)
      {
        throw ::xsd::cxx::tree::parsing< char > ();
      }

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::xercesc::DOMInputSource& i,
                 ::xercesc::DOMErrorHandler& h,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >& p)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (i, h, p, f));

      if (!d)
      {
        throw ::xsd::cxx::tree::parsing< char > ();
      }

      return ::dtn::clmessage::cl_message_ (
        static_cast< const ::xercesc::DOMDocument& > (*d), f, p);
    }

    ::std::auto_ptr< ::dtn::clmessage::cl_message >
    cl_message_ (const ::xercesc::DOMDocument& d,
                 ::xml_schema::flags f,
                 const ::xsd::cxx::tree::properties< char >&)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > c (
        (f & ::xml_schema::flags::keep_dom) 
        ? static_cast< ::xercesc::DOMDocument* > (d.cloneNode (true))
        : 0);

      const ::xsd::cxx::xml::dom::element< char > e (
        c.get ()
        ? *c->getDocumentElement ()
        : *d.getDocumentElement ());

      if (e.name () == "cl_message" &&
          e.namespace_ () == "")
      {
        ::std::auto_ptr< ::dtn::clmessage::cl_message > r (
          ::xsd::cxx::tree::traits< ::dtn::clmessage::cl_message, char >::create (
            e.dom_element (), f, 0));
        if (f & ::xml_schema::flags::keep_dom) c.release ();
        return r;
      }

      throw ::xsd::cxx::tree::unexpected_element < char > (
        e.name (),
        e.namespace_ (),
        "cl_message",
        "");
    }
  }
}

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

namespace dtn
{
  namespace clmessage
  {
    void
    operator<< (::xercesc::DOMElement& e,
                linkTypeType i)
    {
      e << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a,
                linkTypeType i)
    {
      a << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >& l,
                linkTypeType i)
    {
      l << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e,
                linkStateType i)
    {
      e << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a,
                linkStateType i)
    {
      a << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >& l,
                linkStateType i)
    {
      l << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e,
                linkReasonType i)
    {
      e << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a,
                linkReasonType i)
    {
      a << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >& l,
                linkReasonType i)
    {
      l << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e,
                bundlePassMethodType i)
    {
      e << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a,
                bundlePassMethodType i)
    {
      a << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >& l,
                bundlePassMethodType i)
    {
      l << static_cast< const ::xml_schema::string& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const percentType& i)
    {
      e << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a,
                const percentType& i)
    {
      a << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i);
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >& l,
                const percentType& i)
    {
      l << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i);
    }

    void
    cl_message_ (::xercesc::DOMDocument& d,
                 const ::dtn::clmessage::cl_message& s,
                 ::xml_schema::flags)
    {
      ::xsd::cxx::xml::dom::element< char > e (*d.getDocumentElement ());

      if (e.name () == "cl_message" &&
          e.namespace_ () == "")
      {
        e.dom_element () << s;
      }
      else
      {
        throw ::xsd::cxx::tree::unexpected_element < char > (
          e.name (),
          e.namespace_ (),
          "cl_message",
          "");
      }
    }

    ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument >
    cl_message_ (const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 ::xml_schema::flags f)
    {
      try
      {
        ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
          ::xsd::cxx::xml::dom::serialize< char > (
            "cl_message",
            "",
            m,
            f));
        ::dtn::clmessage::cl_message_ (*d, s, f);
        return d;
      }
      catch (const ::xsd::cxx::xml::dom::mapping< char >& e)
      {
        throw ::xsd::cxx::tree::no_namespace_mapping< char > (e.name ());
      }
      catch (const ::xsd::cxx::xml::dom::xsi_already_in_use&)
      {
        throw ::xsd::cxx::tree::xsi_already_in_use< char > ();
      }
    }

    void
    cl_message_ (::xercesc::XMLFormatTarget& t,
                 const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 const ::std::basic_string< char >& e,
                 ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::dtn::clmessage::cl_message_ (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
    cl_message_ (::xercesc::XMLFormatTarget& t,
                 const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 const ::std::basic_string< char >& e,
                 ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::dtn::clmessage::cl_message_ (s, m, f));
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        throw ::xsd::cxx::tree::serialization< char > ();
      }
    }

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

    void
    cl_message_ (::std::ostream& o,
                 const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 const ::std::basic_string< char >& e,
                 ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0);

      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::dtn::clmessage::cl_message_ (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
    cl_message_ (::std::ostream& o,
                 const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 ::xsd::cxx::xml::error_handler< char >& h,
                 const ::std::basic_string< char >& e,
                 ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0);

      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::dtn::clmessage::cl_message_ (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
    cl_message_ (::std::ostream& o,
                 const ::dtn::clmessage::cl_message& s,
                 const ::xsd::cxx::xml::dom::namespace_infomap< char >& m,
                 ::xercesc::DOMErrorHandler& h,
                 const ::std::basic_string< char >& e,
                 ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::dtn::clmessage::cl_message_ (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
    operator<< (::xercesc::DOMElement& e,
                const attribute_name& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "value",
          e);

        a.dom_attribute () << i.value ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const key_value_pair& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "name",
          e);

        a.dom_attribute () << i.name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "value",
          e);

        a.dom_attribute () << i.value ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "source_eid",
          e);

        a.dom_attribute () << i.source_eid ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "timestamp_seconds",
          e);

        a.dom_attribute () << i.timestamp_seconds ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "timestamp_sequence",
          e);

        a.dom_attribute () << i.timestamp_sequence ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_fragment",
          e);

        a.dom_attribute () << i.is_fragment ();
      }

      if (i.fragment_length ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "fragment_length",
          e);

        a.dom_attribute () << *i.fragment_length ();
      }

      if (i.fragment_offset ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "fragment_offset",
          e);

        a.dom_attribute () << *i.fragment_offset ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (link_attributes::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      if (i.type ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "type",
          e);

        a.dom_attribute () << *i.type ();
      }

      if (i.state ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "state",
          e);

        a.dom_attribute () << *i.state ();
      }

      if (i.peer_eid ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << *i.peer_eid ();
      }

      if (i.is_reachable ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_reachable",
          e);

        a.dom_attribute () << *i.is_reachable ();
      }

      if (i.is_usable ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_usable",
          e);

        a.dom_attribute () << *i.is_usable ();
      }

      if (i.how_reliable ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "how_reliable",
          e);

        a.dom_attribute () << *i.how_reliable ();
      }

      if (i.how_available ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "how_available",
          e);

        a.dom_attribute () << *i.how_available ();
      }

      if (i.reactive_fragment ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reactive_fragment",
          e);

        a.dom_attribute () << *i.reactive_fragment ();
      }

      if (i.nexthop ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "nexthop",
          e);

        a.dom_attribute () << *i.nexthop ();
      }

      if (i.cla_name ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "cla_name",
          e);

        a.dom_attribute () << *i.cla_name ();
      }

      if (i.high_water_mark ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "high_water_mark",
          e);

        a.dom_attribute () << *i.high_water_mark ();
      }

      if (i.low_water_mark ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "low_water_mark",
          e);

        a.dom_attribute () << *i.low_water_mark ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_config_parameters& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (link_config_parameters::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      if (i.is_usable ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_usable",
          e);

        a.dom_attribute () << *i.is_usable ();
      }

      if (i.reactive_fragment ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reactive_fragment",
          e);

        a.dom_attribute () << *i.reactive_fragment ();
      }

      if (i.nexthop ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "nexthop",
          e);

        a.dom_attribute () << *i.nexthop ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const contact_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "start_time",
          e);

        a.dom_attribute () << i.start_time ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "duration",
          e);

        a.dom_attribute () << i.duration ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "bps",
          e);

        a.dom_attribute () << i.bps ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "latency",
          e);

        a.dom_attribute () << i.latency ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "packet_loss_prob",
          e);

        a.dom_attribute () << i.packet_loss_prob ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const cla_add_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "name",
          e);

        a.dom_attribute () << i.name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const cla_delete_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "name",
          e);

        a.dom_attribute () << i.name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const cla_set_params_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (cla_set_params_request::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      if (i.local_eid ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "local_eid",
          e);

        a.dom_attribute () << *i.local_eid ();
      }

      if (i.create_discovered_links ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "create_discovered_links",
          e);

        a.dom_attribute () << *i.create_discovered_links ();
      }

      if (i.bundle_pass_method ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "bundle_pass_method",
          e);

        a.dom_attribute () << *i.bundle_pass_method ();
      }

      if (i.reactive_fragment_enabled ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reactive_fragment_enabled",
          e);

        a.dom_attribute () << *i.reactive_fragment_enabled ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const cla_params_set_event&)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);
    }

    void
    operator<< (::xercesc::DOMAttr&,
                const cla_params_set_event&)
    {
    }

    void
    operator<< (::xsd::cxx::tree::list_stream< char >&,
                const cla_params_set_event&)
    {
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_set_defaults_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (interface_set_defaults_request::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_create_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (interface_create_request::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_created_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_reconfigure_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (interface_reconfigure_request::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }

      if (i.up ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "up",
          e);

        a.dom_attribute () << *i.up ();
      }

      if (i.discovery ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "discovery",
          e);

        a.dom_attribute () << *i.discovery ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_reconfigured_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const interface_destroy_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const eid_reachable_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_set_defaults_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_config_parameters",
          e);
        s.dom_element () << i.link_config_parameters ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_create_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_config_parameters",
          e);
        s.dom_element () << i.link_config_parameters ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "type",
          e);

        a.dom_attribute () << i.type ();
      }

      if (i.peer_eid ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << *i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_created_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_attributes",
          e);
        s.dom_element () << i.link_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reason",
          e);

        a.dom_attribute () << i.reason ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_open_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_opened_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "contact_attributes",
          e);
        s.dom_element () << i.contact_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_close_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_closed_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "contact_attributes",
          e);
        s.dom_element () << i.contact_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_state_changed_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "new_state",
          e);

        a.dom_attribute () << i.new_state ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reason",
          e);

        a.dom_attribute () << i.reason ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_reconfigure_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_config_parameters",
          e);
        s.dom_element () << i.link_config_parameters ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_delete_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_deleted_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reason",
          e);

        a.dom_attribute () << i.reason ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_attribute_changed_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_attributes",
          e);
        s.dom_element () << i.link_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reason",
          e);

        a.dom_attribute () << i.reason ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const contact_attribute_changed_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "contact_attributes",
          e);
        s.dom_element () << i.contact_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reason",
          e);

        a.dom_attribute () << i.reason ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_add_reachable_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "link_config_parameters",
          e);
        s.dom_element () << i.link_config_parameters ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_send_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundle_attributes",
          e);
        s.dom_element () << i.bundle_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "location",
          e);

        a.dom_attribute () << i.location ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_receive_started_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "location",
          e);

        a.dom_attribute () << i.location ();
      }

      if (i.peer_eid ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << *i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_received_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "location",
          e);

        a.dom_attribute () << i.location ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "bytes_received",
          e);

        a.dom_attribute () << i.bytes_received ();
      }

      if (i.peer_eid ())
      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << *i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_transmitted_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundle_attributes",
          e);
        s.dom_element () << i.bundle_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "bytes_sent",
          e);

        a.dom_attribute () << i.bytes_sent ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reliably_sent",
          e);

        a.dom_attribute () << i.reliably_sent ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_cancel_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundle_attributes",
          e);
        s.dom_element () << i.bundle_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_canceled_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundle_attributes",
          e);
        s.dom_element () << i.bundle_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const query_bundle_queued& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundle_attributes",
          e);
        s.dom_element () << i.bundle_attributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const report_bundle_queued& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_queued",
          e);

        a.dom_attribute () << i.is_queued ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const query_eid_reachable& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << i.peer_eid ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const report_eid_reachable& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_reachable",
          e);

        a.dom_attribute () << i.is_reachable ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const query_link_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (query_link_attributes::attribute_name::const_iterator
             b (i.attribute_name ().begin ()), n (i.attribute_name ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "attribute_name",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const report_link_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (report_link_attributes::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const query_interface_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (query_interface_attributes::attribute_name::const_iterator
             b (i.attribute_name ().begin ()), n (i.attribute_name ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "attribute_name",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "interface_name",
          e);

        a.dom_attribute () << i.interface_name ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const report_interface_attributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (report_interface_attributes::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const query_cla_parameters& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (query_cla_parameters::attribute_name::const_iterator
             b (i.attribute_name ().begin ()), n (i.attribute_name ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "attribute_name",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const report_cla_parameters& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (report_cla_parameters::key_value_pair::const_iterator
             b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "key_value_pair",
            e);
          s.dom_element () << *b;
        }
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "query_id",
          e);

        a.dom_attribute () << i.query_id ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const cl_message& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        if (i.cla_add_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "cla_add_request",
            e);
          s.dom_element () << *i.cla_add_request ();
        }
      }

      {
        if (i.cla_delete_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "cla_delete_request",
            e);
          s.dom_element () << *i.cla_delete_request ();
        }
      }

      {
        if (i.cla_set_params_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "cla_set_params_request",
            e);
          s.dom_element () << *i.cla_set_params_request ();
        }
      }

      {
        if (i.cla_params_set_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "cla_params_set_event",
            e);
          s.dom_element () << *i.cla_params_set_event ();
        }
      }

      {
        if (i.interface_set_defaults_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_set_defaults_request",
            e);
          s.dom_element () << *i.interface_set_defaults_request ();
        }
      }

      {
        if (i.interface_create_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_create_request",
            e);
          s.dom_element () << *i.interface_create_request ();
        }
      }

      {
        if (i.interface_created_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_created_event",
            e);
          s.dom_element () << *i.interface_created_event ();
        }
      }

      {
        if (i.interface_reconfigure_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_reconfigure_request",
            e);
          s.dom_element () << *i.interface_reconfigure_request ();
        }
      }

      {
        if (i.interface_reconfigured_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_reconfigured_event",
            e);
          s.dom_element () << *i.interface_reconfigured_event ();
        }
      }

      {
        if (i.interface_destroy_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "interface_destroy_request",
            e);
          s.dom_element () << *i.interface_destroy_request ();
        }
      }

      {
        if (i.eid_reachable_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "eid_reachable_event",
            e);
          s.dom_element () << *i.eid_reachable_event ();
        }
      }

      {
        if (i.link_set_defaults_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_set_defaults_request",
            e);
          s.dom_element () << *i.link_set_defaults_request ();
        }
      }

      {
        if (i.link_create_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_create_request",
            e);
          s.dom_element () << *i.link_create_request ();
        }
      }

      {
        if (i.link_created_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_created_event",
            e);
          s.dom_element () << *i.link_created_event ();
        }
      }

      {
        if (i.link_open_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_open_request",
            e);
          s.dom_element () << *i.link_open_request ();
        }
      }

      {
        if (i.link_opened_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_opened_event",
            e);
          s.dom_element () << *i.link_opened_event ();
        }
      }

      {
        if (i.link_close_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_close_request",
            e);
          s.dom_element () << *i.link_close_request ();
        }
      }

      {
        if (i.link_closed_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_closed_event",
            e);
          s.dom_element () << *i.link_closed_event ();
        }
      }

      {
        if (i.link_state_changed_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_state_changed_event",
            e);
          s.dom_element () << *i.link_state_changed_event ();
        }
      }

      {
        if (i.link_reconfigure_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_reconfigure_request",
            e);
          s.dom_element () << *i.link_reconfigure_request ();
        }
      }

      {
        if (i.link_delete_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_delete_request",
            e);
          s.dom_element () << *i.link_delete_request ();
        }
      }

      {
        if (i.link_deleted_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_deleted_event",
            e);
          s.dom_element () << *i.link_deleted_event ();
        }
      }

      {
        if (i.link_attribute_changed_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_attribute_changed_event",
            e);
          s.dom_element () << *i.link_attribute_changed_event ();
        }
      }

      {
        if (i.contact_attribute_changed_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "contact_attribute_changed_event",
            e);
          s.dom_element () << *i.contact_attribute_changed_event ();
        }
      }

      {
        if (i.link_add_reachable_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_add_reachable_event",
            e);
          s.dom_element () << *i.link_add_reachable_event ();
        }
      }

      {
        if (i.bundle_send_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_send_request",
            e);
          s.dom_element () << *i.bundle_send_request ();
        }
      }

      {
        if (i.bundle_receive_started_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_receive_started_event",
            e);
          s.dom_element () << *i.bundle_receive_started_event ();
        }
      }

      {
        if (i.bundle_received_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_received_event",
            e);
          s.dom_element () << *i.bundle_received_event ();
        }
      }

      {
        if (i.bundle_transmitted_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_transmitted_event",
            e);
          s.dom_element () << *i.bundle_transmitted_event ();
        }
      }

      {
        if (i.bundle_cancel_request ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_cancel_request",
            e);
          s.dom_element () << *i.bundle_cancel_request ();
        }
      }

      {
        if (i.bundle_canceled_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_canceled_event",
            e);
          s.dom_element () << *i.bundle_canceled_event ();
        }
      }

      {
        if (i.query_bundle_queued ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "query_bundle_queued",
            e);
          s.dom_element () << *i.query_bundle_queued ();
        }
      }

      {
        if (i.report_bundle_queued ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "report_bundle_queued",
            e);
          s.dom_element () << *i.report_bundle_queued ();
        }
      }

      {
        if (i.query_eid_reachable ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "query_eid_reachable",
            e);
          s.dom_element () << *i.query_eid_reachable ();
        }
      }

      {
        if (i.report_eid_reachable ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "report_eid_reachable",
            e);
          s.dom_element () << *i.report_eid_reachable ();
        }
      }

      {
        if (i.query_link_attributes ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "query_link_attributes",
            e);
          s.dom_element () << *i.query_link_attributes ();
        }
      }

      {
        if (i.report_link_attributes ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "report_link_attributes",
            e);
          s.dom_element () << *i.report_link_attributes ();
        }
      }

      {
        if (i.query_interface_attributes ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "query_interface_attributes",
            e);
          s.dom_element () << *i.query_interface_attributes ();
        }
      }

      {
        if (i.report_interface_attributes ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "report_interface_attributes",
            e);
          s.dom_element () << *i.report_interface_attributes ();
        }
      }

      {
        if (i.query_cla_parameters ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "query_cla_parameters",
            e);
          s.dom_element () << *i.query_cla_parameters ();
        }
      }

      {
        if (i.report_cla_parameters ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "report_cla_parameters",
            e);
          s.dom_element () << *i.report_cla_parameters ();
        }
      }
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
#endif
//
// End epilogue.