// Copyright (C) 2005-2006 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.
//
// In addition, 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.
//
#include <config.h>
#ifdef XERCES_C_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
    // 


    // Parameter
    // 

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

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

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

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

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

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

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

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


    // bundleAttributes
    // 

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

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

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

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

    const bundleAttributes::timestamp::type& bundleAttributes::
    timestamp () const
    {
      return this->_xsd_timestamp_.get ();
    }

    bundleAttributes::timestamp::type& bundleAttributes::
    timestamp ()
    {
      return this->_xsd_timestamp_.get ();
    }

    void bundleAttributes::
    timestamp (const timestamp::type& timestamp)
    {
      this->_xsd_timestamp_.set (timestamp);
    }

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

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

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

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

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

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

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

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

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

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

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


    // linkAttributes
    // 

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

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

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

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

    const linkAttributes::state::type& linkAttributes::
    state () const
    {
      return this->_xsd_state_.get ();
    }

    linkAttributes::state::type& linkAttributes::
    state ()
    {
      return this->_xsd_state_.get ();
    }

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

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

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

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

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

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

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

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

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

    const linkAttributes::is_usable::type& linkAttributes::
    is_usable () const
    {
      return this->_xsd_is_usable_.get ();
    }

    linkAttributes::is_usable::type& linkAttributes::
    is_usable ()
    {
      return this->_xsd_is_usable_.get ();
    }

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

    const linkAttributes::how_reliable::type& linkAttributes::
    how_reliable () const
    {
      return this->_xsd_how_reliable_.get ();
    }

    linkAttributes::how_reliable::type& linkAttributes::
    how_reliable ()
    {
      return this->_xsd_how_reliable_.get ();
    }

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

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

    const linkAttributes::how_available::type& linkAttributes::
    how_available () const
    {
      return this->_xsd_how_available_.get ();
    }

    linkAttributes::how_available::type& linkAttributes::
    how_available ()
    {
      return this->_xsd_how_available_.get ();
    }

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

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

    const linkAttributes::reactive_fragment::type& linkAttributes::
    reactive_fragment () const
    {
      return this->_xsd_reactive_fragment_.get ();
    }

    linkAttributes::reactive_fragment::type& linkAttributes::
    reactive_fragment ()
    {
      return this->_xsd_reactive_fragment_.get ();
    }

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

    const linkAttributes::underlay_address::type& linkAttributes::
    underlay_address () const
    {
      return this->_xsd_underlay_address_.get ();
    }

    linkAttributes::underlay_address::type& linkAttributes::
    underlay_address ()
    {
      return this->_xsd_underlay_address_.get ();
    }

    void linkAttributes::
    underlay_address (const underlay_address::type& underlay_address)
    {
      this->_xsd_underlay_address_.set (underlay_address);
    }

    void linkAttributes::
    underlay_address (::std::auto_ptr< underlay_address::type > underlay_address)
    {
      this->_xsd_underlay_address_.set (underlay_address);
    }

    const linkAttributes::cla_name::type& linkAttributes::
    cla_name () const
    {
      return this->_xsd_cla_name_.get ();
    }

    linkAttributes::cla_name::type& linkAttributes::
    cla_name ()
    {
      return this->_xsd_cla_name_.get ();
    }

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

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


    // contactAttributes
    // 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void contactAttributes::
    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::Parameter::container& cla_set_params_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    cla_set_params_request::Parameter::container& cla_set_params_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void cla_set_params_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }

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


    // cla_params_set_event
    // 


    // interface_set_defaults_request
    // 

    const interface_set_defaults_request::Parameter::container& interface_set_defaults_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    interface_set_defaults_request::Parameter::container& interface_set_defaults_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void interface_set_defaults_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }


    // interface_create_request
    // 

    const interface_create_request::Parameter::container& interface_create_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    interface_create_request::Parameter::container& interface_create_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void interface_create_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }

    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::Parameter::container& interface_reconfigure_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    interface_reconfigure_request::Parameter::container& interface_reconfigure_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void interface_reconfigure_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }

    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::Parameter::container& link_set_defaults_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    link_set_defaults_request::Parameter::container& link_set_defaults_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void link_set_defaults_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }


    // link_create_request
    // 

    const link_create_request::Parameter::container& link_create_request::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    link_create_request::Parameter::container& link_create_request::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void link_create_request::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }

    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::linkAttributes::type& link_created_event::
    linkAttributes () const
    {
      return this->_xsd_linkAttributes_.get ();
    }

    link_created_event::linkAttributes::type& link_created_event::
    linkAttributes ()
    {
      return this->_xsd_linkAttributes_.get ();
    }

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

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

    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_reachable_event
    // 

    const link_reachable_event::Parameter::container& link_reachable_event::
    Parameter () const
    {
      return this->_xsd_Parameter_;
    }

    link_reachable_event::Parameter::container& link_reachable_event::
    Parameter ()
    {
      return this->_xsd_Parameter_;
    }

    void link_reachable_event::
    Parameter (const Parameter::container& Parameter)
    {
      this->_xsd_Parameter_ = Parameter;
    }

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

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

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

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

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

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

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

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


    // 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::contactAttributes::type& link_opened_event::
    contactAttributes () const
    {
      return this->_xsd_contactAttributes_.get ();
    }

    link_opened_event::contactAttributes::type& link_opened_event::
    contactAttributes ()
    {
      return this->_xsd_contactAttributes_.get ();
    }

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

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

    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::contactAttributes::type& link_closed_event::
    contactAttributes () const
    {
      return this->_xsd_contactAttributes_.get ();
    }

    link_closed_event::contactAttributes::type& link_closed_event::
    contactAttributes ()
    {
      return this->_xsd_contactAttributes_.get ();
    }

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

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

    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_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::linkAttributes::type& link_deleted_event::
    linkAttributes () const
    {
      return this->_xsd_linkAttributes_.get ();
    }

    link_deleted_event::linkAttributes::type& link_deleted_event::
    linkAttributes ()
    {
      return this->_xsd_linkAttributes_.get ();
    }

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

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

    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::linkAttributes::type& link_attribute_changed_event::
    linkAttributes () const
    {
      return this->_xsd_linkAttributes_.get ();
    }

    link_attribute_changed_event::linkAttributes::type& link_attribute_changed_event::
    linkAttributes ()
    {
      return this->_xsd_linkAttributes_.get ();
    }

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

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

    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::contactAttributes::type& contact_attribute_changed_event::
    contactAttributes () const
    {
      return this->_xsd_contactAttributes_.get ();
    }

    contact_attribute_changed_event::contactAttributes::type& contact_attribute_changed_event::
    contactAttributes ()
    {
      return this->_xsd_contactAttributes_.get ();
    }

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

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

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


    // bundle_send_request
    // 

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

    bundle_send_request::bundleAttributes::type& bundle_send_request::
    bundleAttributes ()
    {
      return this->_xsd_bundleAttributes_.get ();
    }

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

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

    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::bundleAttributes::type& bundle_transmitted_event::
    bundleAttributes () const
    {
      return this->_xsd_bundleAttributes_.get ();
    }

    bundle_transmitted_event::bundleAttributes::type& bundle_transmitted_event::
    bundleAttributes ()
    {
      return this->_xsd_bundleAttributes_.get ();
    }

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

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

    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::bundleAttributes::type& bundle_cancel_request::
    bundleAttributes () const
    {
      return this->_xsd_bundleAttributes_.get ();
    }

    bundle_cancel_request::bundleAttributes::type& bundle_cancel_request::
    bundleAttributes ()
    {
      return this->_xsd_bundleAttributes_.get ();
    }

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

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

    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_cancelled_event
    // 

    const bundle_cancelled_event::bundleAttributes::type& bundle_cancelled_event::
    bundleAttributes () const
    {
      return this->_xsd_bundleAttributes_.get ();
    }

    bundle_cancelled_event::bundleAttributes::type& bundle_cancelled_event::
    bundleAttributes ()
    {
      return this->_xsd_bundleAttributes_.get ();
    }

    void bundle_cancelled_event::
    bundleAttributes (const bundleAttributes::type& bundleAttributes)
    {
      this->_xsd_bundleAttributes_.set (bundleAttributes);
    }

    void bundle_cancelled_event::
    bundleAttributes (::std::auto_ptr< bundleAttributes::type > bundleAttributes)
    {
      this->_xsd_bundleAttributes_.set (bundleAttributes);
    }

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

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

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

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


    // 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_reachable_event::container& cl_message::
    link_reachable_event () const
    {
      return this->_xsd_link_reachable_event_;
    }

    cl_message::link_reachable_event::container& cl_message::
    link_reachable_event ()
    {
      return this->_xsd_link_reachable_event_;
    }

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

    void cl_message::
    link_reachable_event (const link_reachable_event::container& link_reachable_event)
    {
      this->_xsd_link_reachable_event_ = link_reachable_event;
    }

    void cl_message::
    link_reachable_event (::std::auto_ptr< link_reachable_event::type > link_reachable_event)
    {
      this->_xsd_link_reachable_event_.set (link_reachable_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_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::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_cancelled_event::container& cl_message::
    bundle_cancelled_event () const
    {
      return this->_xsd_bundle_cancelled_event_;
    }

    cl_message::bundle_cancelled_event::container& cl_message::
    bundle_cancelled_event ()
    {
      return this->_xsd_bundle_cancelled_event_;
    }

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

    void cl_message::
    bundle_cancelled_event (const bundle_cancelled_event::container& bundle_cancelled_event)
    {
      this->_xsd_bundle_cancelled_event_ = bundle_cancelled_event;
    }

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

#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);
    }

    // Parameter
    //

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

    Parameter::
    Parameter (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)
    {
    }

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

    Parameter::
    Parameter (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 Parameter::
    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",
          "");
      }
    }

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

    // bundleAttributes
    //

    bundleAttributes::
    bundleAttributes ()
    : ::xml_schema::type (),
    _xsd_source_eid_ (::xml_schema::flags (), this),
    _xsd_timestamp_ (::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)
    {
    }

    bundleAttributes::
    bundleAttributes (const source_eid::type& _xsd_source_eid,
                      const timestamp::type& _xsd_timestamp,
                      const is_fragment::type& _xsd_is_fragment)
    : ::xml_schema::type (),
    _xsd_source_eid_ (_xsd_source_eid,
                      ::xml_schema::flags (),
                      this),
    _xsd_timestamp_ (_xsd_timestamp,
                     ::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)
    {
    }

    bundleAttributes::
    bundleAttributes (const bundleAttributes& _xsd_bundleAttributes,
                      ::xml_schema::flags f,
                      ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundleAttributes, f, c),
    _xsd_source_eid_ (_xsd_bundleAttributes._xsd_source_eid_,
                      f | ::xml_schema::flags::not_root,
                      this),
    _xsd_timestamp_ (_xsd_bundleAttributes._xsd_timestamp_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_is_fragment_ (_xsd_bundleAttributes._xsd_is_fragment_,
                       f | ::xml_schema::flags::not_root,
                       this),
    _xsd_fragment_length_ (_xsd_bundleAttributes._xsd_fragment_length_,
                           f | ::xml_schema::flags::not_root,
                           this),
    _xsd_fragment_offset_ (_xsd_bundleAttributes._xsd_fragment_offset_,
                           f | ::xml_schema::flags::not_root,
                           this)
    {
    }

    bundleAttributes::
    bundleAttributes (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_ (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 bundleAttributes::
    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" && a.namespace_ ().empty ())
        {
          this->timestamp (
            timestamp::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_.present ())
      {
        throw ::xsd::cxx::tree::expected_attribute< char > (
          "timestamp",
          "");
      }

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

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

    // linkAttributes
    //

    linkAttributes::
    linkAttributes ()
    : ::xml_schema::type (),
    _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_underlay_address_ (::xml_schema::flags (), this),
    _xsd_cla_name_ (::xml_schema::flags (), this)
    {
    }

    linkAttributes::
    linkAttributes (const type::type_& _xsd_type,
                    const state::type& _xsd_state,
                    const peer_eid::type& _xsd_peer_eid,
                    const is_reachable::type& _xsd_is_reachable,
                    const is_usable::type& _xsd_is_usable,
                    const how_reliable::type& _xsd_how_reliable,
                    const how_available::type& _xsd_how_available,
                    const reactive_fragment::type& _xsd_reactive_fragment,
                    const underlay_address::type& _xsd_underlay_address,
                    const cla_name::type& _xsd_cla_name)
    : ::xml_schema::type (),
    _xsd_type_ (_xsd_type,
                ::xml_schema::flags (),
                this),
    _xsd_state_ (_xsd_state,
                 ::xml_schema::flags (),
                 this),
    _xsd_peer_eid_ (_xsd_peer_eid,
                    ::xml_schema::flags (),
                    this),
    _xsd_is_reachable_ (_xsd_is_reachable,
                        ::xml_schema::flags (),
                        this),
    _xsd_is_usable_ (_xsd_is_usable,
                     ::xml_schema::flags (),
                     this),
    _xsd_how_reliable_ (_xsd_how_reliable,
                        ::xml_schema::flags (),
                        this),
    _xsd_how_available_ (_xsd_how_available,
                         ::xml_schema::flags (),
                         this),
    _xsd_reactive_fragment_ (_xsd_reactive_fragment,
                             ::xml_schema::flags (),
                             this),
    _xsd_underlay_address_ (_xsd_underlay_address,
                            ::xml_schema::flags (),
                            this),
    _xsd_cla_name_ (_xsd_cla_name,
                    ::xml_schema::flags (),
                    this)
    {
    }

    linkAttributes::
    linkAttributes (const linkAttributes& _xsd_linkAttributes,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_linkAttributes, f, c),
    _xsd_type_ (_xsd_linkAttributes._xsd_type_,
                f | ::xml_schema::flags::not_root,
                this),
    _xsd_state_ (_xsd_linkAttributes._xsd_state_,
                 f | ::xml_schema::flags::not_root,
                 this),
    _xsd_peer_eid_ (_xsd_linkAttributes._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_is_reachable_ (_xsd_linkAttributes._xsd_is_reachable_,
                        f | ::xml_schema::flags::not_root,
                        this),
    _xsd_is_usable_ (_xsd_linkAttributes._xsd_is_usable_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_how_reliable_ (_xsd_linkAttributes._xsd_how_reliable_,
                        f | ::xml_schema::flags::not_root,
                        this),
    _xsd_how_available_ (_xsd_linkAttributes._xsd_how_available_,
                         f | ::xml_schema::flags::not_root,
                         this),
    _xsd_reactive_fragment_ (_xsd_linkAttributes._xsd_reactive_fragment_,
                             f | ::xml_schema::flags::not_root,
                             this),
    _xsd_underlay_address_ (_xsd_linkAttributes._xsd_underlay_address_,
                            f | ::xml_schema::flags::not_root,
                            this),
    _xsd_cla_name_ (_xsd_linkAttributes._xsd_cla_name_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    linkAttributes::
    linkAttributes (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _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_underlay_address_ (f | ::xml_schema::flags::not_root, this),
    _xsd_cla_name_ (f | ::xml_schema::flags::not_root, this)
    {
      parse (e, f);
    }

    void linkAttributes::
    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 () == "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 () == "underlay_address" && a.namespace_ ().empty ())
        {
          ::std::auto_ptr< underlay_address::type > r (
            underlay_address::traits::create (
              a.dom_attribute (),
              f | ::xml_schema::flags::not_root,
              this));

          this->underlay_address (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 (!_xsd_type_.present ())
      {
        throw ::xsd::cxx::tree::expected_attribute< char > (
          "type",
          "");
      }

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

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

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

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

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

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

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

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

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

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

    // contactAttributes
    //

    contactAttributes::
    contactAttributes ()
    : ::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)
    {
    }

    contactAttributes::
    contactAttributes (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)
    {
    }

    contactAttributes::
    contactAttributes (const contactAttributes& _xsd_contactAttributes,
                       ::xml_schema::flags f,
                       ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_contactAttributes, f, c),
    _xsd_start_time_ (_xsd_contactAttributes._xsd_start_time_,
                      f | ::xml_schema::flags::not_root,
                      this),
    _xsd_duration_ (_xsd_contactAttributes._xsd_duration_,
                    f | ::xml_schema::flags::not_root,
                    this),
    _xsd_bps_ (_xsd_contactAttributes._xsd_bps_,
               f | ::xml_schema::flags::not_root,
               this),
    _xsd_latency_ (_xsd_contactAttributes._xsd_latency_,
                   f | ::xml_schema::flags::not_root,
                   this),
    _xsd_packet_loss_prob_ (_xsd_contactAttributes._xsd_packet_loss_prob_,
                            f | ::xml_schema::flags::not_root,
                            this)
    {
    }

    contactAttributes::
    contactAttributes (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 contactAttributes::
    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",
          "");
      }
    }

    contactAttributes* contactAttributes::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new contactAttributes (*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_Parameter_ (::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)
    {
    }

    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_Parameter_ (_xsd_cla_set_params_request._xsd_Parameter_,
                     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)
    {
    }

    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_Parameter_ (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)
    {
      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 ());

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

            this->Parameter ().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;
        }
      }
    }

    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_Parameter_ (::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_Parameter_ (_xsd_interface_set_defaults_request._xsd_Parameter_,
                     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_Parameter_ (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 ());

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

            this->Parameter ().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_Parameter_ (::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_Parameter_ (::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_Parameter_ (_xsd_interface_create_request._xsd_Parameter_,
                     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_Parameter_ (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 ());

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

            this->Parameter ().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_Parameter_ (::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_Parameter_ (::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_Parameter_ (_xsd_interface_reconfigure_request._xsd_Parameter_,
                     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_Parameter_ (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 ());

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

            this->Parameter ().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_Parameter_ (::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_Parameter_ (_xsd_link_set_defaults_request._xsd_Parameter_,
                     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_Parameter_ (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 ());

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

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

    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_Parameter_ (::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_name::type& _xsd_link_name,
                         const type::type_& _xsd_type)
    : ::xml_schema::type (),
    _xsd_Parameter_ (::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_Parameter_ (_xsd_link_create_request._xsd_Parameter_,
                     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_Parameter_ (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 ());

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

            this->Parameter ().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 () == "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_linkAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_created_event::
    link_created_event (const linkAttributes::type& _xsd_linkAttributes,
                        const link_name::type& _xsd_link_name,
                        const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_linkAttributes_ (_xsd_linkAttributes,
                          ::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_linkAttributes_ (_xsd_link_created_event._xsd_linkAttributes_,
                          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_linkAttributes_ (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 ());

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

            if (_xsd_linkAttributes_.present ())
              continue;
            this->linkAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_linkAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "linkAttributes",
          "");
      }

      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_reachable_event
    //

    link_reachable_event::
    link_reachable_event ()
    : ::xml_schema::type (),
    _xsd_Parameter_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_peer_eid_ (::xml_schema::flags (), this)
    {
    }

    link_reachable_event::
    link_reachable_event (const link_name::type& _xsd_link_name,
                          const peer_eid::type& _xsd_peer_eid)
    : ::xml_schema::type (),
    _xsd_Parameter_ (::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_reachable_event::
    link_reachable_event (const link_reachable_event& _xsd_link_reachable_event,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_link_reachable_event, f, c),
    _xsd_Parameter_ (_xsd_link_reachable_event._xsd_Parameter_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_link_name_ (_xsd_link_reachable_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this),
    _xsd_peer_eid_ (_xsd_link_reachable_event._xsd_peer_eid_,
                    f | ::xml_schema::flags::not_root,
                    this)
    {
    }

    link_reachable_event::
    link_reachable_event (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::type* c)
    : ::xml_schema::type (e, f, c),
    _xsd_Parameter_ (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_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 ());

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

            this->Parameter ().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 () == "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_reachable_event* link_reachable_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new link_reachable_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_contactAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_opened_event::
    link_opened_event (const contactAttributes::type& _xsd_contactAttributes,
                       const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_contactAttributes_ (_xsd_contactAttributes,
                             ::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_contactAttributes_ (_xsd_link_opened_event._xsd_contactAttributes_,
                             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_contactAttributes_ (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 ());

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

            if (_xsd_contactAttributes_.present ())
              continue;
            this->contactAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contactAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contactAttributes",
          "");
      }

      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_contactAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    link_closed_event::
    link_closed_event (const contactAttributes::type& _xsd_contactAttributes,
                       const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_contactAttributes_ (_xsd_contactAttributes,
                             ::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_contactAttributes_ (_xsd_link_closed_event._xsd_contactAttributes_,
                             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_contactAttributes_ (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 ());

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

            if (_xsd_contactAttributes_.present ())
              continue;
            this->contactAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contactAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contactAttributes",
          "");
      }

      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_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_linkAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_reason_ (::xml_schema::flags (), this)
    {
    }

    link_deleted_event::
    link_deleted_event (const linkAttributes::type& _xsd_linkAttributes,
                        const link_name::type& _xsd_link_name,
                        const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_linkAttributes_ (_xsd_linkAttributes,
                          ::xml_schema::flags (),
                          this),
    _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_linkAttributes_ (_xsd_link_deleted_event._xsd_linkAttributes_,
                          f | ::xml_schema::flags::not_root,
                          this),
    _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_linkAttributes_ (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_deleted_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 ());

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

            if (_xsd_linkAttributes_.present ())
              continue;
            this->linkAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_linkAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "linkAttributes",
          "");
      }

      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_linkAttributes_ (::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 linkAttributes::type& _xsd_linkAttributes,
                                  const link_name::type& _xsd_link_name,
                                  const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_linkAttributes_ (_xsd_linkAttributes,
                          ::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_linkAttributes_ (_xsd_link_attribute_changed_event._xsd_linkAttributes_,
                          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_linkAttributes_ (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 ());

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

            if (_xsd_linkAttributes_.present ())
              continue;
            this->linkAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_linkAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "linkAttributes",
          "");
      }

      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_contactAttributes_ (::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 contactAttributes::type& _xsd_contactAttributes,
                                     const link_name::type& _xsd_link_name,
                                     const reason::type& _xsd_reason)
    : ::xml_schema::type (),
    _xsd_contactAttributes_ (_xsd_contactAttributes,
                             ::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_contactAttributes_ (_xsd_contact_attribute_changed_event._xsd_contactAttributes_,
                             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_contactAttributes_ (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 ());

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

            if (_xsd_contactAttributes_.present ())
              continue;
            this->contactAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_contactAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "contactAttributes",
          "");
      }

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

    // bundle_send_request
    //

    bundle_send_request::
    bundle_send_request ()
    : ::xml_schema::type (),
    _xsd_bundleAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this),
    _xsd_location_ (::xml_schema::flags (), this)
    {
    }

    bundle_send_request::
    bundle_send_request (const bundleAttributes::type& _xsd_bundleAttributes,
                         const link_name::type& _xsd_link_name,
                         const location::type& _xsd_location)
    : ::xml_schema::type (),
    _xsd_bundleAttributes_ (_xsd_bundleAttributes,
                            ::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_bundleAttributes_ (_xsd_bundle_send_request._xsd_bundleAttributes_,
                            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_bundleAttributes_ (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 ());

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

            if (_xsd_bundleAttributes_.present ())
              continue;
            this->bundleAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundleAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundleAttributes",
          "");
      }

      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_bundleAttributes_ (::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 bundleAttributes::type& _xsd_bundleAttributes,
                              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_bundleAttributes_ (_xsd_bundleAttributes,
                            ::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_bundleAttributes_ (_xsd_bundle_transmitted_event._xsd_bundleAttributes_,
                            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_bundleAttributes_ (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 ());

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

            if (_xsd_bundleAttributes_.present ())
              continue;
            this->bundleAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundleAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundleAttributes",
          "");
      }

      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_bundleAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    bundle_cancel_request::
    bundle_cancel_request (const bundleAttributes::type& _xsd_bundleAttributes,
                           const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_bundleAttributes_ (_xsd_bundleAttributes,
                            ::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_bundleAttributes_ (_xsd_bundle_cancel_request._xsd_bundleAttributes_,
                            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_bundleAttributes_ (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 ());

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

            if (_xsd_bundleAttributes_.present ())
              continue;
            this->bundleAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundleAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundleAttributes",
          "");
      }

      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_cancelled_event
    //

    bundle_cancelled_event::
    bundle_cancelled_event ()
    : ::xml_schema::type (),
    _xsd_bundleAttributes_ (::xml_schema::flags (), this),
    _xsd_link_name_ (::xml_schema::flags (), this)
    {
    }

    bundle_cancelled_event::
    bundle_cancelled_event (const bundleAttributes::type& _xsd_bundleAttributes,
                            const link_name::type& _xsd_link_name)
    : ::xml_schema::type (),
    _xsd_bundleAttributes_ (_xsd_bundleAttributes,
                            ::xml_schema::flags (),
                            this),
    _xsd_link_name_ (_xsd_link_name,
                     ::xml_schema::flags (),
                     this)
    {
    }

    bundle_cancelled_event::
    bundle_cancelled_event (const bundle_cancelled_event& _xsd_bundle_cancelled_event,
                            ::xml_schema::flags f,
                            ::xml_schema::type* c)
    : ::xml_schema::type (_xsd_bundle_cancelled_event, f, c),
    _xsd_bundleAttributes_ (_xsd_bundle_cancelled_event._xsd_bundleAttributes_,
                            f | ::xml_schema::flags::not_root,
                            this),
    _xsd_link_name_ (_xsd_bundle_cancelled_event._xsd_link_name_,
                     f | ::xml_schema::flags::not_root,
                     this)
    {
    }

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

    void bundle_cancelled_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 ());

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

            if (_xsd_bundleAttributes_.present ())
              continue;
            this->bundleAttributes (r);
            continue;
          }
        }
      }

      if (!_xsd_bundleAttributes_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "bundleAttributes",
          "");
      }

      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_cancelled_event* bundle_cancelled_event::
    _clone (::xml_schema::flags f,
            ::xml_schema::type* c) const
    {
      return new bundle_cancelled_event (*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_reachable_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_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_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_cancelled_event_ (::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_reachable_event_ (_xsd_cl_message._xsd_link_reachable_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_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_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_cancelled_event_ (_xsd_cl_message._xsd_bundle_cancelled_event_,
                                  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_reachable_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_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_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_cancelled_event_ (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_reachable_event
        //
        {
          if (e.name () == "link_reachable_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< link_reachable_event::type > r (
              link_reachable_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->link_reachable_event ())
              continue;
            this->link_reachable_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_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;
          }
        }

        // 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_cancelled_event
        //
        {
          if (e.name () == "bundle_cancelled_event" && e.namespace_ () == "")
          {
            ::std::auto_ptr< bundle_cancelled_event::type > r (
              bundle_cancelled_event::traits::create (
                e.dom_element (),
                f | ::xml_schema::flags::not_root,
                this));

            if (this->bundle_cancelled_event ())
              continue;
            this->bundle_cancelled_event (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 Parameter& 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 bundleAttributes& 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",
          e);

        a.dom_attribute () << i.timestamp ();
      }

      {
        ::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 linkAttributes& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "type",
          e);

        a.dom_attribute () << i.type ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "state",
          e);

        a.dom_attribute () << i.state ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "peer_eid",
          e);

        a.dom_attribute () << i.peer_eid ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_reachable",
          e);

        a.dom_attribute () << i.is_reachable ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "is_usable",
          e);

        a.dom_attribute () << i.is_usable ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "how_reliable",
          e);

        a.dom_attribute () << i.how_reliable ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "how_available",
          e);

        a.dom_attribute () << i.how_available ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "reactive_fragment",
          e);

        a.dom_attribute () << i.reactive_fragment ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "underlay_address",
          e);

        a.dom_attribute () << i.underlay_address ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "cla_name",
          e);

        a.dom_attribute () << i.cla_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const contactAttributes& 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::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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 ();
      }
    }

    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::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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);

      {
        for (link_set_defaults_request::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            e);
          s.dom_element () << *b;
        }
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const link_create_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (link_create_request::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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 (
          "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 (
          "linkAttributes",
          e);
        s.dom_element () << i.linkAttributes ();
      }

      {
        ::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_reachable_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        for (link_reachable_event::Parameter::const_iterator
             b (i.Parameter ().begin ()), n (i.Parameter ().end ());
             b != n; ++b)
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "Parameter",
            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 (
          "peer_eid",
          e);

        a.dom_attribute () << i.peer_eid ();
      }
    }

    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 (
          "contactAttributes",
          e);
        s.dom_element () << i.contactAttributes ();
      }

      {
        ::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 (
          "contactAttributes",
          e);
        s.dom_element () << i.contactAttributes ();
      }

      {
        ::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_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::element< char > s (
          "linkAttributes",
          e);
        s.dom_element () << i.linkAttributes ();
      }

      {
        ::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 (
          "linkAttributes",
          e);
        s.dom_element () << i.linkAttributes ();
      }

      {
        ::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 (
          "contactAttributes",
          e);
        s.dom_element () << i.contactAttributes ();
      }

      {
        ::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 bundle_send_request& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundleAttributes",
          e);
        s.dom_element () << i.bundleAttributes ();
      }

      {
        ::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 (
          "bundleAttributes",
          e);
        s.dom_element () << i.bundleAttributes ();
      }

      {
        ::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 (
          "bundleAttributes",
          e);
        s.dom_element () << i.bundleAttributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e,
                const bundle_cancelled_event& i)
    {
      while (::xercesc::DOMNode* n = e.getFirstChild ())
        e.removeChild (n);

      {
        ::xsd::cxx::xml::dom::element< char > s (
          "bundleAttributes",
          e);
        s.dom_element () << i.bundleAttributes ();
      }

      {
        ::xsd::cxx::xml::dom::attribute< char > a (
          "link_name",
          e);

        a.dom_attribute () << i.link_name ();
      }
    }

    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_reachable_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "link_reachable_event",
            e);
          s.dom_element () << *i.link_reachable_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_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.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_cancelled_event ())
        {
          ::xsd::cxx::xml::dom::element< char > s (
            "bundle_cancelled_event",
            e);
          s.dom_element () << *i.bundle_cancelled_event ();
        }
      }
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
#endif
//
// End epilogue.