diff -r 000000000000 -r 2b3e5ec03512 servlib/conv_layers/clevent.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servlib/conv_layers/clevent.cc Thu Apr 21 14:57:45 2011 +0100 @@ -0,0 +1,13650 @@ +// Copyright (C) 2005-2007 Code Synthesis Tools CC +// +// This program was generated by XML Schema Definition Compiler (XSD) +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License version 2 as +// published by the Free Software Foundation. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +// +// In addition, as a special exception, Code Synthesis Tools CC gives +// permission to link this program with the Xerces-C++ library (or with +// modified versions of Xerces-C++ that use the same license as Xerces-C++), +// and distribute linked combinations including the two. You must obey +// the GNU General Public License version 2 in all respects for all of +// the code used other than Xerces-C++. If you modify this copy of the +// program, you may extend this exception to your version of the program, +// but you are not obligated to do so. If you do not wish to do so, delete +// this exception statement from your version. +// +// Furthermore, Code Synthesis Tools CC makes a special exception for +// the Free/Libre and Open Source Software (FLOSS) which is described +// in the accompanying FLOSSE file. +// + +// Begin prologue. +// +#ifdef HAVE_CONFIG_H +# include +#endif +#if defined(XERCES_C_ENABLED) && defined(EXTERNAL_CL_ENABLED) +// +// End prologue. + +#include + +#include "clevent.h" + +namespace dtn +{ + namespace clmessage + { + // linkTypeType + // + + linkTypeType:: + linkTypeType () + : ::xml_schema::string () + { + } + + linkTypeType:: + linkTypeType (_xsd_linkTypeType v) + : ::xml_schema::string (_xsd_linkTypeType_literals_[v]) + { + } + + linkTypeType:: + linkTypeType (const ::xml_schema::string& _xsd_linkTypeType) + : ::xml_schema::string (_xsd_linkTypeType) + { + } + + linkTypeType:: + linkTypeType (const linkTypeType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + linkTypeType& linkTypeType:: + operator= (_xsd_linkTypeType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_linkTypeType_literals_[v]); + + return *this; + } + + + // linkStateType + // + + linkStateType:: + linkStateType () + : ::xml_schema::string () + { + } + + linkStateType:: + linkStateType (_xsd_linkStateType v) + : ::xml_schema::string (_xsd_linkStateType_literals_[v]) + { + } + + linkStateType:: + linkStateType (const ::xml_schema::string& _xsd_linkStateType) + : ::xml_schema::string (_xsd_linkStateType) + { + } + + linkStateType:: + linkStateType (const linkStateType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + linkStateType& linkStateType:: + operator= (_xsd_linkStateType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_linkStateType_literals_[v]); + + return *this; + } + + + // linkReasonType + // + + linkReasonType:: + linkReasonType () + : ::xml_schema::string () + { + } + + linkReasonType:: + linkReasonType (_xsd_linkReasonType v) + : ::xml_schema::string (_xsd_linkReasonType_literals_[v]) + { + } + + linkReasonType:: + linkReasonType (const ::xml_schema::string& _xsd_linkReasonType) + : ::xml_schema::string (_xsd_linkReasonType) + { + } + + linkReasonType:: + linkReasonType (const linkReasonType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + linkReasonType& linkReasonType:: + operator= (_xsd_linkReasonType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_linkReasonType_literals_[v]); + + return *this; + } + + + // bundlePassMethodType + // + + bundlePassMethodType:: + bundlePassMethodType () + : ::xml_schema::string () + { + } + + bundlePassMethodType:: + bundlePassMethodType (_xsd_bundlePassMethodType v) + : ::xml_schema::string (_xsd_bundlePassMethodType_literals_[v]) + { + } + + bundlePassMethodType:: + bundlePassMethodType (const ::xml_schema::string& _xsd_bundlePassMethodType) + : ::xml_schema::string (_xsd_bundlePassMethodType) + { + } + + bundlePassMethodType:: + bundlePassMethodType (const bundlePassMethodType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + bundlePassMethodType& bundlePassMethodType:: + operator= (_xsd_bundlePassMethodType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_bundlePassMethodType_literals_[v]); + + return *this; + } + + + // percentType + // + + + // attribute_name + // + + const attribute_name::value::type& attribute_name:: + value () const + { + return this->_xsd_value_.get (); + } + + attribute_name::value::type& attribute_name:: + value () + { + return this->_xsd_value_.get (); + } + + void attribute_name:: + value (const value::type& value) + { + this->_xsd_value_.set (value); + } + + void attribute_name:: + value (::std::auto_ptr< value::type > value) + { + this->_xsd_value_.set (value); + } + + + // key_value_pair + // + + const key_value_pair::name::type& key_value_pair:: + name () const + { + return this->_xsd_name_.get (); + } + + key_value_pair::name::type& key_value_pair:: + name () + { + return this->_xsd_name_.get (); + } + + void key_value_pair:: + name (const name::type& name) + { + this->_xsd_name_.set (name); + } + + void key_value_pair:: + name (::std::auto_ptr< name::type > name) + { + this->_xsd_name_.set (name); + } + + const key_value_pair::value::type& key_value_pair:: + value () const + { + return this->_xsd_value_.get (); + } + + key_value_pair::value::type& key_value_pair:: + value () + { + return this->_xsd_value_.get (); + } + + void key_value_pair:: + value (const value::type& value) + { + this->_xsd_value_.set (value); + } + + void key_value_pair:: + value (::std::auto_ptr< value::type > value) + { + this->_xsd_value_.set (value); + } + + + // bundle_attributes + // + + const bundle_attributes::source_eid::type& bundle_attributes:: + source_eid () const + { + return this->_xsd_source_eid_.get (); + } + + bundle_attributes::source_eid::type& bundle_attributes:: + source_eid () + { + return this->_xsd_source_eid_.get (); + } + + void bundle_attributes:: + source_eid (const source_eid::type& source_eid) + { + this->_xsd_source_eid_.set (source_eid); + } + + void bundle_attributes:: + source_eid (::std::auto_ptr< source_eid::type > source_eid) + { + this->_xsd_source_eid_.set (source_eid); + } + + const bundle_attributes::timestamp_seconds::type& bundle_attributes:: + timestamp_seconds () const + { + return this->_xsd_timestamp_seconds_.get (); + } + + bundle_attributes::timestamp_seconds::type& bundle_attributes:: + timestamp_seconds () + { + return this->_xsd_timestamp_seconds_.get (); + } + + void bundle_attributes:: + timestamp_seconds (const timestamp_seconds::type& timestamp_seconds) + { + this->_xsd_timestamp_seconds_.set (timestamp_seconds); + } + + const bundle_attributes::timestamp_sequence::type& bundle_attributes:: + timestamp_sequence () const + { + return this->_xsd_timestamp_sequence_.get (); + } + + bundle_attributes::timestamp_sequence::type& bundle_attributes:: + timestamp_sequence () + { + return this->_xsd_timestamp_sequence_.get (); + } + + void bundle_attributes:: + timestamp_sequence (const timestamp_sequence::type& timestamp_sequence) + { + this->_xsd_timestamp_sequence_.set (timestamp_sequence); + } + + const bundle_attributes::is_fragment::type& bundle_attributes:: + is_fragment () const + { + return this->_xsd_is_fragment_.get (); + } + + bundle_attributes::is_fragment::type& bundle_attributes:: + is_fragment () + { + return this->_xsd_is_fragment_.get (); + } + + void bundle_attributes:: + is_fragment (const is_fragment::type& is_fragment) + { + this->_xsd_is_fragment_.set (is_fragment); + } + + const bundle_attributes::fragment_length::container& bundle_attributes:: + fragment_length () const + { + return this->_xsd_fragment_length_; + } + + bundle_attributes::fragment_length::container& bundle_attributes:: + fragment_length () + { + return this->_xsd_fragment_length_; + } + + void bundle_attributes:: + fragment_length (const fragment_length::type& fragment_length) + { + this->_xsd_fragment_length_.set (fragment_length); + } + + void bundle_attributes:: + fragment_length (const fragment_length::container& fragment_length) + { + this->_xsd_fragment_length_ = fragment_length; + } + + const bundle_attributes::fragment_offset::container& bundle_attributes:: + fragment_offset () const + { + return this->_xsd_fragment_offset_; + } + + bundle_attributes::fragment_offset::container& bundle_attributes:: + fragment_offset () + { + return this->_xsd_fragment_offset_; + } + + void bundle_attributes:: + fragment_offset (const fragment_offset::type& fragment_offset) + { + this->_xsd_fragment_offset_.set (fragment_offset); + } + + void bundle_attributes:: + fragment_offset (const fragment_offset::container& fragment_offset) + { + this->_xsd_fragment_offset_ = fragment_offset; + } + + + // link_attributes + // + + const link_attributes::key_value_pair::container& link_attributes:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + link_attributes::key_value_pair::container& link_attributes:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void link_attributes:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const link_attributes::type::container& link_attributes:: + type () const + { + return this->_xsd_type_; + } + + link_attributes::type::container& link_attributes:: + type () + { + return this->_xsd_type_; + } + + void link_attributes:: + type (const type::type_& type) + { + this->_xsd_type_.set (type); + } + + void link_attributes:: + type (const type::container& type) + { + this->_xsd_type_ = type; + } + + void link_attributes:: + type (::std::auto_ptr< type::type_ > type) + { + this->_xsd_type_.set (type); + } + + const link_attributes::state::container& link_attributes:: + state () const + { + return this->_xsd_state_; + } + + link_attributes::state::container& link_attributes:: + state () + { + return this->_xsd_state_; + } + + void link_attributes:: + state (const state::type& state) + { + this->_xsd_state_.set (state); + } + + void link_attributes:: + state (const state::container& state) + { + this->_xsd_state_ = state; + } + + void link_attributes:: + state (::std::auto_ptr< state::type > state) + { + this->_xsd_state_.set (state); + } + + const link_attributes::peer_eid::container& link_attributes:: + peer_eid () const + { + return this->_xsd_peer_eid_; + } + + link_attributes::peer_eid::container& link_attributes:: + peer_eid () + { + return this->_xsd_peer_eid_; + } + + void link_attributes:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void link_attributes:: + peer_eid (const peer_eid::container& peer_eid) + { + this->_xsd_peer_eid_ = peer_eid; + } + + void link_attributes:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + const link_attributes::is_reachable::container& link_attributes:: + is_reachable () const + { + return this->_xsd_is_reachable_; + } + + link_attributes::is_reachable::container& link_attributes:: + is_reachable () + { + return this->_xsd_is_reachable_; + } + + void link_attributes:: + is_reachable (const is_reachable::type& is_reachable) + { + this->_xsd_is_reachable_.set (is_reachable); + } + + void link_attributes:: + is_reachable (const is_reachable::container& is_reachable) + { + this->_xsd_is_reachable_ = is_reachable; + } + + const link_attributes::is_usable::container& link_attributes:: + is_usable () const + { + return this->_xsd_is_usable_; + } + + link_attributes::is_usable::container& link_attributes:: + is_usable () + { + return this->_xsd_is_usable_; + } + + void link_attributes:: + is_usable (const is_usable::type& is_usable) + { + this->_xsd_is_usable_.set (is_usable); + } + + void link_attributes:: + is_usable (const is_usable::container& is_usable) + { + this->_xsd_is_usable_ = is_usable; + } + + const link_attributes::how_reliable::container& link_attributes:: + how_reliable () const + { + return this->_xsd_how_reliable_; + } + + link_attributes::how_reliable::container& link_attributes:: + how_reliable () + { + return this->_xsd_how_reliable_; + } + + void link_attributes:: + how_reliable (const how_reliable::type& how_reliable) + { + this->_xsd_how_reliable_.set (how_reliable); + } + + void link_attributes:: + how_reliable (const how_reliable::container& how_reliable) + { + this->_xsd_how_reliable_ = how_reliable; + } + + void link_attributes:: + how_reliable (::std::auto_ptr< how_reliable::type > how_reliable) + { + this->_xsd_how_reliable_.set (how_reliable); + } + + const link_attributes::how_available::container& link_attributes:: + how_available () const + { + return this->_xsd_how_available_; + } + + link_attributes::how_available::container& link_attributes:: + how_available () + { + return this->_xsd_how_available_; + } + + void link_attributes:: + how_available (const how_available::type& how_available) + { + this->_xsd_how_available_.set (how_available); + } + + void link_attributes:: + how_available (const how_available::container& how_available) + { + this->_xsd_how_available_ = how_available; + } + + void link_attributes:: + how_available (::std::auto_ptr< how_available::type > how_available) + { + this->_xsd_how_available_.set (how_available); + } + + const link_attributes::reactive_fragment::container& link_attributes:: + reactive_fragment () const + { + return this->_xsd_reactive_fragment_; + } + + link_attributes::reactive_fragment::container& link_attributes:: + reactive_fragment () + { + return this->_xsd_reactive_fragment_; + } + + void link_attributes:: + reactive_fragment (const reactive_fragment::type& reactive_fragment) + { + this->_xsd_reactive_fragment_.set (reactive_fragment); + } + + void link_attributes:: + reactive_fragment (const reactive_fragment::container& reactive_fragment) + { + this->_xsd_reactive_fragment_ = reactive_fragment; + } + + const link_attributes::nexthop::container& link_attributes:: + nexthop () const + { + return this->_xsd_nexthop_; + } + + link_attributes::nexthop::container& link_attributes:: + nexthop () + { + return this->_xsd_nexthop_; + } + + void link_attributes:: + nexthop (const nexthop::type& nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + void link_attributes:: + nexthop (const nexthop::container& nexthop) + { + this->_xsd_nexthop_ = nexthop; + } + + void link_attributes:: + nexthop (::std::auto_ptr< nexthop::type > nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + const link_attributes::cla_name::container& link_attributes:: + cla_name () const + { + return this->_xsd_cla_name_; + } + + link_attributes::cla_name::container& link_attributes:: + cla_name () + { + return this->_xsd_cla_name_; + } + + void link_attributes:: + cla_name (const cla_name::type& cla_name) + { + this->_xsd_cla_name_.set (cla_name); + } + + void link_attributes:: + cla_name (const cla_name::container& cla_name) + { + this->_xsd_cla_name_ = cla_name; + } + + void link_attributes:: + cla_name (::std::auto_ptr< cla_name::type > cla_name) + { + this->_xsd_cla_name_.set (cla_name); + } + + const link_attributes::high_water_mark::container& link_attributes:: + high_water_mark () const + { + return this->_xsd_high_water_mark_; + } + + link_attributes::high_water_mark::container& link_attributes:: + high_water_mark () + { + return this->_xsd_high_water_mark_; + } + + void link_attributes:: + high_water_mark (const high_water_mark::type& high_water_mark) + { + this->_xsd_high_water_mark_.set (high_water_mark); + } + + void link_attributes:: + high_water_mark (const high_water_mark::container& high_water_mark) + { + this->_xsd_high_water_mark_ = high_water_mark; + } + + const link_attributes::low_water_mark::container& link_attributes:: + low_water_mark () const + { + return this->_xsd_low_water_mark_; + } + + link_attributes::low_water_mark::container& link_attributes:: + low_water_mark () + { + return this->_xsd_low_water_mark_; + } + + void link_attributes:: + low_water_mark (const low_water_mark::type& low_water_mark) + { + this->_xsd_low_water_mark_.set (low_water_mark); + } + + void link_attributes:: + low_water_mark (const low_water_mark::container& low_water_mark) + { + this->_xsd_low_water_mark_ = low_water_mark; + } + + + // link_config_parameters + // + + const link_config_parameters::key_value_pair::container& link_config_parameters:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + link_config_parameters::key_value_pair::container& link_config_parameters:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void link_config_parameters:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const link_config_parameters::is_usable::container& link_config_parameters:: + is_usable () const + { + return this->_xsd_is_usable_; + } + + link_config_parameters::is_usable::container& link_config_parameters:: + is_usable () + { + return this->_xsd_is_usable_; + } + + void link_config_parameters:: + is_usable (const is_usable::type& is_usable) + { + this->_xsd_is_usable_.set (is_usable); + } + + void link_config_parameters:: + is_usable (const is_usable::container& is_usable) + { + this->_xsd_is_usable_ = is_usable; + } + + const link_config_parameters::reactive_fragment::container& link_config_parameters:: + reactive_fragment () const + { + return this->_xsd_reactive_fragment_; + } + + link_config_parameters::reactive_fragment::container& link_config_parameters:: + reactive_fragment () + { + return this->_xsd_reactive_fragment_; + } + + void link_config_parameters:: + reactive_fragment (const reactive_fragment::type& reactive_fragment) + { + this->_xsd_reactive_fragment_.set (reactive_fragment); + } + + void link_config_parameters:: + reactive_fragment (const reactive_fragment::container& reactive_fragment) + { + this->_xsd_reactive_fragment_ = reactive_fragment; + } + + const link_config_parameters::nexthop::container& link_config_parameters:: + nexthop () const + { + return this->_xsd_nexthop_; + } + + link_config_parameters::nexthop::container& link_config_parameters:: + nexthop () + { + return this->_xsd_nexthop_; + } + + void link_config_parameters:: + nexthop (const nexthop::type& nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + void link_config_parameters:: + nexthop (const nexthop::container& nexthop) + { + this->_xsd_nexthop_ = nexthop; + } + + void link_config_parameters:: + nexthop (::std::auto_ptr< nexthop::type > nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + + // contact_attributes + // + + const contact_attributes::start_time::type& contact_attributes:: + start_time () const + { + return this->_xsd_start_time_.get (); + } + + contact_attributes::start_time::type& contact_attributes:: + start_time () + { + return this->_xsd_start_time_.get (); + } + + void contact_attributes:: + start_time (const start_time::type& start_time) + { + this->_xsd_start_time_.set (start_time); + } + + const contact_attributes::duration::type& contact_attributes:: + duration () const + { + return this->_xsd_duration_.get (); + } + + contact_attributes::duration::type& contact_attributes:: + duration () + { + return this->_xsd_duration_.get (); + } + + void contact_attributes:: + duration (const duration::type& duration) + { + this->_xsd_duration_.set (duration); + } + + const contact_attributes::bps::type& contact_attributes:: + bps () const + { + return this->_xsd_bps_.get (); + } + + contact_attributes::bps::type& contact_attributes:: + bps () + { + return this->_xsd_bps_.get (); + } + + void contact_attributes:: + bps (const bps::type& bps) + { + this->_xsd_bps_.set (bps); + } + + const contact_attributes::latency::type& contact_attributes:: + latency () const + { + return this->_xsd_latency_.get (); + } + + contact_attributes::latency::type& contact_attributes:: + latency () + { + return this->_xsd_latency_.get (); + } + + void contact_attributes:: + latency (const latency::type& latency) + { + this->_xsd_latency_.set (latency); + } + + const contact_attributes::packet_loss_prob::type& contact_attributes:: + packet_loss_prob () const + { + return this->_xsd_packet_loss_prob_.get (); + } + + contact_attributes::packet_loss_prob::type& contact_attributes:: + packet_loss_prob () + { + return this->_xsd_packet_loss_prob_.get (); + } + + void contact_attributes:: + packet_loss_prob (const packet_loss_prob::type& packet_loss_prob) + { + this->_xsd_packet_loss_prob_.set (packet_loss_prob); + } + + void contact_attributes:: + packet_loss_prob (::std::auto_ptr< packet_loss_prob::type > packet_loss_prob) + { + this->_xsd_packet_loss_prob_.set (packet_loss_prob); + } + + + // cla_add_request + // + + const cla_add_request::name::type& cla_add_request:: + name () const + { + return this->_xsd_name_.get (); + } + + cla_add_request::name::type& cla_add_request:: + name () + { + return this->_xsd_name_.get (); + } + + void cla_add_request:: + name (const name::type& name) + { + this->_xsd_name_.set (name); + } + + void cla_add_request:: + name (::std::auto_ptr< name::type > name) + { + this->_xsd_name_.set (name); + } + + + // cla_delete_request + // + + const cla_delete_request::name::type& cla_delete_request:: + name () const + { + return this->_xsd_name_.get (); + } + + cla_delete_request::name::type& cla_delete_request:: + name () + { + return this->_xsd_name_.get (); + } + + void cla_delete_request:: + name (const name::type& name) + { + this->_xsd_name_.set (name); + } + + void cla_delete_request:: + name (::std::auto_ptr< name::type > name) + { + this->_xsd_name_.set (name); + } + + + // cla_set_params_request + // + + const cla_set_params_request::key_value_pair::container& cla_set_params_request:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + cla_set_params_request::key_value_pair::container& cla_set_params_request:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void cla_set_params_request:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const cla_set_params_request::local_eid::container& cla_set_params_request:: + local_eid () const + { + return this->_xsd_local_eid_; + } + + cla_set_params_request::local_eid::container& cla_set_params_request:: + local_eid () + { + return this->_xsd_local_eid_; + } + + void cla_set_params_request:: + local_eid (const local_eid::type& local_eid) + { + this->_xsd_local_eid_.set (local_eid); + } + + void cla_set_params_request:: + local_eid (const local_eid::container& local_eid) + { + this->_xsd_local_eid_ = local_eid; + } + + void cla_set_params_request:: + local_eid (::std::auto_ptr< local_eid::type > local_eid) + { + this->_xsd_local_eid_.set (local_eid); + } + + const cla_set_params_request::create_discovered_links::container& cla_set_params_request:: + create_discovered_links () const + { + return this->_xsd_create_discovered_links_; + } + + cla_set_params_request::create_discovered_links::container& cla_set_params_request:: + create_discovered_links () + { + return this->_xsd_create_discovered_links_; + } + + void cla_set_params_request:: + create_discovered_links (const create_discovered_links::type& create_discovered_links) + { + this->_xsd_create_discovered_links_.set (create_discovered_links); + } + + void cla_set_params_request:: + create_discovered_links (const create_discovered_links::container& create_discovered_links) + { + this->_xsd_create_discovered_links_ = create_discovered_links; + } + + const cla_set_params_request::bundle_pass_method::container& cla_set_params_request:: + bundle_pass_method () const + { + return this->_xsd_bundle_pass_method_; + } + + cla_set_params_request::bundle_pass_method::container& cla_set_params_request:: + bundle_pass_method () + { + return this->_xsd_bundle_pass_method_; + } + + void cla_set_params_request:: + bundle_pass_method (const bundle_pass_method::type& bundle_pass_method) + { + this->_xsd_bundle_pass_method_.set (bundle_pass_method); + } + + void cla_set_params_request:: + bundle_pass_method (const bundle_pass_method::container& bundle_pass_method) + { + this->_xsd_bundle_pass_method_ = bundle_pass_method; + } + + void cla_set_params_request:: + bundle_pass_method (::std::auto_ptr< bundle_pass_method::type > bundle_pass_method) + { + this->_xsd_bundle_pass_method_.set (bundle_pass_method); + } + + const cla_set_params_request::reactive_fragment_enabled::container& cla_set_params_request:: + reactive_fragment_enabled () const + { + return this->_xsd_reactive_fragment_enabled_; + } + + cla_set_params_request::reactive_fragment_enabled::container& cla_set_params_request:: + reactive_fragment_enabled () + { + return this->_xsd_reactive_fragment_enabled_; + } + + void cla_set_params_request:: + reactive_fragment_enabled (const reactive_fragment_enabled::type& reactive_fragment_enabled) + { + this->_xsd_reactive_fragment_enabled_.set (reactive_fragment_enabled); + } + + void cla_set_params_request:: + reactive_fragment_enabled (const reactive_fragment_enabled::container& reactive_fragment_enabled) + { + this->_xsd_reactive_fragment_enabled_ = reactive_fragment_enabled; + } + + + // cla_params_set_event + // + + + // interface_set_defaults_request + // + + const interface_set_defaults_request::key_value_pair::container& interface_set_defaults_request:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + interface_set_defaults_request::key_value_pair::container& interface_set_defaults_request:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void interface_set_defaults_request:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + + // interface_create_request + // + + const interface_create_request::key_value_pair::container& interface_create_request:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + interface_create_request::key_value_pair::container& interface_create_request:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void interface_create_request:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const interface_create_request::interface_name::type& interface_create_request:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + interface_create_request::interface_name::type& interface_create_request:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void interface_create_request:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void interface_create_request:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + + // interface_created_event + // + + const interface_created_event::interface_name::type& interface_created_event:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + interface_created_event::interface_name::type& interface_created_event:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void interface_created_event:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void interface_created_event:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + + // interface_reconfigure_request + // + + const interface_reconfigure_request::key_value_pair::container& interface_reconfigure_request:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + interface_reconfigure_request::key_value_pair::container& interface_reconfigure_request:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void interface_reconfigure_request:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const interface_reconfigure_request::interface_name::type& interface_reconfigure_request:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + interface_reconfigure_request::interface_name::type& interface_reconfigure_request:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void interface_reconfigure_request:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void interface_reconfigure_request:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + const interface_reconfigure_request::up::container& interface_reconfigure_request:: + up () const + { + return this->_xsd_up_; + } + + interface_reconfigure_request::up::container& interface_reconfigure_request:: + up () + { + return this->_xsd_up_; + } + + void interface_reconfigure_request:: + up (const up::type& up) + { + this->_xsd_up_.set (up); + } + + void interface_reconfigure_request:: + up (const up::container& up) + { + this->_xsd_up_ = up; + } + + const interface_reconfigure_request::discovery::container& interface_reconfigure_request:: + discovery () const + { + return this->_xsd_discovery_; + } + + interface_reconfigure_request::discovery::container& interface_reconfigure_request:: + discovery () + { + return this->_xsd_discovery_; + } + + void interface_reconfigure_request:: + discovery (const discovery::type& discovery) + { + this->_xsd_discovery_.set (discovery); + } + + void interface_reconfigure_request:: + discovery (const discovery::container& discovery) + { + this->_xsd_discovery_ = discovery; + } + + + // interface_reconfigured_event + // + + const interface_reconfigured_event::interface_name::type& interface_reconfigured_event:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + interface_reconfigured_event::interface_name::type& interface_reconfigured_event:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void interface_reconfigured_event:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void interface_reconfigured_event:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + + // interface_destroy_request + // + + const interface_destroy_request::interface_name::type& interface_destroy_request:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + interface_destroy_request::interface_name::type& interface_destroy_request:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void interface_destroy_request:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void interface_destroy_request:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + + // eid_reachable_event + // + + const eid_reachable_event::interface_name::type& eid_reachable_event:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + eid_reachable_event::interface_name::type& eid_reachable_event:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void eid_reachable_event:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void eid_reachable_event:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + const eid_reachable_event::peer_eid::type& eid_reachable_event:: + peer_eid () const + { + return this->_xsd_peer_eid_.get (); + } + + eid_reachable_event::peer_eid::type& eid_reachable_event:: + peer_eid () + { + return this->_xsd_peer_eid_.get (); + } + + void eid_reachable_event:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void eid_reachable_event:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // link_set_defaults_request + // + + const link_set_defaults_request::link_config_parameters::type& link_set_defaults_request:: + link_config_parameters () const + { + return this->_xsd_link_config_parameters_.get (); + } + + link_set_defaults_request::link_config_parameters::type& link_set_defaults_request:: + link_config_parameters () + { + return this->_xsd_link_config_parameters_.get (); + } + + void link_set_defaults_request:: + link_config_parameters (const link_config_parameters::type& link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + void link_set_defaults_request:: + link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + + // link_create_request + // + + const link_create_request::link_config_parameters::type& link_create_request:: + link_config_parameters () const + { + return this->_xsd_link_config_parameters_.get (); + } + + link_create_request::link_config_parameters::type& link_create_request:: + link_config_parameters () + { + return this->_xsd_link_config_parameters_.get (); + } + + void link_create_request:: + link_config_parameters (const link_config_parameters::type& link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + void link_create_request:: + link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + const link_create_request::link_name::type& link_create_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_create_request::link_name::type& link_create_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_create_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_create_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_create_request::type::type_& link_create_request:: + type () const + { + return this->_xsd_type_.get (); + } + + link_create_request::type::type_& link_create_request:: + type () + { + return this->_xsd_type_.get (); + } + + void link_create_request:: + type (const type::type_& type) + { + this->_xsd_type_.set (type); + } + + void link_create_request:: + type (::std::auto_ptr< type::type_ > type) + { + this->_xsd_type_.set (type); + } + + const link_create_request::peer_eid::container& link_create_request:: + peer_eid () const + { + return this->_xsd_peer_eid_; + } + + link_create_request::peer_eid::container& link_create_request:: + peer_eid () + { + return this->_xsd_peer_eid_; + } + + void link_create_request:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void link_create_request:: + peer_eid (const peer_eid::container& peer_eid) + { + this->_xsd_peer_eid_ = peer_eid; + } + + void link_create_request:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // link_created_event + // + + const link_created_event::link_attributes::type& link_created_event:: + link_attributes () const + { + return this->_xsd_link_attributes_.get (); + } + + link_created_event::link_attributes::type& link_created_event:: + link_attributes () + { + return this->_xsd_link_attributes_.get (); + } + + void link_created_event:: + link_attributes (const link_attributes::type& link_attributes) + { + this->_xsd_link_attributes_.set (link_attributes); + } + + void link_created_event:: + link_attributes (::std::auto_ptr< link_attributes::type > link_attributes) + { + this->_xsd_link_attributes_.set (link_attributes); + } + + const link_created_event::link_name::type& link_created_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_created_event::link_name::type& link_created_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_created_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_created_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_created_event::reason::type& link_created_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_created_event::reason::type& link_created_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_created_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_created_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_open_request + // + + const link_open_request::link_name::type& link_open_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_open_request::link_name::type& link_open_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_open_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_open_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_opened_event + // + + const link_opened_event::contact_attributes::type& link_opened_event:: + contact_attributes () const + { + return this->_xsd_contact_attributes_.get (); + } + + link_opened_event::contact_attributes::type& link_opened_event:: + contact_attributes () + { + return this->_xsd_contact_attributes_.get (); + } + + void link_opened_event:: + contact_attributes (const contact_attributes::type& contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + void link_opened_event:: + contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + const link_opened_event::link_name::type& link_opened_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_opened_event::link_name::type& link_opened_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_opened_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_opened_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_close_request + // + + const link_close_request::link_name::type& link_close_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_close_request::link_name::type& link_close_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_close_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_close_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_closed_event + // + + const link_closed_event::contact_attributes::type& link_closed_event:: + contact_attributes () const + { + return this->_xsd_contact_attributes_.get (); + } + + link_closed_event::contact_attributes::type& link_closed_event:: + contact_attributes () + { + return this->_xsd_contact_attributes_.get (); + } + + void link_closed_event:: + contact_attributes (const contact_attributes::type& contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + void link_closed_event:: + contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + const link_closed_event::link_name::type& link_closed_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_closed_event::link_name::type& link_closed_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_closed_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_closed_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_state_changed_event + // + + const link_state_changed_event::link_name::type& link_state_changed_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_state_changed_event::link_name::type& link_state_changed_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_state_changed_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_state_changed_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_state_changed_event::new_state::type& link_state_changed_event:: + new_state () const + { + return this->_xsd_new_state_.get (); + } + + link_state_changed_event::new_state::type& link_state_changed_event:: + new_state () + { + return this->_xsd_new_state_.get (); + } + + void link_state_changed_event:: + new_state (const new_state::type& new_state) + { + this->_xsd_new_state_.set (new_state); + } + + void link_state_changed_event:: + new_state (::std::auto_ptr< new_state::type > new_state) + { + this->_xsd_new_state_.set (new_state); + } + + const link_state_changed_event::reason::type& link_state_changed_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_state_changed_event::reason::type& link_state_changed_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_state_changed_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_state_changed_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_reconfigure_request + // + + const link_reconfigure_request::link_config_parameters::type& link_reconfigure_request:: + link_config_parameters () const + { + return this->_xsd_link_config_parameters_.get (); + } + + link_reconfigure_request::link_config_parameters::type& link_reconfigure_request:: + link_config_parameters () + { + return this->_xsd_link_config_parameters_.get (); + } + + void link_reconfigure_request:: + link_config_parameters (const link_config_parameters::type& link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + void link_reconfigure_request:: + link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + const link_reconfigure_request::link_name::type& link_reconfigure_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_reconfigure_request::link_name::type& link_reconfigure_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_reconfigure_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_reconfigure_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_delete_request + // + + const link_delete_request::link_name::type& link_delete_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_delete_request::link_name::type& link_delete_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_delete_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_delete_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // link_deleted_event + // + + const link_deleted_event::link_name::type& link_deleted_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_deleted_event::link_name::type& link_deleted_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_deleted_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_deleted_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_deleted_event::reason::type& link_deleted_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_deleted_event::reason::type& link_deleted_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_deleted_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_deleted_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_attribute_changed_event + // + + const link_attribute_changed_event::link_attributes::type& link_attribute_changed_event:: + link_attributes () const + { + return this->_xsd_link_attributes_.get (); + } + + link_attribute_changed_event::link_attributes::type& link_attribute_changed_event:: + link_attributes () + { + return this->_xsd_link_attributes_.get (); + } + + void link_attribute_changed_event:: + link_attributes (const link_attributes::type& link_attributes) + { + this->_xsd_link_attributes_.set (link_attributes); + } + + void link_attribute_changed_event:: + link_attributes (::std::auto_ptr< link_attributes::type > link_attributes) + { + this->_xsd_link_attributes_.set (link_attributes); + } + + const link_attribute_changed_event::link_name::type& link_attribute_changed_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_attribute_changed_event::link_name::type& link_attribute_changed_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_attribute_changed_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_attribute_changed_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_attribute_changed_event::reason::type& link_attribute_changed_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_attribute_changed_event::reason::type& link_attribute_changed_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_attribute_changed_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_attribute_changed_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // contact_attribute_changed_event + // + + const contact_attribute_changed_event::contact_attributes::type& contact_attribute_changed_event:: + contact_attributes () const + { + return this->_xsd_contact_attributes_.get (); + } + + contact_attribute_changed_event::contact_attributes::type& contact_attribute_changed_event:: + contact_attributes () + { + return this->_xsd_contact_attributes_.get (); + } + + void contact_attribute_changed_event:: + contact_attributes (const contact_attributes::type& contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + void contact_attribute_changed_event:: + contact_attributes (::std::auto_ptr< contact_attributes::type > contact_attributes) + { + this->_xsd_contact_attributes_.set (contact_attributes); + } + + const contact_attribute_changed_event::link_name::type& contact_attribute_changed_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + contact_attribute_changed_event::link_name::type& contact_attribute_changed_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void contact_attribute_changed_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void contact_attribute_changed_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const contact_attribute_changed_event::reason::type& contact_attribute_changed_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + contact_attribute_changed_event::reason::type& contact_attribute_changed_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void contact_attribute_changed_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void contact_attribute_changed_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_add_reachable_event + // + + const link_add_reachable_event::link_config_parameters::type& link_add_reachable_event:: + link_config_parameters () const + { + return this->_xsd_link_config_parameters_.get (); + } + + link_add_reachable_event::link_config_parameters::type& link_add_reachable_event:: + link_config_parameters () + { + return this->_xsd_link_config_parameters_.get (); + } + + void link_add_reachable_event:: + link_config_parameters (const link_config_parameters::type& link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + void link_add_reachable_event:: + link_config_parameters (::std::auto_ptr< link_config_parameters::type > link_config_parameters) + { + this->_xsd_link_config_parameters_.set (link_config_parameters); + } + + const link_add_reachable_event::link_name::type& link_add_reachable_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + link_add_reachable_event::link_name::type& link_add_reachable_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void link_add_reachable_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void link_add_reachable_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const link_add_reachable_event::peer_eid::type& link_add_reachable_event:: + peer_eid () const + { + return this->_xsd_peer_eid_.get (); + } + + link_add_reachable_event::peer_eid::type& link_add_reachable_event:: + peer_eid () + { + return this->_xsd_peer_eid_.get (); + } + + void link_add_reachable_event:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void link_add_reachable_event:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // bundle_send_request + // + + const bundle_send_request::bundle_attributes::type& bundle_send_request:: + bundle_attributes () const + { + return this->_xsd_bundle_attributes_.get (); + } + + bundle_send_request::bundle_attributes::type& bundle_send_request:: + bundle_attributes () + { + return this->_xsd_bundle_attributes_.get (); + } + + void bundle_send_request:: + bundle_attributes (const bundle_attributes::type& bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + void bundle_send_request:: + bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + const bundle_send_request::link_name::type& bundle_send_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + bundle_send_request::link_name::type& bundle_send_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void bundle_send_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void bundle_send_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const bundle_send_request::location::type& bundle_send_request:: + location () const + { + return this->_xsd_location_.get (); + } + + bundle_send_request::location::type& bundle_send_request:: + location () + { + return this->_xsd_location_.get (); + } + + void bundle_send_request:: + location (const location::type& location) + { + this->_xsd_location_.set (location); + } + + void bundle_send_request:: + location (::std::auto_ptr< location::type > location) + { + this->_xsd_location_.set (location); + } + + + // bundle_receive_started_event + // + + const bundle_receive_started_event::location::type& bundle_receive_started_event:: + location () const + { + return this->_xsd_location_.get (); + } + + bundle_receive_started_event::location::type& bundle_receive_started_event:: + location () + { + return this->_xsd_location_.get (); + } + + void bundle_receive_started_event:: + location (const location::type& location) + { + this->_xsd_location_.set (location); + } + + void bundle_receive_started_event:: + location (::std::auto_ptr< location::type > location) + { + this->_xsd_location_.set (location); + } + + const bundle_receive_started_event::peer_eid::container& bundle_receive_started_event:: + peer_eid () const + { + return this->_xsd_peer_eid_; + } + + bundle_receive_started_event::peer_eid::container& bundle_receive_started_event:: + peer_eid () + { + return this->_xsd_peer_eid_; + } + + void bundle_receive_started_event:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void bundle_receive_started_event:: + peer_eid (const peer_eid::container& peer_eid) + { + this->_xsd_peer_eid_ = peer_eid; + } + + void bundle_receive_started_event:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // bundle_received_event + // + + const bundle_received_event::location::type& bundle_received_event:: + location () const + { + return this->_xsd_location_.get (); + } + + bundle_received_event::location::type& bundle_received_event:: + location () + { + return this->_xsd_location_.get (); + } + + void bundle_received_event:: + location (const location::type& location) + { + this->_xsd_location_.set (location); + } + + void bundle_received_event:: + location (::std::auto_ptr< location::type > location) + { + this->_xsd_location_.set (location); + } + + const bundle_received_event::bytes_received::type& bundle_received_event:: + bytes_received () const + { + return this->_xsd_bytes_received_.get (); + } + + bundle_received_event::bytes_received::type& bundle_received_event:: + bytes_received () + { + return this->_xsd_bytes_received_.get (); + } + + void bundle_received_event:: + bytes_received (const bytes_received::type& bytes_received) + { + this->_xsd_bytes_received_.set (bytes_received); + } + + const bundle_received_event::peer_eid::container& bundle_received_event:: + peer_eid () const + { + return this->_xsd_peer_eid_; + } + + bundle_received_event::peer_eid::container& bundle_received_event:: + peer_eid () + { + return this->_xsd_peer_eid_; + } + + void bundle_received_event:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void bundle_received_event:: + peer_eid (const peer_eid::container& peer_eid) + { + this->_xsd_peer_eid_ = peer_eid; + } + + void bundle_received_event:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // bundle_transmitted_event + // + + const bundle_transmitted_event::bundle_attributes::type& bundle_transmitted_event:: + bundle_attributes () const + { + return this->_xsd_bundle_attributes_.get (); + } + + bundle_transmitted_event::bundle_attributes::type& bundle_transmitted_event:: + bundle_attributes () + { + return this->_xsd_bundle_attributes_.get (); + } + + void bundle_transmitted_event:: + bundle_attributes (const bundle_attributes::type& bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + void bundle_transmitted_event:: + bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + const bundle_transmitted_event::link_name::type& bundle_transmitted_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + bundle_transmitted_event::link_name::type& bundle_transmitted_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void bundle_transmitted_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void bundle_transmitted_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const bundle_transmitted_event::bytes_sent::type& bundle_transmitted_event:: + bytes_sent () const + { + return this->_xsd_bytes_sent_.get (); + } + + bundle_transmitted_event::bytes_sent::type& bundle_transmitted_event:: + bytes_sent () + { + return this->_xsd_bytes_sent_.get (); + } + + void bundle_transmitted_event:: + bytes_sent (const bytes_sent::type& bytes_sent) + { + this->_xsd_bytes_sent_.set (bytes_sent); + } + + const bundle_transmitted_event::reliably_sent::type& bundle_transmitted_event:: + reliably_sent () const + { + return this->_xsd_reliably_sent_.get (); + } + + bundle_transmitted_event::reliably_sent::type& bundle_transmitted_event:: + reliably_sent () + { + return this->_xsd_reliably_sent_.get (); + } + + void bundle_transmitted_event:: + reliably_sent (const reliably_sent::type& reliably_sent) + { + this->_xsd_reliably_sent_.set (reliably_sent); + } + + + // bundle_cancel_request + // + + const bundle_cancel_request::bundle_attributes::type& bundle_cancel_request:: + bundle_attributes () const + { + return this->_xsd_bundle_attributes_.get (); + } + + bundle_cancel_request::bundle_attributes::type& bundle_cancel_request:: + bundle_attributes () + { + return this->_xsd_bundle_attributes_.get (); + } + + void bundle_cancel_request:: + bundle_attributes (const bundle_attributes::type& bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + void bundle_cancel_request:: + bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + const bundle_cancel_request::link_name::type& bundle_cancel_request:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + bundle_cancel_request::link_name::type& bundle_cancel_request:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void bundle_cancel_request:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void bundle_cancel_request:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // bundle_canceled_event + // + + const bundle_canceled_event::bundle_attributes::type& bundle_canceled_event:: + bundle_attributes () const + { + return this->_xsd_bundle_attributes_.get (); + } + + bundle_canceled_event::bundle_attributes::type& bundle_canceled_event:: + bundle_attributes () + { + return this->_xsd_bundle_attributes_.get (); + } + + void bundle_canceled_event:: + bundle_attributes (const bundle_attributes::type& bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + void bundle_canceled_event:: + bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + const bundle_canceled_event::link_name::type& bundle_canceled_event:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + bundle_canceled_event::link_name::type& bundle_canceled_event:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void bundle_canceled_event:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void bundle_canceled_event:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // query_bundle_queued + // + + const query_bundle_queued::bundle_attributes::type& query_bundle_queued:: + bundle_attributes () const + { + return this->_xsd_bundle_attributes_.get (); + } + + query_bundle_queued::bundle_attributes::type& query_bundle_queued:: + bundle_attributes () + { + return this->_xsd_bundle_attributes_.get (); + } + + void query_bundle_queued:: + bundle_attributes (const bundle_attributes::type& bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + void query_bundle_queued:: + bundle_attributes (::std::auto_ptr< bundle_attributes::type > bundle_attributes) + { + this->_xsd_bundle_attributes_.set (bundle_attributes); + } + + const query_bundle_queued::query_id::type& query_bundle_queued:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + query_bundle_queued::query_id::type& query_bundle_queued:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void query_bundle_queued:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void query_bundle_queued:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const query_bundle_queued::link_name::type& query_bundle_queued:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + query_bundle_queued::link_name::type& query_bundle_queued:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void query_bundle_queued:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void query_bundle_queued:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + + // report_bundle_queued + // + + const report_bundle_queued::query_id::type& report_bundle_queued:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + report_bundle_queued::query_id::type& report_bundle_queued:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void report_bundle_queued:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void report_bundle_queued:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const report_bundle_queued::is_queued::type& report_bundle_queued:: + is_queued () const + { + return this->_xsd_is_queued_.get (); + } + + report_bundle_queued::is_queued::type& report_bundle_queued:: + is_queued () + { + return this->_xsd_is_queued_.get (); + } + + void report_bundle_queued:: + is_queued (const is_queued::type& is_queued) + { + this->_xsd_is_queued_.set (is_queued); + } + + + // query_eid_reachable + // + + const query_eid_reachable::query_id::type& query_eid_reachable:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + query_eid_reachable::query_id::type& query_eid_reachable:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void query_eid_reachable:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void query_eid_reachable:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const query_eid_reachable::interface_name::type& query_eid_reachable:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + query_eid_reachable::interface_name::type& query_eid_reachable:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void query_eid_reachable:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void query_eid_reachable:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + const query_eid_reachable::peer_eid::type& query_eid_reachable:: + peer_eid () const + { + return this->_xsd_peer_eid_.get (); + } + + query_eid_reachable::peer_eid::type& query_eid_reachable:: + peer_eid () + { + return this->_xsd_peer_eid_.get (); + } + + void query_eid_reachable:: + peer_eid (const peer_eid::type& peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + void query_eid_reachable:: + peer_eid (::std::auto_ptr< peer_eid::type > peer_eid) + { + this->_xsd_peer_eid_.set (peer_eid); + } + + + // report_eid_reachable + // + + const report_eid_reachable::query_id::type& report_eid_reachable:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + report_eid_reachable::query_id::type& report_eid_reachable:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void report_eid_reachable:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void report_eid_reachable:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const report_eid_reachable::is_reachable::type& report_eid_reachable:: + is_reachable () const + { + return this->_xsd_is_reachable_.get (); + } + + report_eid_reachable::is_reachable::type& report_eid_reachable:: + is_reachable () + { + return this->_xsd_is_reachable_.get (); + } + + void report_eid_reachable:: + is_reachable (const is_reachable::type& is_reachable) + { + this->_xsd_is_reachable_.set (is_reachable); + } + + + // query_link_attributes + // + + const query_link_attributes::attribute_name::container& query_link_attributes:: + attribute_name () const + { + return this->_xsd_attribute_name_; + } + + query_link_attributes::attribute_name::container& query_link_attributes:: + attribute_name () + { + return this->_xsd_attribute_name_; + } + + void query_link_attributes:: + attribute_name (const attribute_name::container& attribute_name) + { + this->_xsd_attribute_name_ = attribute_name; + } + + const query_link_attributes::link_name::type& query_link_attributes:: + link_name () const + { + return this->_xsd_link_name_.get (); + } + + query_link_attributes::link_name::type& query_link_attributes:: + link_name () + { + return this->_xsd_link_name_.get (); + } + + void query_link_attributes:: + link_name (const link_name::type& link_name) + { + this->_xsd_link_name_.set (link_name); + } + + void query_link_attributes:: + link_name (::std::auto_ptr< link_name::type > link_name) + { + this->_xsd_link_name_.set (link_name); + } + + const query_link_attributes::query_id::type& query_link_attributes:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + query_link_attributes::query_id::type& query_link_attributes:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void query_link_attributes:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void query_link_attributes:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // report_link_attributes + // + + const report_link_attributes::key_value_pair::container& report_link_attributes:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + report_link_attributes::key_value_pair::container& report_link_attributes:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void report_link_attributes:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const report_link_attributes::query_id::type& report_link_attributes:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + report_link_attributes::query_id::type& report_link_attributes:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void report_link_attributes:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void report_link_attributes:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // query_interface_attributes + // + + const query_interface_attributes::attribute_name::container& query_interface_attributes:: + attribute_name () const + { + return this->_xsd_attribute_name_; + } + + query_interface_attributes::attribute_name::container& query_interface_attributes:: + attribute_name () + { + return this->_xsd_attribute_name_; + } + + void query_interface_attributes:: + attribute_name (const attribute_name::container& attribute_name) + { + this->_xsd_attribute_name_ = attribute_name; + } + + const query_interface_attributes::interface_name::type& query_interface_attributes:: + interface_name () const + { + return this->_xsd_interface_name_.get (); + } + + query_interface_attributes::interface_name::type& query_interface_attributes:: + interface_name () + { + return this->_xsd_interface_name_.get (); + } + + void query_interface_attributes:: + interface_name (const interface_name::type& interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + void query_interface_attributes:: + interface_name (::std::auto_ptr< interface_name::type > interface_name) + { + this->_xsd_interface_name_.set (interface_name); + } + + const query_interface_attributes::query_id::type& query_interface_attributes:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + query_interface_attributes::query_id::type& query_interface_attributes:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void query_interface_attributes:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void query_interface_attributes:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // report_interface_attributes + // + + const report_interface_attributes::key_value_pair::container& report_interface_attributes:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + report_interface_attributes::key_value_pair::container& report_interface_attributes:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void report_interface_attributes:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const report_interface_attributes::query_id::type& report_interface_attributes:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + report_interface_attributes::query_id::type& report_interface_attributes:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void report_interface_attributes:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void report_interface_attributes:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // query_cla_parameters + // + + const query_cla_parameters::attribute_name::container& query_cla_parameters:: + attribute_name () const + { + return this->_xsd_attribute_name_; + } + + query_cla_parameters::attribute_name::container& query_cla_parameters:: + attribute_name () + { + return this->_xsd_attribute_name_; + } + + void query_cla_parameters:: + attribute_name (const attribute_name::container& attribute_name) + { + this->_xsd_attribute_name_ = attribute_name; + } + + const query_cla_parameters::query_id::type& query_cla_parameters:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + query_cla_parameters::query_id::type& query_cla_parameters:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void query_cla_parameters:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void query_cla_parameters:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // report_cla_parameters + // + + const report_cla_parameters::key_value_pair::container& report_cla_parameters:: + key_value_pair () const + { + return this->_xsd_key_value_pair_; + } + + report_cla_parameters::key_value_pair::container& report_cla_parameters:: + key_value_pair () + { + return this->_xsd_key_value_pair_; + } + + void report_cla_parameters:: + key_value_pair (const key_value_pair::container& key_value_pair) + { + this->_xsd_key_value_pair_ = key_value_pair; + } + + const report_cla_parameters::query_id::type& report_cla_parameters:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + report_cla_parameters::query_id::type& report_cla_parameters:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void report_cla_parameters:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void report_cla_parameters:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + + // cl_message + // + + const cl_message::cla_add_request::container& cl_message:: + cla_add_request () const + { + return this->_xsd_cla_add_request_; + } + + cl_message::cla_add_request::container& cl_message:: + cla_add_request () + { + return this->_xsd_cla_add_request_; + } + + void cl_message:: + cla_add_request (const cla_add_request::type& cla_add_request) + { + this->_xsd_cla_add_request_.set (cla_add_request); + } + + void cl_message:: + cla_add_request (const cla_add_request::container& cla_add_request) + { + this->_xsd_cla_add_request_ = cla_add_request; + } + + void cl_message:: + cla_add_request (::std::auto_ptr< cla_add_request::type > cla_add_request) + { + this->_xsd_cla_add_request_.set (cla_add_request); + } + + const cl_message::cla_delete_request::container& cl_message:: + cla_delete_request () const + { + return this->_xsd_cla_delete_request_; + } + + cl_message::cla_delete_request::container& cl_message:: + cla_delete_request () + { + return this->_xsd_cla_delete_request_; + } + + void cl_message:: + cla_delete_request (const cla_delete_request::type& cla_delete_request) + { + this->_xsd_cla_delete_request_.set (cla_delete_request); + } + + void cl_message:: + cla_delete_request (const cla_delete_request::container& cla_delete_request) + { + this->_xsd_cla_delete_request_ = cla_delete_request; + } + + void cl_message:: + cla_delete_request (::std::auto_ptr< cla_delete_request::type > cla_delete_request) + { + this->_xsd_cla_delete_request_.set (cla_delete_request); + } + + const cl_message::cla_set_params_request::container& cl_message:: + cla_set_params_request () const + { + return this->_xsd_cla_set_params_request_; + } + + cl_message::cla_set_params_request::container& cl_message:: + cla_set_params_request () + { + return this->_xsd_cla_set_params_request_; + } + + void cl_message:: + cla_set_params_request (const cla_set_params_request::type& cla_set_params_request) + { + this->_xsd_cla_set_params_request_.set (cla_set_params_request); + } + + void cl_message:: + cla_set_params_request (const cla_set_params_request::container& cla_set_params_request) + { + this->_xsd_cla_set_params_request_ = cla_set_params_request; + } + + void cl_message:: + cla_set_params_request (::std::auto_ptr< cla_set_params_request::type > cla_set_params_request) + { + this->_xsd_cla_set_params_request_.set (cla_set_params_request); + } + + const cl_message::cla_params_set_event::container& cl_message:: + cla_params_set_event () const + { + return this->_xsd_cla_params_set_event_; + } + + cl_message::cla_params_set_event::container& cl_message:: + cla_params_set_event () + { + return this->_xsd_cla_params_set_event_; + } + + void cl_message:: + cla_params_set_event (const cla_params_set_event::type& cla_params_set_event) + { + this->_xsd_cla_params_set_event_.set (cla_params_set_event); + } + + void cl_message:: + cla_params_set_event (const cla_params_set_event::container& cla_params_set_event) + { + this->_xsd_cla_params_set_event_ = cla_params_set_event; + } + + void cl_message:: + cla_params_set_event (::std::auto_ptr< cla_params_set_event::type > cla_params_set_event) + { + this->_xsd_cla_params_set_event_.set (cla_params_set_event); + } + + const cl_message::interface_set_defaults_request::container& cl_message:: + interface_set_defaults_request () const + { + return this->_xsd_interface_set_defaults_request_; + } + + cl_message::interface_set_defaults_request::container& cl_message:: + interface_set_defaults_request () + { + return this->_xsd_interface_set_defaults_request_; + } + + void cl_message:: + interface_set_defaults_request (const interface_set_defaults_request::type& interface_set_defaults_request) + { + this->_xsd_interface_set_defaults_request_.set (interface_set_defaults_request); + } + + void cl_message:: + interface_set_defaults_request (const interface_set_defaults_request::container& interface_set_defaults_request) + { + this->_xsd_interface_set_defaults_request_ = interface_set_defaults_request; + } + + void cl_message:: + interface_set_defaults_request (::std::auto_ptr< interface_set_defaults_request::type > interface_set_defaults_request) + { + this->_xsd_interface_set_defaults_request_.set (interface_set_defaults_request); + } + + const cl_message::interface_create_request::container& cl_message:: + interface_create_request () const + { + return this->_xsd_interface_create_request_; + } + + cl_message::interface_create_request::container& cl_message:: + interface_create_request () + { + return this->_xsd_interface_create_request_; + } + + void cl_message:: + interface_create_request (const interface_create_request::type& interface_create_request) + { + this->_xsd_interface_create_request_.set (interface_create_request); + } + + void cl_message:: + interface_create_request (const interface_create_request::container& interface_create_request) + { + this->_xsd_interface_create_request_ = interface_create_request; + } + + void cl_message:: + interface_create_request (::std::auto_ptr< interface_create_request::type > interface_create_request) + { + this->_xsd_interface_create_request_.set (interface_create_request); + } + + const cl_message::interface_created_event::container& cl_message:: + interface_created_event () const + { + return this->_xsd_interface_created_event_; + } + + cl_message::interface_created_event::container& cl_message:: + interface_created_event () + { + return this->_xsd_interface_created_event_; + } + + void cl_message:: + interface_created_event (const interface_created_event::type& interface_created_event) + { + this->_xsd_interface_created_event_.set (interface_created_event); + } + + void cl_message:: + interface_created_event (const interface_created_event::container& interface_created_event) + { + this->_xsd_interface_created_event_ = interface_created_event; + } + + void cl_message:: + interface_created_event (::std::auto_ptr< interface_created_event::type > interface_created_event) + { + this->_xsd_interface_created_event_.set (interface_created_event); + } + + const cl_message::interface_reconfigure_request::container& cl_message:: + interface_reconfigure_request () const + { + return this->_xsd_interface_reconfigure_request_; + } + + cl_message::interface_reconfigure_request::container& cl_message:: + interface_reconfigure_request () + { + return this->_xsd_interface_reconfigure_request_; + } + + void cl_message:: + interface_reconfigure_request (const interface_reconfigure_request::type& interface_reconfigure_request) + { + this->_xsd_interface_reconfigure_request_.set (interface_reconfigure_request); + } + + void cl_message:: + interface_reconfigure_request (const interface_reconfigure_request::container& interface_reconfigure_request) + { + this->_xsd_interface_reconfigure_request_ = interface_reconfigure_request; + } + + void cl_message:: + interface_reconfigure_request (::std::auto_ptr< interface_reconfigure_request::type > interface_reconfigure_request) + { + this->_xsd_interface_reconfigure_request_.set (interface_reconfigure_request); + } + + const cl_message::interface_reconfigured_event::container& cl_message:: + interface_reconfigured_event () const + { + return this->_xsd_interface_reconfigured_event_; + } + + cl_message::interface_reconfigured_event::container& cl_message:: + interface_reconfigured_event () + { + return this->_xsd_interface_reconfigured_event_; + } + + void cl_message:: + interface_reconfigured_event (const interface_reconfigured_event::type& interface_reconfigured_event) + { + this->_xsd_interface_reconfigured_event_.set (interface_reconfigured_event); + } + + void cl_message:: + interface_reconfigured_event (const interface_reconfigured_event::container& interface_reconfigured_event) + { + this->_xsd_interface_reconfigured_event_ = interface_reconfigured_event; + } + + void cl_message:: + interface_reconfigured_event (::std::auto_ptr< interface_reconfigured_event::type > interface_reconfigured_event) + { + this->_xsd_interface_reconfigured_event_.set (interface_reconfigured_event); + } + + const cl_message::interface_destroy_request::container& cl_message:: + interface_destroy_request () const + { + return this->_xsd_interface_destroy_request_; + } + + cl_message::interface_destroy_request::container& cl_message:: + interface_destroy_request () + { + return this->_xsd_interface_destroy_request_; + } + + void cl_message:: + interface_destroy_request (const interface_destroy_request::type& interface_destroy_request) + { + this->_xsd_interface_destroy_request_.set (interface_destroy_request); + } + + void cl_message:: + interface_destroy_request (const interface_destroy_request::container& interface_destroy_request) + { + this->_xsd_interface_destroy_request_ = interface_destroy_request; + } + + void cl_message:: + interface_destroy_request (::std::auto_ptr< interface_destroy_request::type > interface_destroy_request) + { + this->_xsd_interface_destroy_request_.set (interface_destroy_request); + } + + const cl_message::eid_reachable_event::container& cl_message:: + eid_reachable_event () const + { + return this->_xsd_eid_reachable_event_; + } + + cl_message::eid_reachable_event::container& cl_message:: + eid_reachable_event () + { + return this->_xsd_eid_reachable_event_; + } + + void cl_message:: + eid_reachable_event (const eid_reachable_event::type& eid_reachable_event) + { + this->_xsd_eid_reachable_event_.set (eid_reachable_event); + } + + void cl_message:: + eid_reachable_event (const eid_reachable_event::container& eid_reachable_event) + { + this->_xsd_eid_reachable_event_ = eid_reachable_event; + } + + void cl_message:: + eid_reachable_event (::std::auto_ptr< eid_reachable_event::type > eid_reachable_event) + { + this->_xsd_eid_reachable_event_.set (eid_reachable_event); + } + + const cl_message::link_set_defaults_request::container& cl_message:: + link_set_defaults_request () const + { + return this->_xsd_link_set_defaults_request_; + } + + cl_message::link_set_defaults_request::container& cl_message:: + link_set_defaults_request () + { + return this->_xsd_link_set_defaults_request_; + } + + void cl_message:: + link_set_defaults_request (const link_set_defaults_request::type& link_set_defaults_request) + { + this->_xsd_link_set_defaults_request_.set (link_set_defaults_request); + } + + void cl_message:: + link_set_defaults_request (const link_set_defaults_request::container& link_set_defaults_request) + { + this->_xsd_link_set_defaults_request_ = link_set_defaults_request; + } + + void cl_message:: + link_set_defaults_request (::std::auto_ptr< link_set_defaults_request::type > link_set_defaults_request) + { + this->_xsd_link_set_defaults_request_.set (link_set_defaults_request); + } + + const cl_message::link_create_request::container& cl_message:: + link_create_request () const + { + return this->_xsd_link_create_request_; + } + + cl_message::link_create_request::container& cl_message:: + link_create_request () + { + return this->_xsd_link_create_request_; + } + + void cl_message:: + link_create_request (const link_create_request::type& link_create_request) + { + this->_xsd_link_create_request_.set (link_create_request); + } + + void cl_message:: + link_create_request (const link_create_request::container& link_create_request) + { + this->_xsd_link_create_request_ = link_create_request; + } + + void cl_message:: + link_create_request (::std::auto_ptr< link_create_request::type > link_create_request) + { + this->_xsd_link_create_request_.set (link_create_request); + } + + const cl_message::link_created_event::container& cl_message:: + link_created_event () const + { + return this->_xsd_link_created_event_; + } + + cl_message::link_created_event::container& cl_message:: + link_created_event () + { + return this->_xsd_link_created_event_; + } + + void cl_message:: + link_created_event (const link_created_event::type& link_created_event) + { + this->_xsd_link_created_event_.set (link_created_event); + } + + void cl_message:: + link_created_event (const link_created_event::container& link_created_event) + { + this->_xsd_link_created_event_ = link_created_event; + } + + void cl_message:: + link_created_event (::std::auto_ptr< link_created_event::type > link_created_event) + { + this->_xsd_link_created_event_.set (link_created_event); + } + + const cl_message::link_open_request::container& cl_message:: + link_open_request () const + { + return this->_xsd_link_open_request_; + } + + cl_message::link_open_request::container& cl_message:: + link_open_request () + { + return this->_xsd_link_open_request_; + } + + void cl_message:: + link_open_request (const link_open_request::type& link_open_request) + { + this->_xsd_link_open_request_.set (link_open_request); + } + + void cl_message:: + link_open_request (const link_open_request::container& link_open_request) + { + this->_xsd_link_open_request_ = link_open_request; + } + + void cl_message:: + link_open_request (::std::auto_ptr< link_open_request::type > link_open_request) + { + this->_xsd_link_open_request_.set (link_open_request); + } + + const cl_message::link_opened_event::container& cl_message:: + link_opened_event () const + { + return this->_xsd_link_opened_event_; + } + + cl_message::link_opened_event::container& cl_message:: + link_opened_event () + { + return this->_xsd_link_opened_event_; + } + + void cl_message:: + link_opened_event (const link_opened_event::type& link_opened_event) + { + this->_xsd_link_opened_event_.set (link_opened_event); + } + + void cl_message:: + link_opened_event (const link_opened_event::container& link_opened_event) + { + this->_xsd_link_opened_event_ = link_opened_event; + } + + void cl_message:: + link_opened_event (::std::auto_ptr< link_opened_event::type > link_opened_event) + { + this->_xsd_link_opened_event_.set (link_opened_event); + } + + const cl_message::link_close_request::container& cl_message:: + link_close_request () const + { + return this->_xsd_link_close_request_; + } + + cl_message::link_close_request::container& cl_message:: + link_close_request () + { + return this->_xsd_link_close_request_; + } + + void cl_message:: + link_close_request (const link_close_request::type& link_close_request) + { + this->_xsd_link_close_request_.set (link_close_request); + } + + void cl_message:: + link_close_request (const link_close_request::container& link_close_request) + { + this->_xsd_link_close_request_ = link_close_request; + } + + void cl_message:: + link_close_request (::std::auto_ptr< link_close_request::type > link_close_request) + { + this->_xsd_link_close_request_.set (link_close_request); + } + + const cl_message::link_closed_event::container& cl_message:: + link_closed_event () const + { + return this->_xsd_link_closed_event_; + } + + cl_message::link_closed_event::container& cl_message:: + link_closed_event () + { + return this->_xsd_link_closed_event_; + } + + void cl_message:: + link_closed_event (const link_closed_event::type& link_closed_event) + { + this->_xsd_link_closed_event_.set (link_closed_event); + } + + void cl_message:: + link_closed_event (const link_closed_event::container& link_closed_event) + { + this->_xsd_link_closed_event_ = link_closed_event; + } + + void cl_message:: + link_closed_event (::std::auto_ptr< link_closed_event::type > link_closed_event) + { + this->_xsd_link_closed_event_.set (link_closed_event); + } + + const cl_message::link_state_changed_event::container& cl_message:: + link_state_changed_event () const + { + return this->_xsd_link_state_changed_event_; + } + + cl_message::link_state_changed_event::container& cl_message:: + link_state_changed_event () + { + return this->_xsd_link_state_changed_event_; + } + + void cl_message:: + link_state_changed_event (const link_state_changed_event::type& link_state_changed_event) + { + this->_xsd_link_state_changed_event_.set (link_state_changed_event); + } + + void cl_message:: + link_state_changed_event (const link_state_changed_event::container& link_state_changed_event) + { + this->_xsd_link_state_changed_event_ = link_state_changed_event; + } + + void cl_message:: + link_state_changed_event (::std::auto_ptr< link_state_changed_event::type > link_state_changed_event) + { + this->_xsd_link_state_changed_event_.set (link_state_changed_event); + } + + const cl_message::link_reconfigure_request::container& cl_message:: + link_reconfigure_request () const + { + return this->_xsd_link_reconfigure_request_; + } + + cl_message::link_reconfigure_request::container& cl_message:: + link_reconfigure_request () + { + return this->_xsd_link_reconfigure_request_; + } + + void cl_message:: + link_reconfigure_request (const link_reconfigure_request::type& link_reconfigure_request) + { + this->_xsd_link_reconfigure_request_.set (link_reconfigure_request); + } + + void cl_message:: + link_reconfigure_request (const link_reconfigure_request::container& link_reconfigure_request) + { + this->_xsd_link_reconfigure_request_ = link_reconfigure_request; + } + + void cl_message:: + link_reconfigure_request (::std::auto_ptr< link_reconfigure_request::type > link_reconfigure_request) + { + this->_xsd_link_reconfigure_request_.set (link_reconfigure_request); + } + + const cl_message::link_delete_request::container& cl_message:: + link_delete_request () const + { + return this->_xsd_link_delete_request_; + } + + cl_message::link_delete_request::container& cl_message:: + link_delete_request () + { + return this->_xsd_link_delete_request_; + } + + void cl_message:: + link_delete_request (const link_delete_request::type& link_delete_request) + { + this->_xsd_link_delete_request_.set (link_delete_request); + } + + void cl_message:: + link_delete_request (const link_delete_request::container& link_delete_request) + { + this->_xsd_link_delete_request_ = link_delete_request; + } + + void cl_message:: + link_delete_request (::std::auto_ptr< link_delete_request::type > link_delete_request) + { + this->_xsd_link_delete_request_.set (link_delete_request); + } + + const cl_message::link_deleted_event::container& cl_message:: + link_deleted_event () const + { + return this->_xsd_link_deleted_event_; + } + + cl_message::link_deleted_event::container& cl_message:: + link_deleted_event () + { + return this->_xsd_link_deleted_event_; + } + + void cl_message:: + link_deleted_event (const link_deleted_event::type& link_deleted_event) + { + this->_xsd_link_deleted_event_.set (link_deleted_event); + } + + void cl_message:: + link_deleted_event (const link_deleted_event::container& link_deleted_event) + { + this->_xsd_link_deleted_event_ = link_deleted_event; + } + + void cl_message:: + link_deleted_event (::std::auto_ptr< link_deleted_event::type > link_deleted_event) + { + this->_xsd_link_deleted_event_.set (link_deleted_event); + } + + const cl_message::link_attribute_changed_event::container& cl_message:: + link_attribute_changed_event () const + { + return this->_xsd_link_attribute_changed_event_; + } + + cl_message::link_attribute_changed_event::container& cl_message:: + link_attribute_changed_event () + { + return this->_xsd_link_attribute_changed_event_; + } + + void cl_message:: + link_attribute_changed_event (const link_attribute_changed_event::type& link_attribute_changed_event) + { + this->_xsd_link_attribute_changed_event_.set (link_attribute_changed_event); + } + + void cl_message:: + link_attribute_changed_event (const link_attribute_changed_event::container& link_attribute_changed_event) + { + this->_xsd_link_attribute_changed_event_ = link_attribute_changed_event; + } + + void cl_message:: + link_attribute_changed_event (::std::auto_ptr< link_attribute_changed_event::type > link_attribute_changed_event) + { + this->_xsd_link_attribute_changed_event_.set (link_attribute_changed_event); + } + + const cl_message::contact_attribute_changed_event::container& cl_message:: + contact_attribute_changed_event () const + { + return this->_xsd_contact_attribute_changed_event_; + } + + cl_message::contact_attribute_changed_event::container& cl_message:: + contact_attribute_changed_event () + { + return this->_xsd_contact_attribute_changed_event_; + } + + void cl_message:: + contact_attribute_changed_event (const contact_attribute_changed_event::type& contact_attribute_changed_event) + { + this->_xsd_contact_attribute_changed_event_.set (contact_attribute_changed_event); + } + + void cl_message:: + contact_attribute_changed_event (const contact_attribute_changed_event::container& contact_attribute_changed_event) + { + this->_xsd_contact_attribute_changed_event_ = contact_attribute_changed_event; + } + + void cl_message:: + contact_attribute_changed_event (::std::auto_ptr< contact_attribute_changed_event::type > contact_attribute_changed_event) + { + this->_xsd_contact_attribute_changed_event_.set (contact_attribute_changed_event); + } + + const cl_message::link_add_reachable_event::container& cl_message:: + link_add_reachable_event () const + { + return this->_xsd_link_add_reachable_event_; + } + + cl_message::link_add_reachable_event::container& cl_message:: + link_add_reachable_event () + { + return this->_xsd_link_add_reachable_event_; + } + + void cl_message:: + link_add_reachable_event (const link_add_reachable_event::type& link_add_reachable_event) + { + this->_xsd_link_add_reachable_event_.set (link_add_reachable_event); + } + + void cl_message:: + link_add_reachable_event (const link_add_reachable_event::container& link_add_reachable_event) + { + this->_xsd_link_add_reachable_event_ = link_add_reachable_event; + } + + void cl_message:: + link_add_reachable_event (::std::auto_ptr< link_add_reachable_event::type > link_add_reachable_event) + { + this->_xsd_link_add_reachable_event_.set (link_add_reachable_event); + } + + const cl_message::bundle_send_request::container& cl_message:: + bundle_send_request () const + { + return this->_xsd_bundle_send_request_; + } + + cl_message::bundle_send_request::container& cl_message:: + bundle_send_request () + { + return this->_xsd_bundle_send_request_; + } + + void cl_message:: + bundle_send_request (const bundle_send_request::type& bundle_send_request) + { + this->_xsd_bundle_send_request_.set (bundle_send_request); + } + + void cl_message:: + bundle_send_request (const bundle_send_request::container& bundle_send_request) + { + this->_xsd_bundle_send_request_ = bundle_send_request; + } + + void cl_message:: + bundle_send_request (::std::auto_ptr< bundle_send_request::type > bundle_send_request) + { + this->_xsd_bundle_send_request_.set (bundle_send_request); + } + + const cl_message::bundle_receive_started_event::container& cl_message:: + bundle_receive_started_event () const + { + return this->_xsd_bundle_receive_started_event_; + } + + cl_message::bundle_receive_started_event::container& cl_message:: + bundle_receive_started_event () + { + return this->_xsd_bundle_receive_started_event_; + } + + void cl_message:: + bundle_receive_started_event (const bundle_receive_started_event::type& bundle_receive_started_event) + { + this->_xsd_bundle_receive_started_event_.set (bundle_receive_started_event); + } + + void cl_message:: + bundle_receive_started_event (const bundle_receive_started_event::container& bundle_receive_started_event) + { + this->_xsd_bundle_receive_started_event_ = bundle_receive_started_event; + } + + void cl_message:: + bundle_receive_started_event (::std::auto_ptr< bundle_receive_started_event::type > bundle_receive_started_event) + { + this->_xsd_bundle_receive_started_event_.set (bundle_receive_started_event); + } + + const cl_message::bundle_received_event::container& cl_message:: + bundle_received_event () const + { + return this->_xsd_bundle_received_event_; + } + + cl_message::bundle_received_event::container& cl_message:: + bundle_received_event () + { + return this->_xsd_bundle_received_event_; + } + + void cl_message:: + bundle_received_event (const bundle_received_event::type& bundle_received_event) + { + this->_xsd_bundle_received_event_.set (bundle_received_event); + } + + void cl_message:: + bundle_received_event (const bundle_received_event::container& bundle_received_event) + { + this->_xsd_bundle_received_event_ = bundle_received_event; + } + + void cl_message:: + bundle_received_event (::std::auto_ptr< bundle_received_event::type > bundle_received_event) + { + this->_xsd_bundle_received_event_.set (bundle_received_event); + } + + const cl_message::bundle_transmitted_event::container& cl_message:: + bundle_transmitted_event () const + { + return this->_xsd_bundle_transmitted_event_; + } + + cl_message::bundle_transmitted_event::container& cl_message:: + bundle_transmitted_event () + { + return this->_xsd_bundle_transmitted_event_; + } + + void cl_message:: + bundle_transmitted_event (const bundle_transmitted_event::type& bundle_transmitted_event) + { + this->_xsd_bundle_transmitted_event_.set (bundle_transmitted_event); + } + + void cl_message:: + bundle_transmitted_event (const bundle_transmitted_event::container& bundle_transmitted_event) + { + this->_xsd_bundle_transmitted_event_ = bundle_transmitted_event; + } + + void cl_message:: + bundle_transmitted_event (::std::auto_ptr< bundle_transmitted_event::type > bundle_transmitted_event) + { + this->_xsd_bundle_transmitted_event_.set (bundle_transmitted_event); + } + + const cl_message::bundle_cancel_request::container& cl_message:: + bundle_cancel_request () const + { + return this->_xsd_bundle_cancel_request_; + } + + cl_message::bundle_cancel_request::container& cl_message:: + bundle_cancel_request () + { + return this->_xsd_bundle_cancel_request_; + } + + void cl_message:: + bundle_cancel_request (const bundle_cancel_request::type& bundle_cancel_request) + { + this->_xsd_bundle_cancel_request_.set (bundle_cancel_request); + } + + void cl_message:: + bundle_cancel_request (const bundle_cancel_request::container& bundle_cancel_request) + { + this->_xsd_bundle_cancel_request_ = bundle_cancel_request; + } + + void cl_message:: + bundle_cancel_request (::std::auto_ptr< bundle_cancel_request::type > bundle_cancel_request) + { + this->_xsd_bundle_cancel_request_.set (bundle_cancel_request); + } + + const cl_message::bundle_canceled_event::container& cl_message:: + bundle_canceled_event () const + { + return this->_xsd_bundle_canceled_event_; + } + + cl_message::bundle_canceled_event::container& cl_message:: + bundle_canceled_event () + { + return this->_xsd_bundle_canceled_event_; + } + + void cl_message:: + bundle_canceled_event (const bundle_canceled_event::type& bundle_canceled_event) + { + this->_xsd_bundle_canceled_event_.set (bundle_canceled_event); + } + + void cl_message:: + bundle_canceled_event (const bundle_canceled_event::container& bundle_canceled_event) + { + this->_xsd_bundle_canceled_event_ = bundle_canceled_event; + } + + void cl_message:: + bundle_canceled_event (::std::auto_ptr< bundle_canceled_event::type > bundle_canceled_event) + { + this->_xsd_bundle_canceled_event_.set (bundle_canceled_event); + } + + const cl_message::query_bundle_queued::container& cl_message:: + query_bundle_queued () const + { + return this->_xsd_query_bundle_queued_; + } + + cl_message::query_bundle_queued::container& cl_message:: + query_bundle_queued () + { + return this->_xsd_query_bundle_queued_; + } + + void cl_message:: + query_bundle_queued (const query_bundle_queued::type& query_bundle_queued) + { + this->_xsd_query_bundle_queued_.set (query_bundle_queued); + } + + void cl_message:: + query_bundle_queued (const query_bundle_queued::container& query_bundle_queued) + { + this->_xsd_query_bundle_queued_ = query_bundle_queued; + } + + void cl_message:: + query_bundle_queued (::std::auto_ptr< query_bundle_queued::type > query_bundle_queued) + { + this->_xsd_query_bundle_queued_.set (query_bundle_queued); + } + + const cl_message::report_bundle_queued::container& cl_message:: + report_bundle_queued () const + { + return this->_xsd_report_bundle_queued_; + } + + cl_message::report_bundle_queued::container& cl_message:: + report_bundle_queued () + { + return this->_xsd_report_bundle_queued_; + } + + void cl_message:: + report_bundle_queued (const report_bundle_queued::type& report_bundle_queued) + { + this->_xsd_report_bundle_queued_.set (report_bundle_queued); + } + + void cl_message:: + report_bundle_queued (const report_bundle_queued::container& report_bundle_queued) + { + this->_xsd_report_bundle_queued_ = report_bundle_queued; + } + + void cl_message:: + report_bundle_queued (::std::auto_ptr< report_bundle_queued::type > report_bundle_queued) + { + this->_xsd_report_bundle_queued_.set (report_bundle_queued); + } + + const cl_message::query_eid_reachable::container& cl_message:: + query_eid_reachable () const + { + return this->_xsd_query_eid_reachable_; + } + + cl_message::query_eid_reachable::container& cl_message:: + query_eid_reachable () + { + return this->_xsd_query_eid_reachable_; + } + + void cl_message:: + query_eid_reachable (const query_eid_reachable::type& query_eid_reachable) + { + this->_xsd_query_eid_reachable_.set (query_eid_reachable); + } + + void cl_message:: + query_eid_reachable (const query_eid_reachable::container& query_eid_reachable) + { + this->_xsd_query_eid_reachable_ = query_eid_reachable; + } + + void cl_message:: + query_eid_reachable (::std::auto_ptr< query_eid_reachable::type > query_eid_reachable) + { + this->_xsd_query_eid_reachable_.set (query_eid_reachable); + } + + const cl_message::report_eid_reachable::container& cl_message:: + report_eid_reachable () const + { + return this->_xsd_report_eid_reachable_; + } + + cl_message::report_eid_reachable::container& cl_message:: + report_eid_reachable () + { + return this->_xsd_report_eid_reachable_; + } + + void cl_message:: + report_eid_reachable (const report_eid_reachable::type& report_eid_reachable) + { + this->_xsd_report_eid_reachable_.set (report_eid_reachable); + } + + void cl_message:: + report_eid_reachable (const report_eid_reachable::container& report_eid_reachable) + { + this->_xsd_report_eid_reachable_ = report_eid_reachable; + } + + void cl_message:: + report_eid_reachable (::std::auto_ptr< report_eid_reachable::type > report_eid_reachable) + { + this->_xsd_report_eid_reachable_.set (report_eid_reachable); + } + + const cl_message::query_link_attributes::container& cl_message:: + query_link_attributes () const + { + return this->_xsd_query_link_attributes_; + } + + cl_message::query_link_attributes::container& cl_message:: + query_link_attributes () + { + return this->_xsd_query_link_attributes_; + } + + void cl_message:: + query_link_attributes (const query_link_attributes::type& query_link_attributes) + { + this->_xsd_query_link_attributes_.set (query_link_attributes); + } + + void cl_message:: + query_link_attributes (const query_link_attributes::container& query_link_attributes) + { + this->_xsd_query_link_attributes_ = query_link_attributes; + } + + void cl_message:: + query_link_attributes (::std::auto_ptr< query_link_attributes::type > query_link_attributes) + { + this->_xsd_query_link_attributes_.set (query_link_attributes); + } + + const cl_message::report_link_attributes::container& cl_message:: + report_link_attributes () const + { + return this->_xsd_report_link_attributes_; + } + + cl_message::report_link_attributes::container& cl_message:: + report_link_attributes () + { + return this->_xsd_report_link_attributes_; + } + + void cl_message:: + report_link_attributes (const report_link_attributes::type& report_link_attributes) + { + this->_xsd_report_link_attributes_.set (report_link_attributes); + } + + void cl_message:: + report_link_attributes (const report_link_attributes::container& report_link_attributes) + { + this->_xsd_report_link_attributes_ = report_link_attributes; + } + + void cl_message:: + report_link_attributes (::std::auto_ptr< report_link_attributes::type > report_link_attributes) + { + this->_xsd_report_link_attributes_.set (report_link_attributes); + } + + const cl_message::query_interface_attributes::container& cl_message:: + query_interface_attributes () const + { + return this->_xsd_query_interface_attributes_; + } + + cl_message::query_interface_attributes::container& cl_message:: + query_interface_attributes () + { + return this->_xsd_query_interface_attributes_; + } + + void cl_message:: + query_interface_attributes (const query_interface_attributes::type& query_interface_attributes) + { + this->_xsd_query_interface_attributes_.set (query_interface_attributes); + } + + void cl_message:: + query_interface_attributes (const query_interface_attributes::container& query_interface_attributes) + { + this->_xsd_query_interface_attributes_ = query_interface_attributes; + } + + void cl_message:: + query_interface_attributes (::std::auto_ptr< query_interface_attributes::type > query_interface_attributes) + { + this->_xsd_query_interface_attributes_.set (query_interface_attributes); + } + + const cl_message::report_interface_attributes::container& cl_message:: + report_interface_attributes () const + { + return this->_xsd_report_interface_attributes_; + } + + cl_message::report_interface_attributes::container& cl_message:: + report_interface_attributes () + { + return this->_xsd_report_interface_attributes_; + } + + void cl_message:: + report_interface_attributes (const report_interface_attributes::type& report_interface_attributes) + { + this->_xsd_report_interface_attributes_.set (report_interface_attributes); + } + + void cl_message:: + report_interface_attributes (const report_interface_attributes::container& report_interface_attributes) + { + this->_xsd_report_interface_attributes_ = report_interface_attributes; + } + + void cl_message:: + report_interface_attributes (::std::auto_ptr< report_interface_attributes::type > report_interface_attributes) + { + this->_xsd_report_interface_attributes_.set (report_interface_attributes); + } + + const cl_message::query_cla_parameters::container& cl_message:: + query_cla_parameters () const + { + return this->_xsd_query_cla_parameters_; + } + + cl_message::query_cla_parameters::container& cl_message:: + query_cla_parameters () + { + return this->_xsd_query_cla_parameters_; + } + + void cl_message:: + query_cla_parameters (const query_cla_parameters::type& query_cla_parameters) + { + this->_xsd_query_cla_parameters_.set (query_cla_parameters); + } + + void cl_message:: + query_cla_parameters (const query_cla_parameters::container& query_cla_parameters) + { + this->_xsd_query_cla_parameters_ = query_cla_parameters; + } + + void cl_message:: + query_cla_parameters (::std::auto_ptr< query_cla_parameters::type > query_cla_parameters) + { + this->_xsd_query_cla_parameters_.set (query_cla_parameters); + } + + const cl_message::report_cla_parameters::container& cl_message:: + report_cla_parameters () const + { + return this->_xsd_report_cla_parameters_; + } + + cl_message::report_cla_parameters::container& cl_message:: + report_cla_parameters () + { + return this->_xsd_report_cla_parameters_; + } + + void cl_message:: + report_cla_parameters (const report_cla_parameters::type& report_cla_parameters) + { + this->_xsd_report_cla_parameters_.set (report_cla_parameters); + } + + void cl_message:: + report_cla_parameters (const report_cla_parameters::container& report_cla_parameters) + { + this->_xsd_report_cla_parameters_ = report_cla_parameters; + } + + void cl_message:: + report_cla_parameters (::std::auto_ptr< report_cla_parameters::type > report_cla_parameters) + { + this->_xsd_report_cla_parameters_.set (report_cla_parameters); + } + } +} + +#include +#include + +namespace dtn +{ + namespace clmessage + { + // linkTypeType + // + + linkTypeType:: + linkTypeType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_linkTypeType_convert (); + } + + linkTypeType:: + linkTypeType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_linkTypeType_convert (); + } + + linkTypeType:: + linkTypeType (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (s, e, f, c) + { + _xsd_linkTypeType_convert (); + } + + linkTypeType* linkTypeType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new linkTypeType (*this, f, c); + } + + linkTypeType::_xsd_linkTypeType linkTypeType:: + _xsd_linkTypeType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkTypeType_literals_); + const _xsd_linkTypeType* i (::std::lower_bound ( + _xsd_linkTypeType_indexes_, + _xsd_linkTypeType_indexes_ + 5, + *this, + c)); + + if (i == _xsd_linkTypeType_indexes_ + 5 || _xsd_linkTypeType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const linkTypeType:: + _xsd_linkTypeType_literals_[5] = + { + "alwayson", + "ondemand", + "scheduled", + "predicted", + "opportunistic" + }; + + const linkTypeType::_xsd_linkTypeType linkTypeType:: + _xsd_linkTypeType_indexes_[5] = + { + ::dtn::clmessage::linkTypeType::alwayson, + ::dtn::clmessage::linkTypeType::ondemand, + ::dtn::clmessage::linkTypeType::opportunistic, + ::dtn::clmessage::linkTypeType::predicted, + ::dtn::clmessage::linkTypeType::scheduled + }; + + // linkStateType + // + + linkStateType:: + linkStateType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_linkStateType_convert (); + } + + linkStateType:: + linkStateType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_linkStateType_convert (); + } + + linkStateType:: + linkStateType (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (s, e, f, c) + { + _xsd_linkStateType_convert (); + } + + linkStateType* linkStateType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new linkStateType (*this, f, c); + } + + linkStateType::_xsd_linkStateType linkStateType:: + _xsd_linkStateType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkStateType_literals_); + const _xsd_linkStateType* i (::std::lower_bound ( + _xsd_linkStateType_indexes_, + _xsd_linkStateType_indexes_ + 6, + *this, + c)); + + if (i == _xsd_linkStateType_indexes_ + 6 || _xsd_linkStateType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const linkStateType:: + _xsd_linkStateType_literals_[6] = + { + "unavailable", + "available", + "opening", + "open", + "busy", + "closed" + }; + + const linkStateType::_xsd_linkStateType linkStateType:: + _xsd_linkStateType_indexes_[6] = + { + ::dtn::clmessage::linkStateType::available, + ::dtn::clmessage::linkStateType::busy, + ::dtn::clmessage::linkStateType::closed, + ::dtn::clmessage::linkStateType::open, + ::dtn::clmessage::linkStateType::opening, + ::dtn::clmessage::linkStateType::unavailable + }; + + // linkReasonType + // + + linkReasonType:: + linkReasonType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_linkReasonType_convert (); + } + + linkReasonType:: + linkReasonType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_linkReasonType_convert (); + } + + linkReasonType:: + linkReasonType (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (s, e, f, c) + { + _xsd_linkReasonType_convert (); + } + + linkReasonType* linkReasonType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new linkReasonType (*this, f, c); + } + + linkReasonType::_xsd_linkReasonType linkReasonType:: + _xsd_linkReasonType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_linkReasonType_literals_); + const _xsd_linkReasonType* i (::std::lower_bound ( + _xsd_linkReasonType_indexes_, + _xsd_linkReasonType_indexes_ + 8, + *this, + c)); + + if (i == _xsd_linkReasonType_indexes_ + 8 || _xsd_linkReasonType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const linkReasonType:: + _xsd_linkReasonType_literals_[8] = + { + "no_info", + "user", + "broken", + "shutdown", + "reconnect", + "idle", + "timeout", + "unblocked" + }; + + const linkReasonType::_xsd_linkReasonType linkReasonType:: + _xsd_linkReasonType_indexes_[8] = + { + ::dtn::clmessage::linkReasonType::broken, + ::dtn::clmessage::linkReasonType::idle, + ::dtn::clmessage::linkReasonType::no_info, + ::dtn::clmessage::linkReasonType::reconnect, + ::dtn::clmessage::linkReasonType::shutdown, + ::dtn::clmessage::linkReasonType::timeout, + ::dtn::clmessage::linkReasonType::unblocked, + ::dtn::clmessage::linkReasonType::user + }; + + // bundlePassMethodType + // + + bundlePassMethodType:: + bundlePassMethodType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_bundlePassMethodType_convert (); + } + + bundlePassMethodType:: + bundlePassMethodType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_bundlePassMethodType_convert (); + } + + bundlePassMethodType:: + bundlePassMethodType (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (s, e, f, c) + { + _xsd_bundlePassMethodType_convert (); + } + + bundlePassMethodType* bundlePassMethodType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundlePassMethodType (*this, f, c); + } + + bundlePassMethodType::_xsd_bundlePassMethodType bundlePassMethodType:: + _xsd_bundlePassMethodType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundlePassMethodType_literals_); + const _xsd_bundlePassMethodType* i (::std::lower_bound ( + _xsd_bundlePassMethodType_indexes_, + _xsd_bundlePassMethodType_indexes_ + 2, + *this, + c)); + + if (i == _xsd_bundlePassMethodType_indexes_ + 2 || _xsd_bundlePassMethodType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const bundlePassMethodType:: + _xsd_bundlePassMethodType_literals_[2] = + { + "unknown", + "filesystem" + }; + + const bundlePassMethodType::_xsd_bundlePassMethodType bundlePassMethodType:: + _xsd_bundlePassMethodType_indexes_[2] = + { + ::dtn::clmessage::bundlePassMethodType::filesystem, + ::dtn::clmessage::bundlePassMethodType::unknown + }; + + // percentType + // + + percentType:: + percentType () + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > () + { + } + + percentType:: + percentType (const _xsd_percentType::base_& _xsd_percentType) + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (_xsd_percentType) + { + } + + percentType:: + percentType (const percentType& _xsd_percentType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (_xsd_percentType, f, c) + { + } + + percentType:: + percentType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (e, f, c) + { + } + + percentType:: + percentType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (a, f, c) + { + } + + percentType:: + percentType (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type > (s, e, f, c) + { + } + + percentType* percentType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new percentType (*this, f, c); + } + + // attribute_name + // + + attribute_name:: + attribute_name () + : ::xml_schema::type (), + _xsd_value_ (::xml_schema::flags (), this) + { + } + + attribute_name:: + attribute_name (const value::type& _xsd_value) + : ::xml_schema::type (), + _xsd_value_ (_xsd_value, + ::xml_schema::flags (), + this) + { + } + + attribute_name:: + attribute_name (const attribute_name& _xsd_attribute_name, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_attribute_name, f, c), + _xsd_value_ (_xsd_attribute_name._xsd_value_, + f | ::xml_schema::flags::not_root, + this) + { + } + + attribute_name:: + attribute_name (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_value_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void attribute_name:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "value" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< value::type > r ( + value::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->value (r); + continue; + } + } + + if (!_xsd_value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + attribute_name* attribute_name:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new attribute_name (*this, f, c); + } + + // key_value_pair + // + + key_value_pair:: + key_value_pair () + : ::xml_schema::type (), + _xsd_name_ (::xml_schema::flags (), this), + _xsd_value_ (::xml_schema::flags (), this) + { + } + + key_value_pair:: + key_value_pair (const name::type& _xsd_name, + const value::type& _xsd_value) + : ::xml_schema::type (), + _xsd_name_ (_xsd_name, + ::xml_schema::flags (), + this), + _xsd_value_ (_xsd_value, + ::xml_schema::flags (), + this) + { + } + + key_value_pair:: + key_value_pair (const key_value_pair& _xsd_key_value_pair, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_key_value_pair, f, c), + _xsd_name_ (_xsd_key_value_pair._xsd_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_value_ (_xsd_key_value_pair._xsd_value_, + f | ::xml_schema::flags::not_root, + this) + { + } + + key_value_pair:: + key_value_pair (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_value_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void key_value_pair:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< name::type > r ( + name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->name (r); + continue; + } + + if (a.name () == "value" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< value::type > r ( + value::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->value (r); + continue; + } + } + + if (!_xsd_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "name", + ""); + } + + if (!_xsd_value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + key_value_pair* key_value_pair:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new key_value_pair (*this, f, c); + } + + // bundle_attributes + // + + bundle_attributes:: + bundle_attributes () + : ::xml_schema::type (), + _xsd_source_eid_ (::xml_schema::flags (), this), + _xsd_timestamp_seconds_ (::xml_schema::flags (), this), + _xsd_timestamp_sequence_ (::xml_schema::flags (), this), + _xsd_is_fragment_ (::xml_schema::flags (), this), + _xsd_fragment_length_ (::xml_schema::flags (), this), + _xsd_fragment_offset_ (::xml_schema::flags (), this) + { + } + + bundle_attributes:: + bundle_attributes (const source_eid::type& _xsd_source_eid, + const timestamp_seconds::type& _xsd_timestamp_seconds, + const timestamp_sequence::type& _xsd_timestamp_sequence, + const is_fragment::type& _xsd_is_fragment) + : ::xml_schema::type (), + _xsd_source_eid_ (_xsd_source_eid, + ::xml_schema::flags (), + this), + _xsd_timestamp_seconds_ (_xsd_timestamp_seconds, + ::xml_schema::flags (), + this), + _xsd_timestamp_sequence_ (_xsd_timestamp_sequence, + ::xml_schema::flags (), + this), + _xsd_is_fragment_ (_xsd_is_fragment, + ::xml_schema::flags (), + this), + _xsd_fragment_length_ (::xml_schema::flags (), this), + _xsd_fragment_offset_ (::xml_schema::flags (), this) + { + } + + bundle_attributes:: + bundle_attributes (const bundle_attributes& _xsd_bundle_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_attributes, f, c), + _xsd_source_eid_ (_xsd_bundle_attributes._xsd_source_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_timestamp_seconds_ (_xsd_bundle_attributes._xsd_timestamp_seconds_, + f | ::xml_schema::flags::not_root, + this), + _xsd_timestamp_sequence_ (_xsd_bundle_attributes._xsd_timestamp_sequence_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_fragment_ (_xsd_bundle_attributes._xsd_is_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_fragment_length_ (_xsd_bundle_attributes._xsd_fragment_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_fragment_offset_ (_xsd_bundle_attributes._xsd_fragment_offset_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_attributes:: + bundle_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_source_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_timestamp_seconds_ (f | ::xml_schema::flags::not_root, this), + _xsd_timestamp_sequence_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_fragment_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_fragment_offset_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "source_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< source_eid::type > r ( + source_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->source_eid (r); + continue; + } + + if (a.name () == "timestamp_seconds" && a.namespace_ ().empty ()) + { + this->timestamp_seconds ( + timestamp_seconds::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "timestamp_sequence" && a.namespace_ ().empty ()) + { + this->timestamp_sequence ( + timestamp_sequence::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "is_fragment" && a.namespace_ ().empty ()) + { + this->is_fragment ( + is_fragment::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "fragment_length" && a.namespace_ ().empty ()) + { + this->fragment_length ( + fragment_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "fragment_offset" && a.namespace_ ().empty ()) + { + this->fragment_offset ( + fragment_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_source_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "source_eid", + ""); + } + + if (!_xsd_timestamp_seconds_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "timestamp_seconds", + ""); + } + + if (!_xsd_timestamp_sequence_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "timestamp_sequence", + ""); + } + + if (!_xsd_is_fragment_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_fragment", + ""); + } + } + + bundle_attributes* bundle_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_attributes (*this, f, c); + } + + // link_attributes + // + + link_attributes:: + link_attributes () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_type_ (::xml_schema::flags (), this), + _xsd_state_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this), + _xsd_is_reachable_ (::xml_schema::flags (), this), + _xsd_is_usable_ (::xml_schema::flags (), this), + _xsd_how_reliable_ (::xml_schema::flags (), this), + _xsd_how_available_ (::xml_schema::flags (), this), + _xsd_reactive_fragment_ (::xml_schema::flags (), this), + _xsd_nexthop_ (::xml_schema::flags (), this), + _xsd_cla_name_ (::xml_schema::flags (), this), + _xsd_high_water_mark_ (::xml_schema::flags (), this), + _xsd_low_water_mark_ (::xml_schema::flags (), this) + { + } + + link_attributes:: + link_attributes (const link_attributes& _xsd_link_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_attributes, f, c), + _xsd_key_value_pair_ (_xsd_link_attributes._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_type_ (_xsd_link_attributes._xsd_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_state_ (_xsd_link_attributes._xsd_state_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_link_attributes._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_reachable_ (_xsd_link_attributes._xsd_is_reachable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_usable_ (_xsd_link_attributes._xsd_is_usable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_how_reliable_ (_xsd_link_attributes._xsd_how_reliable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_how_available_ (_xsd_link_attributes._xsd_how_available_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reactive_fragment_ (_xsd_link_attributes._xsd_reactive_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_nexthop_ (_xsd_link_attributes._xsd_nexthop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_cla_name_ (_xsd_link_attributes._xsd_cla_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_high_water_mark_ (_xsd_link_attributes._xsd_high_water_mark_, + f | ::xml_schema::flags::not_root, + this), + _xsd_low_water_mark_ (_xsd_link_attributes._xsd_low_water_mark_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_attributes:: + link_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_state_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_reachable_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_usable_ (f | ::xml_schema::flags::not_root, this), + _xsd_how_reliable_ (f | ::xml_schema::flags::not_root, this), + _xsd_how_available_ (f | ::xml_schema::flags::not_root, this), + _xsd_reactive_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this), + _xsd_cla_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_high_water_mark_ (f | ::xml_schema::flags::not_root, this), + _xsd_low_water_mark_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "type" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< type::type_ > r ( + type::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->type (r); + continue; + } + + if (a.name () == "state" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< state::type > r ( + state::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->state (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + + if (a.name () == "is_reachable" && a.namespace_ ().empty ()) + { + this->is_reachable ( + is_reachable::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "is_usable" && a.namespace_ ().empty ()) + { + this->is_usable ( + is_usable::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "how_reliable" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< how_reliable::type > r ( + how_reliable::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->how_reliable (r); + continue; + } + + if (a.name () == "how_available" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< how_available::type > r ( + how_available::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->how_available (r); + continue; + } + + if (a.name () == "reactive_fragment" && a.namespace_ ().empty ()) + { + this->reactive_fragment ( + reactive_fragment::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "nexthop" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< nexthop::type > r ( + nexthop::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->nexthop (r); + continue; + } + + if (a.name () == "cla_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< cla_name::type > r ( + cla_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->cla_name (r); + continue; + } + + if (a.name () == "high_water_mark" && a.namespace_ ().empty ()) + { + this->high_water_mark ( + high_water_mark::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "low_water_mark" && a.namespace_ ().empty ()) + { + this->low_water_mark ( + low_water_mark::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + } + + link_attributes* link_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_attributes (*this, f, c); + } + + // link_config_parameters + // + + link_config_parameters:: + link_config_parameters () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_is_usable_ (::xml_schema::flags (), this), + _xsd_reactive_fragment_ (::xml_schema::flags (), this), + _xsd_nexthop_ (::xml_schema::flags (), this) + { + } + + link_config_parameters:: + link_config_parameters (const link_config_parameters& _xsd_link_config_parameters, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_config_parameters, f, c), + _xsd_key_value_pair_ (_xsd_link_config_parameters._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_usable_ (_xsd_link_config_parameters._xsd_is_usable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reactive_fragment_ (_xsd_link_config_parameters._xsd_reactive_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_nexthop_ (_xsd_link_config_parameters._xsd_nexthop_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_config_parameters:: + link_config_parameters (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_usable_ (f | ::xml_schema::flags::not_root, this), + _xsd_reactive_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_config_parameters:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "is_usable" && a.namespace_ ().empty ()) + { + this->is_usable ( + is_usable::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "reactive_fragment" && a.namespace_ ().empty ()) + { + this->reactive_fragment ( + reactive_fragment::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "nexthop" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< nexthop::type > r ( + nexthop::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->nexthop (r); + continue; + } + } + } + + link_config_parameters* link_config_parameters:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_config_parameters (*this, f, c); + } + + // contact_attributes + // + + contact_attributes:: + contact_attributes () + : ::xml_schema::type (), + _xsd_start_time_ (::xml_schema::flags (), this), + _xsd_duration_ (::xml_schema::flags (), this), + _xsd_bps_ (::xml_schema::flags (), this), + _xsd_latency_ (::xml_schema::flags (), this), + _xsd_packet_loss_prob_ (::xml_schema::flags (), this) + { + } + + contact_attributes:: + contact_attributes (const start_time::type& _xsd_start_time, + const duration::type& _xsd_duration, + const bps::type& _xsd_bps, + const latency::type& _xsd_latency, + const packet_loss_prob::type& _xsd_packet_loss_prob) + : ::xml_schema::type (), + _xsd_start_time_ (_xsd_start_time, + ::xml_schema::flags (), + this), + _xsd_duration_ (_xsd_duration, + ::xml_schema::flags (), + this), + _xsd_bps_ (_xsd_bps, + ::xml_schema::flags (), + this), + _xsd_latency_ (_xsd_latency, + ::xml_schema::flags (), + this), + _xsd_packet_loss_prob_ (_xsd_packet_loss_prob, + ::xml_schema::flags (), + this) + { + } + + contact_attributes:: + contact_attributes (const contact_attributes& _xsd_contact_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_contact_attributes, f, c), + _xsd_start_time_ (_xsd_contact_attributes._xsd_start_time_, + f | ::xml_schema::flags::not_root, + this), + _xsd_duration_ (_xsd_contact_attributes._xsd_duration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bps_ (_xsd_contact_attributes._xsd_bps_, + f | ::xml_schema::flags::not_root, + this), + _xsd_latency_ (_xsd_contact_attributes._xsd_latency_, + f | ::xml_schema::flags::not_root, + this), + _xsd_packet_loss_prob_ (_xsd_contact_attributes._xsd_packet_loss_prob_, + f | ::xml_schema::flags::not_root, + this) + { + } + + contact_attributes:: + contact_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_start_time_ (f | ::xml_schema::flags::not_root, this), + _xsd_duration_ (f | ::xml_schema::flags::not_root, this), + _xsd_bps_ (f | ::xml_schema::flags::not_root, this), + _xsd_latency_ (f | ::xml_schema::flags::not_root, this), + _xsd_packet_loss_prob_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void contact_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "start_time" && a.namespace_ ().empty ()) + { + this->start_time ( + start_time::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "duration" && a.namespace_ ().empty ()) + { + this->duration ( + duration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "bps" && a.namespace_ ().empty ()) + { + this->bps ( + bps::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "latency" && a.namespace_ ().empty ()) + { + this->latency ( + latency::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "packet_loss_prob" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< packet_loss_prob::type > r ( + packet_loss_prob::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->packet_loss_prob (r); + continue; + } + } + + if (!_xsd_start_time_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "start_time", + ""); + } + + if (!_xsd_duration_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "duration", + ""); + } + + if (!_xsd_bps_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "bps", + ""); + } + + if (!_xsd_latency_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "latency", + ""); + } + + if (!_xsd_packet_loss_prob_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "packet_loss_prob", + ""); + } + } + + contact_attributes* contact_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new contact_attributes (*this, f, c); + } + + // cla_add_request + // + + cla_add_request:: + cla_add_request () + : ::xml_schema::type (), + _xsd_name_ (::xml_schema::flags (), this) + { + } + + cla_add_request:: + cla_add_request (const name::type& _xsd_name) + : ::xml_schema::type (), + _xsd_name_ (_xsd_name, + ::xml_schema::flags (), + this) + { + } + + cla_add_request:: + cla_add_request (const cla_add_request& _xsd_cla_add_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cla_add_request, f, c), + _xsd_name_ (_xsd_cla_add_request._xsd_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + cla_add_request:: + cla_add_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void cla_add_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< name::type > r ( + name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->name (r); + continue; + } + } + + if (!_xsd_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "name", + ""); + } + } + + cla_add_request* cla_add_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cla_add_request (*this, f, c); + } + + // cla_delete_request + // + + cla_delete_request:: + cla_delete_request () + : ::xml_schema::type (), + _xsd_name_ (::xml_schema::flags (), this) + { + } + + cla_delete_request:: + cla_delete_request (const name::type& _xsd_name) + : ::xml_schema::type (), + _xsd_name_ (_xsd_name, + ::xml_schema::flags (), + this) + { + } + + cla_delete_request:: + cla_delete_request (const cla_delete_request& _xsd_cla_delete_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cla_delete_request, f, c), + _xsd_name_ (_xsd_cla_delete_request._xsd_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + cla_delete_request:: + cla_delete_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void cla_delete_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< name::type > r ( + name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->name (r); + continue; + } + } + + if (!_xsd_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "name", + ""); + } + } + + cla_delete_request* cla_delete_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cla_delete_request (*this, f, c); + } + + // cla_set_params_request + // + + cla_set_params_request:: + cla_set_params_request () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_local_eid_ (::xml_schema::flags (), this), + _xsd_create_discovered_links_ (::xml_schema::flags (), this), + _xsd_bundle_pass_method_ (::xml_schema::flags (), this), + _xsd_reactive_fragment_enabled_ (::xml_schema::flags (), this) + { + } + + cla_set_params_request:: + cla_set_params_request (const cla_set_params_request& _xsd_cla_set_params_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cla_set_params_request, f, c), + _xsd_key_value_pair_ (_xsd_cla_set_params_request._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_eid_ (_xsd_cla_set_params_request._xsd_local_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_create_discovered_links_ (_xsd_cla_set_params_request._xsd_create_discovered_links_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_pass_method_ (_xsd_cla_set_params_request._xsd_bundle_pass_method_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reactive_fragment_enabled_ (_xsd_cla_set_params_request._xsd_reactive_fragment_enabled_, + f | ::xml_schema::flags::not_root, + this) + { + } + + cla_set_params_request:: + cla_set_params_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_create_discovered_links_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_pass_method_ (f | ::xml_schema::flags::not_root, this), + _xsd_reactive_fragment_enabled_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void cla_set_params_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< local_eid::type > r ( + local_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->local_eid (r); + continue; + } + + if (a.name () == "create_discovered_links" && a.namespace_ ().empty ()) + { + this->create_discovered_links ( + create_discovered_links::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "bundle_pass_method" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< bundle_pass_method::type > r ( + bundle_pass_method::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->bundle_pass_method (r); + continue; + } + + if (a.name () == "reactive_fragment_enabled" && a.namespace_ ().empty ()) + { + this->reactive_fragment_enabled ( + reactive_fragment_enabled::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + } + + cla_set_params_request* cla_set_params_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cla_set_params_request (*this, f, c); + } + + // cla_params_set_event + // + + cla_params_set_event:: + cla_params_set_event () + : ::xml_schema::type () + { + } + + cla_params_set_event:: + cla_params_set_event (const cla_params_set_event& _xsd_cla_params_set_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cla_params_set_event, f, c) + { + } + + cla_params_set_event:: + cla_params_set_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c) + { + } + + cla_params_set_event:: + cla_params_set_event (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (a, f, c) + { + } + + cla_params_set_event:: + cla_params_set_event (const ::std::basic_string< char >& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (s, e, f, c) + { + } + + cla_params_set_event* cla_params_set_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cla_params_set_event (*this, f, c); + } + + // interface_set_defaults_request + // + + interface_set_defaults_request:: + interface_set_defaults_request () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this) + { + } + + interface_set_defaults_request:: + interface_set_defaults_request (const interface_set_defaults_request& _xsd_interface_set_defaults_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_set_defaults_request, f, c), + _xsd_key_value_pair_ (_xsd_interface_set_defaults_request._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_set_defaults_request:: + interface_set_defaults_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_set_defaults_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + } + + interface_set_defaults_request* interface_set_defaults_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_set_defaults_request (*this, f, c); + } + + // interface_create_request + // + + interface_create_request:: + interface_create_request () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_interface_name_ (::xml_schema::flags (), this) + { + } + + interface_create_request:: + interface_create_request (const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this) + { + } + + interface_create_request:: + interface_create_request (const interface_create_request& _xsd_interface_create_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_create_request, f, c), + _xsd_key_value_pair_ (_xsd_interface_create_request._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_name_ (_xsd_interface_create_request._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_create_request:: + interface_create_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_create_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + } + + interface_create_request* interface_create_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_create_request (*this, f, c); + } + + // interface_created_event + // + + interface_created_event:: + interface_created_event () + : ::xml_schema::type (), + _xsd_interface_name_ (::xml_schema::flags (), this) + { + } + + interface_created_event:: + interface_created_event (const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this) + { + } + + interface_created_event:: + interface_created_event (const interface_created_event& _xsd_interface_created_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_created_event, f, c), + _xsd_interface_name_ (_xsd_interface_created_event._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_created_event:: + interface_created_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_created_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + } + + interface_created_event* interface_created_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_created_event (*this, f, c); + } + + // interface_reconfigure_request + // + + interface_reconfigure_request:: + interface_reconfigure_request () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_interface_name_ (::xml_schema::flags (), this), + _xsd_up_ (::xml_schema::flags (), this), + _xsd_discovery_ (::xml_schema::flags (), this) + { + } + + interface_reconfigure_request:: + interface_reconfigure_request (const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this), + _xsd_up_ (::xml_schema::flags (), this), + _xsd_discovery_ (::xml_schema::flags (), this) + { + } + + interface_reconfigure_request:: + interface_reconfigure_request (const interface_reconfigure_request& _xsd_interface_reconfigure_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_reconfigure_request, f, c), + _xsd_key_value_pair_ (_xsd_interface_reconfigure_request._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_name_ (_xsd_interface_reconfigure_request._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_up_ (_xsd_interface_reconfigure_request._xsd_up_, + f | ::xml_schema::flags::not_root, + this), + _xsd_discovery_ (_xsd_interface_reconfigure_request._xsd_discovery_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_reconfigure_request:: + interface_reconfigure_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_up_ (f | ::xml_schema::flags::not_root, this), + _xsd_discovery_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_reconfigure_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + + if (a.name () == "up" && a.namespace_ ().empty ()) + { + this->up ( + up::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "discovery" && a.namespace_ ().empty ()) + { + this->discovery ( + discovery::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + } + + interface_reconfigure_request* interface_reconfigure_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_reconfigure_request (*this, f, c); + } + + // interface_reconfigured_event + // + + interface_reconfigured_event:: + interface_reconfigured_event () + : ::xml_schema::type (), + _xsd_interface_name_ (::xml_schema::flags (), this) + { + } + + interface_reconfigured_event:: + interface_reconfigured_event (const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this) + { + } + + interface_reconfigured_event:: + interface_reconfigured_event (const interface_reconfigured_event& _xsd_interface_reconfigured_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_reconfigured_event, f, c), + _xsd_interface_name_ (_xsd_interface_reconfigured_event._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_reconfigured_event:: + interface_reconfigured_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_reconfigured_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + } + + interface_reconfigured_event* interface_reconfigured_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_reconfigured_event (*this, f, c); + } + + // interface_destroy_request + // + + interface_destroy_request:: + interface_destroy_request () + : ::xml_schema::type (), + _xsd_interface_name_ (::xml_schema::flags (), this) + { + } + + interface_destroy_request:: + interface_destroy_request (const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this) + { + } + + interface_destroy_request:: + interface_destroy_request (const interface_destroy_request& _xsd_interface_destroy_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_interface_destroy_request, f, c), + _xsd_interface_name_ (_xsd_interface_destroy_request._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + interface_destroy_request:: + interface_destroy_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void interface_destroy_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + } + + interface_destroy_request* interface_destroy_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new interface_destroy_request (*this, f, c); + } + + // eid_reachable_event + // + + eid_reachable_event:: + eid_reachable_event () + : ::xml_schema::type (), + _xsd_interface_name_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + eid_reachable_event:: + eid_reachable_event (const interface_name::type& _xsd_interface_name, + const peer_eid::type& _xsd_peer_eid) + : ::xml_schema::type (), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (_xsd_peer_eid, + ::xml_schema::flags (), + this) + { + } + + eid_reachable_event:: + eid_reachable_event (const eid_reachable_event& _xsd_eid_reachable_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_eid_reachable_event, f, c), + _xsd_interface_name_ (_xsd_eid_reachable_event._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_eid_reachable_event._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + eid_reachable_event:: + eid_reachable_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void eid_reachable_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + + if (!_xsd_peer_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "peer_eid", + ""); + } + } + + eid_reachable_event* eid_reachable_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new eid_reachable_event (*this, f, c); + } + + // link_set_defaults_request + // + + link_set_defaults_request:: + link_set_defaults_request () + : ::xml_schema::type (), + _xsd_link_config_parameters_ (::xml_schema::flags (), this) + { + } + + link_set_defaults_request:: + link_set_defaults_request (const link_config_parameters::type& _xsd_link_config_parameters) + : ::xml_schema::type (), + _xsd_link_config_parameters_ (_xsd_link_config_parameters, + ::xml_schema::flags (), + this) + { + } + + link_set_defaults_request:: + link_set_defaults_request (const link_set_defaults_request& _xsd_link_set_defaults_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_set_defaults_request, f, c), + _xsd_link_config_parameters_ (_xsd_link_set_defaults_request._xsd_link_config_parameters_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_set_defaults_request:: + link_set_defaults_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_set_defaults_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_config_parameters + // + { + if (e.name () == "link_config_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< link_config_parameters::type > r ( + link_config_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_config_parameters_.present ()) + continue; + this->link_config_parameters (r); + continue; + } + } + } + + if (!_xsd_link_config_parameters_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_config_parameters", + ""); + } + } + + link_set_defaults_request* link_set_defaults_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_set_defaults_request (*this, f, c); + } + + // link_create_request + // + + link_create_request:: + link_create_request () + : ::xml_schema::type (), + _xsd_link_config_parameters_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_type_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + link_create_request:: + link_create_request (const link_config_parameters::type& _xsd_link_config_parameters, + const link_name::type& _xsd_link_name, + const type::type_& _xsd_type) + : ::xml_schema::type (), + _xsd_link_config_parameters_ (_xsd_link_config_parameters, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_type_ (_xsd_type, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + link_create_request:: + link_create_request (const link_create_request& _xsd_link_create_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_create_request, f, c), + _xsd_link_config_parameters_ (_xsd_link_create_request._xsd_link_config_parameters_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_create_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_type_ (_xsd_link_create_request._xsd_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_link_create_request._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_create_request:: + link_create_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_create_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_config_parameters + // + { + if (e.name () == "link_config_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< link_config_parameters::type > r ( + link_config_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_config_parameters_.present ()) + continue; + this->link_config_parameters (r); + continue; + } + } + } + + if (!_xsd_link_config_parameters_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_config_parameters", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "type" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< type::type_ > r ( + type::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->type (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_type_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "type", + ""); + } + } + + link_create_request* link_create_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_create_request (*this, f, c); + } + + // link_created_event + // + + link_created_event:: + link_created_event () + : ::xml_schema::type (), + _xsd_link_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_created_event:: + link_created_event (const link_attributes::type& _xsd_link_attributes, + const link_name::type& _xsd_link_name, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_attributes_ (_xsd_link_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_created_event:: + link_created_event (const link_created_event& _xsd_link_created_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_created_event, f, c), + _xsd_link_attributes_ (_xsd_link_created_event._xsd_link_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_created_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_created_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_created_event:: + link_created_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_created_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_attributes + // + { + if (e.name () == "link_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< link_attributes::type > r ( + link_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_attributes_.present ()) + continue; + this->link_attributes (r); + continue; + } + } + } + + if (!_xsd_link_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< reason::type > r ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->reason (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_created_event* link_created_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_created_event (*this, f, c); + } + + // link_open_request + // + + link_open_request:: + link_open_request () + : ::xml_schema::type (), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_open_request:: + link_open_request (const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_open_request:: + link_open_request (const link_open_request& _xsd_link_open_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_open_request, f, c), + _xsd_link_name_ (_xsd_link_open_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_open_request:: + link_open_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_open_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_open_request* link_open_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_open_request (*this, f, c); + } + + // link_opened_event + // + + link_opened_event:: + link_opened_event () + : ::xml_schema::type (), + _xsd_contact_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_opened_event:: + link_opened_event (const contact_attributes::type& _xsd_contact_attributes, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_contact_attributes_ (_xsd_contact_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_opened_event:: + link_opened_event (const link_opened_event& _xsd_link_opened_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_opened_event, f, c), + _xsd_contact_attributes_ (_xsd_link_opened_event._xsd_contact_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_opened_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_opened_event:: + link_opened_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_opened_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // contact_attributes + // + { + if (e.name () == "contact_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_attributes::type > r ( + contact_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attributes_.present ()) + continue; + this->contact_attributes (r); + continue; + } + } + } + + if (!_xsd_contact_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_opened_event* link_opened_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_opened_event (*this, f, c); + } + + // link_close_request + // + + link_close_request:: + link_close_request () + : ::xml_schema::type (), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_close_request:: + link_close_request (const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_close_request:: + link_close_request (const link_close_request& _xsd_link_close_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_close_request, f, c), + _xsd_link_name_ (_xsd_link_close_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_close_request:: + link_close_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_close_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_close_request* link_close_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_close_request (*this, f, c); + } + + // link_closed_event + // + + link_closed_event:: + link_closed_event () + : ::xml_schema::type (), + _xsd_contact_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_closed_event:: + link_closed_event (const contact_attributes::type& _xsd_contact_attributes, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_contact_attributes_ (_xsd_contact_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_closed_event:: + link_closed_event (const link_closed_event& _xsd_link_closed_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_closed_event, f, c), + _xsd_contact_attributes_ (_xsd_link_closed_event._xsd_contact_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_closed_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_closed_event:: + link_closed_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_closed_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // contact_attributes + // + { + if (e.name () == "contact_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_attributes::type > r ( + contact_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attributes_.present ()) + continue; + this->contact_attributes (r); + continue; + } + } + } + + if (!_xsd_contact_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_closed_event* link_closed_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_closed_event (*this, f, c); + } + + // link_state_changed_event + // + + link_state_changed_event:: + link_state_changed_event () + : ::xml_schema::type (), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_new_state_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_state_changed_event:: + link_state_changed_event (const link_name::type& _xsd_link_name, + const new_state::type& _xsd_new_state, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_new_state_ (_xsd_new_state, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_state_changed_event:: + link_state_changed_event (const link_state_changed_event& _xsd_link_state_changed_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_state_changed_event, f, c), + _xsd_link_name_ (_xsd_link_state_changed_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_new_state_ (_xsd_link_state_changed_event._xsd_new_state_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_state_changed_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_state_changed_event:: + link_state_changed_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_new_state_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_state_changed_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "new_state" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< new_state::type > r ( + new_state::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->new_state (r); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< reason::type > r ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->reason (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_new_state_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "new_state", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_state_changed_event* link_state_changed_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_state_changed_event (*this, f, c); + } + + // link_reconfigure_request + // + + link_reconfigure_request:: + link_reconfigure_request () + : ::xml_schema::type (), + _xsd_link_config_parameters_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_reconfigure_request:: + link_reconfigure_request (const link_config_parameters::type& _xsd_link_config_parameters, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_link_config_parameters_ (_xsd_link_config_parameters, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_reconfigure_request:: + link_reconfigure_request (const link_reconfigure_request& _xsd_link_reconfigure_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_reconfigure_request, f, c), + _xsd_link_config_parameters_ (_xsd_link_reconfigure_request._xsd_link_config_parameters_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_reconfigure_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_reconfigure_request:: + link_reconfigure_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_reconfigure_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_config_parameters + // + { + if (e.name () == "link_config_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< link_config_parameters::type > r ( + link_config_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_config_parameters_.present ()) + continue; + this->link_config_parameters (r); + continue; + } + } + } + + if (!_xsd_link_config_parameters_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_config_parameters", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_reconfigure_request* link_reconfigure_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_reconfigure_request (*this, f, c); + } + + // link_delete_request + // + + link_delete_request:: + link_delete_request () + : ::xml_schema::type (), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + link_delete_request:: + link_delete_request (const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + link_delete_request:: + link_delete_request (const link_delete_request& _xsd_link_delete_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_delete_request, f, c), + _xsd_link_name_ (_xsd_link_delete_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_delete_request:: + link_delete_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_delete_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + link_delete_request* link_delete_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_delete_request (*this, f, c); + } + + // link_deleted_event + // + + link_deleted_event:: + link_deleted_event () + : ::xml_schema::type (), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_deleted_event:: + link_deleted_event (const link_name::type& _xsd_link_name, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_deleted_event:: + link_deleted_event (const link_deleted_event& _xsd_link_deleted_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_deleted_event, f, c), + _xsd_link_name_ (_xsd_link_deleted_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_deleted_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_deleted_event:: + link_deleted_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_deleted_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< reason::type > r ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->reason (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_deleted_event* link_deleted_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_deleted_event (*this, f, c); + } + + // link_attribute_changed_event + // + + link_attribute_changed_event:: + link_attribute_changed_event () + : ::xml_schema::type (), + _xsd_link_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_attribute_changed_event:: + link_attribute_changed_event (const link_attributes::type& _xsd_link_attributes, + const link_name::type& _xsd_link_name, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_attributes_ (_xsd_link_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_attribute_changed_event:: + link_attribute_changed_event (const link_attribute_changed_event& _xsd_link_attribute_changed_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_attribute_changed_event, f, c), + _xsd_link_attributes_ (_xsd_link_attribute_changed_event._xsd_link_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_attribute_changed_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_attribute_changed_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_attribute_changed_event:: + link_attribute_changed_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_attribute_changed_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_attributes + // + { + if (e.name () == "link_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< link_attributes::type > r ( + link_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_attributes_.present ()) + continue; + this->link_attributes (r); + continue; + } + } + } + + if (!_xsd_link_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< reason::type > r ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->reason (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_attribute_changed_event* link_attribute_changed_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_attribute_changed_event (*this, f, c); + } + + // contact_attribute_changed_event + // + + contact_attribute_changed_event:: + contact_attribute_changed_event () + : ::xml_schema::type (), + _xsd_contact_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + contact_attribute_changed_event:: + contact_attribute_changed_event (const contact_attributes::type& _xsd_contact_attributes, + const link_name::type& _xsd_link_name, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_contact_attributes_ (_xsd_contact_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + contact_attribute_changed_event:: + contact_attribute_changed_event (const contact_attribute_changed_event& _xsd_contact_attribute_changed_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_contact_attribute_changed_event, f, c), + _xsd_contact_attributes_ (_xsd_contact_attribute_changed_event._xsd_contact_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_contact_attribute_changed_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_contact_attribute_changed_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + contact_attribute_changed_event:: + contact_attribute_changed_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_contact_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void contact_attribute_changed_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // contact_attributes + // + { + if (e.name () == "contact_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_attributes::type > r ( + contact_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attributes_.present ()) + continue; + this->contact_attributes (r); + continue; + } + } + } + + if (!_xsd_contact_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< reason::type > r ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->reason (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + contact_attribute_changed_event* contact_attribute_changed_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new contact_attribute_changed_event (*this, f, c); + } + + // link_add_reachable_event + // + + link_add_reachable_event:: + link_add_reachable_event () + : ::xml_schema::type (), + _xsd_link_config_parameters_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + link_add_reachable_event:: + link_add_reachable_event (const link_config_parameters::type& _xsd_link_config_parameters, + const link_name::type& _xsd_link_name, + const peer_eid::type& _xsd_peer_eid) + : ::xml_schema::type (), + _xsd_link_config_parameters_ (_xsd_link_config_parameters, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (_xsd_peer_eid, + ::xml_schema::flags (), + this) + { + } + + link_add_reachable_event:: + link_add_reachable_event (const link_add_reachable_event& _xsd_link_add_reachable_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_add_reachable_event, f, c), + _xsd_link_config_parameters_ (_xsd_link_add_reachable_event._xsd_link_config_parameters_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_link_add_reachable_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_link_add_reachable_event._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_add_reachable_event:: + link_add_reachable_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_parameters_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_add_reachable_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // link_config_parameters + // + { + if (e.name () == "link_config_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< link_config_parameters::type > r ( + link_config_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_config_parameters_.present ()) + continue; + this->link_config_parameters (r); + continue; + } + } + } + + if (!_xsd_link_config_parameters_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_config_parameters", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_peer_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "peer_eid", + ""); + } + } + + link_add_reachable_event* link_add_reachable_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_add_reachable_event (*this, f, c); + } + + // bundle_send_request + // + + bundle_send_request:: + bundle_send_request () + : ::xml_schema::type (), + _xsd_bundle_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_location_ (::xml_schema::flags (), this) + { + } + + bundle_send_request:: + bundle_send_request (const bundle_attributes::type& _xsd_bundle_attributes, + const link_name::type& _xsd_link_name, + const location::type& _xsd_location) + : ::xml_schema::type (), + _xsd_bundle_attributes_ (_xsd_bundle_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_location_ (_xsd_location, + ::xml_schema::flags (), + this) + { + } + + bundle_send_request:: + bundle_send_request (const bundle_send_request& _xsd_bundle_send_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_send_request, f, c), + _xsd_bundle_attributes_ (_xsd_bundle_send_request._xsd_bundle_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_bundle_send_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_location_ (_xsd_bundle_send_request._xsd_location_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_send_request:: + bundle_send_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_location_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_send_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // bundle_attributes + // + { + if (e.name () == "bundle_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes::type > r ( + bundle_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_attributes_.present ()) + continue; + this->bundle_attributes (r); + continue; + } + } + } + + if (!_xsd_bundle_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "location" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< location::type > r ( + location::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->location (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_location_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "location", + ""); + } + } + + bundle_send_request* bundle_send_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_send_request (*this, f, c); + } + + // bundle_receive_started_event + // + + bundle_receive_started_event:: + bundle_receive_started_event () + : ::xml_schema::type (), + _xsd_location_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + bundle_receive_started_event:: + bundle_receive_started_event (const location::type& _xsd_location) + : ::xml_schema::type (), + _xsd_location_ (_xsd_location, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + bundle_receive_started_event:: + bundle_receive_started_event (const bundle_receive_started_event& _xsd_bundle_receive_started_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_receive_started_event, f, c), + _xsd_location_ (_xsd_bundle_receive_started_event._xsd_location_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_bundle_receive_started_event._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_receive_started_event:: + bundle_receive_started_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_location_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_receive_started_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "location" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< location::type > r ( + location::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->location (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_location_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "location", + ""); + } + } + + bundle_receive_started_event* bundle_receive_started_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_receive_started_event (*this, f, c); + } + + // bundle_received_event + // + + bundle_received_event:: + bundle_received_event () + : ::xml_schema::type (), + _xsd_location_ (::xml_schema::flags (), this), + _xsd_bytes_received_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + bundle_received_event:: + bundle_received_event (const location::type& _xsd_location, + const bytes_received::type& _xsd_bytes_received) + : ::xml_schema::type (), + _xsd_location_ (_xsd_location, + ::xml_schema::flags (), + this), + _xsd_bytes_received_ (_xsd_bytes_received, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + bundle_received_event:: + bundle_received_event (const bundle_received_event& _xsd_bundle_received_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_received_event, f, c), + _xsd_location_ (_xsd_bundle_received_event._xsd_location_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bytes_received_ (_xsd_bundle_received_event._xsd_bytes_received_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_bundle_received_event._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_received_event:: + bundle_received_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_location_ (f | ::xml_schema::flags::not_root, this), + _xsd_bytes_received_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_received_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "location" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< location::type > r ( + location::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->location (r); + continue; + } + + if (a.name () == "bytes_received" && a.namespace_ ().empty ()) + { + this->bytes_received ( + bytes_received::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_location_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "location", + ""); + } + + if (!_xsd_bytes_received_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "bytes_received", + ""); + } + } + + bundle_received_event* bundle_received_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_received_event (*this, f, c); + } + + // bundle_transmitted_event + // + + bundle_transmitted_event:: + bundle_transmitted_event () + : ::xml_schema::type (), + _xsd_bundle_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_bytes_sent_ (::xml_schema::flags (), this), + _xsd_reliably_sent_ (::xml_schema::flags (), this) + { + } + + bundle_transmitted_event:: + bundle_transmitted_event (const bundle_attributes::type& _xsd_bundle_attributes, + const link_name::type& _xsd_link_name, + const bytes_sent::type& _xsd_bytes_sent, + const reliably_sent::type& _xsd_reliably_sent) + : ::xml_schema::type (), + _xsd_bundle_attributes_ (_xsd_bundle_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_bytes_sent_ (_xsd_bytes_sent, + ::xml_schema::flags (), + this), + _xsd_reliably_sent_ (_xsd_reliably_sent, + ::xml_schema::flags (), + this) + { + } + + bundle_transmitted_event:: + bundle_transmitted_event (const bundle_transmitted_event& _xsd_bundle_transmitted_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_transmitted_event, f, c), + _xsd_bundle_attributes_ (_xsd_bundle_transmitted_event._xsd_bundle_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_bundle_transmitted_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bytes_sent_ (_xsd_bundle_transmitted_event._xsd_bytes_sent_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reliably_sent_ (_xsd_bundle_transmitted_event._xsd_reliably_sent_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_transmitted_event:: + bundle_transmitted_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_bytes_sent_ (f | ::xml_schema::flags::not_root, this), + _xsd_reliably_sent_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_transmitted_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // bundle_attributes + // + { + if (e.name () == "bundle_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes::type > r ( + bundle_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_attributes_.present ()) + continue; + this->bundle_attributes (r); + continue; + } + } + } + + if (!_xsd_bundle_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "bytes_sent" && a.namespace_ ().empty ()) + { + this->bytes_sent ( + bytes_sent::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "reliably_sent" && a.namespace_ ().empty ()) + { + this->reliably_sent ( + reliably_sent::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_bytes_sent_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "bytes_sent", + ""); + } + + if (!_xsd_reliably_sent_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reliably_sent", + ""); + } + } + + bundle_transmitted_event* bundle_transmitted_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_transmitted_event (*this, f, c); + } + + // bundle_cancel_request + // + + bundle_cancel_request:: + bundle_cancel_request () + : ::xml_schema::type (), + _xsd_bundle_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + bundle_cancel_request:: + bundle_cancel_request (const bundle_attributes::type& _xsd_bundle_attributes, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_bundle_attributes_ (_xsd_bundle_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + bundle_cancel_request:: + bundle_cancel_request (const bundle_cancel_request& _xsd_bundle_cancel_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_cancel_request, f, c), + _xsd_bundle_attributes_ (_xsd_bundle_cancel_request._xsd_bundle_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_bundle_cancel_request._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_cancel_request:: + bundle_cancel_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_cancel_request:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // bundle_attributes + // + { + if (e.name () == "bundle_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes::type > r ( + bundle_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_attributes_.present ()) + continue; + this->bundle_attributes (r); + continue; + } + } + } + + if (!_xsd_bundle_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + bundle_cancel_request* bundle_cancel_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_cancel_request (*this, f, c); + } + + // bundle_canceled_event + // + + bundle_canceled_event:: + bundle_canceled_event () + : ::xml_schema::type (), + _xsd_bundle_attributes_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + bundle_canceled_event:: + bundle_canceled_event (const bundle_attributes::type& _xsd_bundle_attributes, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_bundle_attributes_ (_xsd_bundle_attributes, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + bundle_canceled_event:: + bundle_canceled_event (const bundle_canceled_event& _xsd_bundle_canceled_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_canceled_event, f, c), + _xsd_bundle_attributes_ (_xsd_bundle_canceled_event._xsd_bundle_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_bundle_canceled_event._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_canceled_event:: + bundle_canceled_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_canceled_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // bundle_attributes + // + { + if (e.name () == "bundle_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes::type > r ( + bundle_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_attributes_.present ()) + continue; + this->bundle_attributes (r); + continue; + } + } + } + + if (!_xsd_bundle_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + bundle_canceled_event* bundle_canceled_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_canceled_event (*this, f, c); + } + + // query_bundle_queued + // + + query_bundle_queued:: + query_bundle_queued () + : ::xml_schema::type (), + _xsd_bundle_attributes_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this) + { + } + + query_bundle_queued:: + query_bundle_queued (const bundle_attributes::type& _xsd_bundle_attributes, + const query_id::type& _xsd_query_id, + const link_name::type& _xsd_link_name) + : ::xml_schema::type (), + _xsd_bundle_attributes_ (_xsd_bundle_attributes, + ::xml_schema::flags (), + this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this) + { + } + + query_bundle_queued:: + query_bundle_queued (const query_bundle_queued& _xsd_query_bundle_queued, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_query_bundle_queued, f, c), + _xsd_bundle_attributes_ (_xsd_query_bundle_queued._xsd_bundle_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_query_bundle_queued._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_query_bundle_queued._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this) + { + } + + query_bundle_queued:: + query_bundle_queued (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void query_bundle_queued:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // bundle_attributes + // + { + if (e.name () == "bundle_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes::type > r ( + bundle_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_attributes_.present ()) + continue; + this->bundle_attributes (r); + continue; + } + } + } + + if (!_xsd_bundle_attributes_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle_attributes", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + } + + query_bundle_queued* query_bundle_queued:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new query_bundle_queued (*this, f, c); + } + + // report_bundle_queued + // + + report_bundle_queued:: + report_bundle_queued () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_is_queued_ (::xml_schema::flags (), this) + { + } + + report_bundle_queued:: + report_bundle_queued (const query_id::type& _xsd_query_id, + const is_queued::type& _xsd_is_queued) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_is_queued_ (_xsd_is_queued, + ::xml_schema::flags (), + this) + { + } + + report_bundle_queued:: + report_bundle_queued (const report_bundle_queued& _xsd_report_bundle_queued, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_report_bundle_queued, f, c), + _xsd_query_id_ (_xsd_report_bundle_queued._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_queued_ (_xsd_report_bundle_queued._xsd_is_queued_, + f | ::xml_schema::flags::not_root, + this) + { + } + + report_bundle_queued:: + report_bundle_queued (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_queued_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void report_bundle_queued:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + + if (a.name () == "is_queued" && a.namespace_ ().empty ()) + { + this->is_queued ( + is_queued::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + + if (!_xsd_is_queued_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_queued", + ""); + } + } + + report_bundle_queued* report_bundle_queued:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new report_bundle_queued (*this, f, c); + } + + // query_eid_reachable + // + + query_eid_reachable:: + query_eid_reachable () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_interface_name_ (::xml_schema::flags (), this), + _xsd_peer_eid_ (::xml_schema::flags (), this) + { + } + + query_eid_reachable:: + query_eid_reachable (const query_id::type& _xsd_query_id, + const interface_name::type& _xsd_interface_name, + const peer_eid::type& _xsd_peer_eid) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this), + _xsd_peer_eid_ (_xsd_peer_eid, + ::xml_schema::flags (), + this) + { + } + + query_eid_reachable:: + query_eid_reachable (const query_eid_reachable& _xsd_query_eid_reachable, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_query_eid_reachable, f, c), + _xsd_query_id_ (_xsd_query_eid_reachable._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_name_ (_xsd_query_eid_reachable._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_peer_eid_ (_xsd_query_eid_reachable._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + query_eid_reachable:: + query_eid_reachable (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_peer_eid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void query_eid_reachable:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + + if (a.name () == "peer_eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->peer_eid (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + + if (!_xsd_peer_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "peer_eid", + ""); + } + } + + query_eid_reachable* query_eid_reachable:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new query_eid_reachable (*this, f, c); + } + + // report_eid_reachable + // + + report_eid_reachable:: + report_eid_reachable () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_is_reachable_ (::xml_schema::flags (), this) + { + } + + report_eid_reachable:: + report_eid_reachable (const query_id::type& _xsd_query_id, + const is_reachable::type& _xsd_is_reachable) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_is_reachable_ (_xsd_is_reachable, + ::xml_schema::flags (), + this) + { + } + + report_eid_reachable:: + report_eid_reachable (const report_eid_reachable& _xsd_report_eid_reachable, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_report_eid_reachable, f, c), + _xsd_query_id_ (_xsd_report_eid_reachable._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_reachable_ (_xsd_report_eid_reachable._xsd_is_reachable_, + f | ::xml_schema::flags::not_root, + this) + { + } + + report_eid_reachable:: + report_eid_reachable (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_reachable_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void report_eid_reachable:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + + if (a.name () == "is_reachable" && a.namespace_ ().empty ()) + { + this->is_reachable ( + is_reachable::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + + if (!_xsd_is_reachable_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_reachable", + ""); + } + } + + report_eid_reachable* report_eid_reachable:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new report_eid_reachable (*this, f, c); + } + + // query_link_attributes + // + + query_link_attributes:: + query_link_attributes () + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_link_name_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + query_link_attributes:: + query_link_attributes (const link_name::type& _xsd_link_name, + const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_link_name_ (_xsd_link_name, + ::xml_schema::flags (), + this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + query_link_attributes:: + query_link_attributes (const query_link_attributes& _xsd_query_link_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_query_link_attributes, f, c), + _xsd_attribute_name_ (_xsd_query_link_attributes._xsd_attribute_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_name_ (_xsd_query_link_attributes._xsd_link_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_query_link_attributes._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + query_link_attributes:: + query_link_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void query_link_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // attribute_name + // + { + if (e.name () == "attribute_name" && e.namespace_ () == "") + { + ::std::auto_ptr< attribute_name::type > r ( + attribute_name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->attribute_name ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_name::type > r ( + link_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_name (r); + continue; + } + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_link_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_name", + ""); + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + query_link_attributes* query_link_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new query_link_attributes (*this, f, c); + } + + // report_link_attributes + // + + report_link_attributes:: + report_link_attributes () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + report_link_attributes:: + report_link_attributes (const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + report_link_attributes:: + report_link_attributes (const report_link_attributes& _xsd_report_link_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_report_link_attributes, f, c), + _xsd_key_value_pair_ (_xsd_report_link_attributes._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_report_link_attributes._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + report_link_attributes:: + report_link_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void report_link_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + report_link_attributes* report_link_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new report_link_attributes (*this, f, c); + } + + // query_interface_attributes + // + + query_interface_attributes:: + query_interface_attributes () + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_interface_name_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + query_interface_attributes:: + query_interface_attributes (const interface_name::type& _xsd_interface_name, + const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_interface_name_ (_xsd_interface_name, + ::xml_schema::flags (), + this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + query_interface_attributes:: + query_interface_attributes (const query_interface_attributes& _xsd_query_interface_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_query_interface_attributes, f, c), + _xsd_attribute_name_ (_xsd_query_interface_attributes._xsd_attribute_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_name_ (_xsd_query_interface_attributes._xsd_interface_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_query_interface_attributes._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + query_interface_attributes:: + query_interface_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void query_interface_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // attribute_name + // + { + if (e.name () == "attribute_name" && e.namespace_ () == "") + { + ::std::auto_ptr< attribute_name::type > r ( + attribute_name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->attribute_name ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "interface_name" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< interface_name::type > r ( + interface_name::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->interface_name (r); + continue; + } + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_interface_name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "interface_name", + ""); + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + query_interface_attributes* query_interface_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new query_interface_attributes (*this, f, c); + } + + // report_interface_attributes + // + + report_interface_attributes:: + report_interface_attributes () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + report_interface_attributes:: + report_interface_attributes (const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + report_interface_attributes:: + report_interface_attributes (const report_interface_attributes& _xsd_report_interface_attributes, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_report_interface_attributes, f, c), + _xsd_key_value_pair_ (_xsd_report_interface_attributes._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_report_interface_attributes._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + report_interface_attributes:: + report_interface_attributes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void report_interface_attributes:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + report_interface_attributes* report_interface_attributes:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new report_interface_attributes (*this, f, c); + } + + // query_cla_parameters + // + + query_cla_parameters:: + query_cla_parameters () + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + query_cla_parameters:: + query_cla_parameters (const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_attribute_name_ (::xml_schema::flags (), this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + query_cla_parameters:: + query_cla_parameters (const query_cla_parameters& _xsd_query_cla_parameters, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_query_cla_parameters, f, c), + _xsd_attribute_name_ (_xsd_query_cla_parameters._xsd_attribute_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_query_cla_parameters._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + query_cla_parameters:: + query_cla_parameters (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_attribute_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void query_cla_parameters:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // attribute_name + // + { + if (e.name () == "attribute_name" && e.namespace_ () == "") + { + ::std::auto_ptr< attribute_name::type > r ( + attribute_name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->attribute_name ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + query_cla_parameters* query_cla_parameters:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new query_cla_parameters (*this, f, c); + } + + // report_cla_parameters + // + + report_cla_parameters:: + report_cla_parameters () + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (::xml_schema::flags (), this) + { + } + + report_cla_parameters:: + report_cla_parameters (const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_key_value_pair_ (::xml_schema::flags (), this), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this) + { + } + + report_cla_parameters:: + report_cla_parameters (const report_cla_parameters& _xsd_report_cla_parameters, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_report_cla_parameters, f, c), + _xsd_key_value_pair_ (_xsd_report_cla_parameters._xsd_key_value_pair_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_id_ (_xsd_report_cla_parameters._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + report_cla_parameters:: + report_cla_parameters (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_key_value_pair_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void report_cla_parameters:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // key_value_pair + // + { + if (e.name () == "key_value_pair" && e.namespace_ () == "") + { + ::std::auto_ptr< key_value_pair::type > r ( + key_value_pair::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->key_value_pair ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "query_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_id (r); + continue; + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "query_id", + ""); + } + } + + report_cla_parameters* report_cla_parameters:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new report_cla_parameters (*this, f, c); + } + + // cl_message + // + + cl_message:: + cl_message () + : ::xml_schema::type (), + _xsd_cla_add_request_ (::xml_schema::flags (), this), + _xsd_cla_delete_request_ (::xml_schema::flags (), this), + _xsd_cla_set_params_request_ (::xml_schema::flags (), this), + _xsd_cla_params_set_event_ (::xml_schema::flags (), this), + _xsd_interface_set_defaults_request_ (::xml_schema::flags (), this), + _xsd_interface_create_request_ (::xml_schema::flags (), this), + _xsd_interface_created_event_ (::xml_schema::flags (), this), + _xsd_interface_reconfigure_request_ (::xml_schema::flags (), this), + _xsd_interface_reconfigured_event_ (::xml_schema::flags (), this), + _xsd_interface_destroy_request_ (::xml_schema::flags (), this), + _xsd_eid_reachable_event_ (::xml_schema::flags (), this), + _xsd_link_set_defaults_request_ (::xml_schema::flags (), this), + _xsd_link_create_request_ (::xml_schema::flags (), this), + _xsd_link_created_event_ (::xml_schema::flags (), this), + _xsd_link_open_request_ (::xml_schema::flags (), this), + _xsd_link_opened_event_ (::xml_schema::flags (), this), + _xsd_link_close_request_ (::xml_schema::flags (), this), + _xsd_link_closed_event_ (::xml_schema::flags (), this), + _xsd_link_state_changed_event_ (::xml_schema::flags (), this), + _xsd_link_reconfigure_request_ (::xml_schema::flags (), this), + _xsd_link_delete_request_ (::xml_schema::flags (), this), + _xsd_link_deleted_event_ (::xml_schema::flags (), this), + _xsd_link_attribute_changed_event_ (::xml_schema::flags (), this), + _xsd_contact_attribute_changed_event_ (::xml_schema::flags (), this), + _xsd_link_add_reachable_event_ (::xml_schema::flags (), this), + _xsd_bundle_send_request_ (::xml_schema::flags (), this), + _xsd_bundle_receive_started_event_ (::xml_schema::flags (), this), + _xsd_bundle_received_event_ (::xml_schema::flags (), this), + _xsd_bundle_transmitted_event_ (::xml_schema::flags (), this), + _xsd_bundle_cancel_request_ (::xml_schema::flags (), this), + _xsd_bundle_canceled_event_ (::xml_schema::flags (), this), + _xsd_query_bundle_queued_ (::xml_schema::flags (), this), + _xsd_report_bundle_queued_ (::xml_schema::flags (), this), + _xsd_query_eid_reachable_ (::xml_schema::flags (), this), + _xsd_report_eid_reachable_ (::xml_schema::flags (), this), + _xsd_query_link_attributes_ (::xml_schema::flags (), this), + _xsd_report_link_attributes_ (::xml_schema::flags (), this), + _xsd_query_interface_attributes_ (::xml_schema::flags (), this), + _xsd_report_interface_attributes_ (::xml_schema::flags (), this), + _xsd_query_cla_parameters_ (::xml_schema::flags (), this), + _xsd_report_cla_parameters_ (::xml_schema::flags (), this) + { + } + + cl_message:: + cl_message (const cl_message& _xsd_cl_message, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cl_message, f, c), + _xsd_cla_add_request_ (_xsd_cl_message._xsd_cla_add_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_cla_delete_request_ (_xsd_cl_message._xsd_cla_delete_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_cla_set_params_request_ (_xsd_cl_message._xsd_cla_set_params_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_cla_params_set_event_ (_xsd_cl_message._xsd_cla_params_set_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_set_defaults_request_ (_xsd_cl_message._xsd_interface_set_defaults_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_create_request_ (_xsd_cl_message._xsd_interface_create_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_created_event_ (_xsd_cl_message._xsd_interface_created_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_reconfigure_request_ (_xsd_cl_message._xsd_interface_reconfigure_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_reconfigured_event_ (_xsd_cl_message._xsd_interface_reconfigured_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_destroy_request_ (_xsd_cl_message._xsd_interface_destroy_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_eid_reachable_event_ (_xsd_cl_message._xsd_eid_reachable_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_set_defaults_request_ (_xsd_cl_message._xsd_link_set_defaults_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_create_request_ (_xsd_cl_message._xsd_link_create_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_created_event_ (_xsd_cl_message._xsd_link_created_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_open_request_ (_xsd_cl_message._xsd_link_open_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_opened_event_ (_xsd_cl_message._xsd_link_opened_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_close_request_ (_xsd_cl_message._xsd_link_close_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_closed_event_ (_xsd_cl_message._xsd_link_closed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_state_changed_event_ (_xsd_cl_message._xsd_link_state_changed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_reconfigure_request_ (_xsd_cl_message._xsd_link_reconfigure_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_delete_request_ (_xsd_cl_message._xsd_link_delete_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_deleted_event_ (_xsd_cl_message._xsd_link_deleted_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_attribute_changed_event_ (_xsd_cl_message._xsd_link_attribute_changed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contact_attribute_changed_event_ (_xsd_cl_message._xsd_contact_attribute_changed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_add_reachable_event_ (_xsd_cl_message._xsd_link_add_reachable_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_send_request_ (_xsd_cl_message._xsd_bundle_send_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_receive_started_event_ (_xsd_cl_message._xsd_bundle_receive_started_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_received_event_ (_xsd_cl_message._xsd_bundle_received_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_transmitted_event_ (_xsd_cl_message._xsd_bundle_transmitted_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_cancel_request_ (_xsd_cl_message._xsd_bundle_cancel_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_canceled_event_ (_xsd_cl_message._xsd_bundle_canceled_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_bundle_queued_ (_xsd_cl_message._xsd_query_bundle_queued_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_bundle_queued_ (_xsd_cl_message._xsd_report_bundle_queued_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_eid_reachable_ (_xsd_cl_message._xsd_query_eid_reachable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_eid_reachable_ (_xsd_cl_message._xsd_report_eid_reachable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_link_attributes_ (_xsd_cl_message._xsd_query_link_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_link_attributes_ (_xsd_cl_message._xsd_report_link_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_interface_attributes_ (_xsd_cl_message._xsd_query_interface_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_interface_attributes_ (_xsd_cl_message._xsd_report_interface_attributes_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_cla_parameters_ (_xsd_cl_message._xsd_query_cla_parameters_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_cla_parameters_ (_xsd_cl_message._xsd_report_cla_parameters_, + f | ::xml_schema::flags::not_root, + this) + { + } + + cl_message:: + cl_message (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_cla_add_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_cla_delete_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_cla_set_params_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_cla_params_set_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_set_defaults_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_create_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_created_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_reconfigure_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_reconfigured_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_destroy_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_eid_reachable_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_set_defaults_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_create_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_created_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_open_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_opened_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_close_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_closed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_state_changed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_reconfigure_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_delete_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_deleted_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_attribute_changed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_contact_attribute_changed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_add_reachable_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_send_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_receive_started_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_received_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_transmitted_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_cancel_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_canceled_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_bundle_queued_ (f | ::xml_schema::flags::not_root, this), + _xsd_report_bundle_queued_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_eid_reachable_ (f | ::xml_schema::flags::not_root, this), + _xsd_report_eid_reachable_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_link_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_report_link_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_interface_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_report_interface_attributes_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_cla_parameters_ (f | ::xml_schema::flags::not_root, this), + _xsd_report_cla_parameters_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void cl_message:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // cla_add_request + // + { + if (e.name () == "cla_add_request" && e.namespace_ () == "") + { + ::std::auto_ptr< cla_add_request::type > r ( + cla_add_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->cla_add_request ()) + continue; + this->cla_add_request (r); + continue; + } + } + + // cla_delete_request + // + { + if (e.name () == "cla_delete_request" && e.namespace_ () == "") + { + ::std::auto_ptr< cla_delete_request::type > r ( + cla_delete_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->cla_delete_request ()) + continue; + this->cla_delete_request (r); + continue; + } + } + + // cla_set_params_request + // + { + if (e.name () == "cla_set_params_request" && e.namespace_ () == "") + { + ::std::auto_ptr< cla_set_params_request::type > r ( + cla_set_params_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->cla_set_params_request ()) + continue; + this->cla_set_params_request (r); + continue; + } + } + + // cla_params_set_event + // + { + if (e.name () == "cla_params_set_event" && e.namespace_ () == "") + { + ::std::auto_ptr< cla_params_set_event::type > r ( + cla_params_set_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->cla_params_set_event ()) + continue; + this->cla_params_set_event (r); + continue; + } + } + + // interface_set_defaults_request + // + { + if (e.name () == "interface_set_defaults_request" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_set_defaults_request::type > r ( + interface_set_defaults_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_set_defaults_request ()) + continue; + this->interface_set_defaults_request (r); + continue; + } + } + + // interface_create_request + // + { + if (e.name () == "interface_create_request" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_create_request::type > r ( + interface_create_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_create_request ()) + continue; + this->interface_create_request (r); + continue; + } + } + + // interface_created_event + // + { + if (e.name () == "interface_created_event" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_created_event::type > r ( + interface_created_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_created_event ()) + continue; + this->interface_created_event (r); + continue; + } + } + + // interface_reconfigure_request + // + { + if (e.name () == "interface_reconfigure_request" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_reconfigure_request::type > r ( + interface_reconfigure_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_reconfigure_request ()) + continue; + this->interface_reconfigure_request (r); + continue; + } + } + + // interface_reconfigured_event + // + { + if (e.name () == "interface_reconfigured_event" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_reconfigured_event::type > r ( + interface_reconfigured_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_reconfigured_event ()) + continue; + this->interface_reconfigured_event (r); + continue; + } + } + + // interface_destroy_request + // + { + if (e.name () == "interface_destroy_request" && e.namespace_ () == "") + { + ::std::auto_ptr< interface_destroy_request::type > r ( + interface_destroy_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->interface_destroy_request ()) + continue; + this->interface_destroy_request (r); + continue; + } + } + + // eid_reachable_event + // + { + if (e.name () == "eid_reachable_event" && e.namespace_ () == "") + { + ::std::auto_ptr< eid_reachable_event::type > r ( + eid_reachable_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->eid_reachable_event ()) + continue; + this->eid_reachable_event (r); + continue; + } + } + + // link_set_defaults_request + // + { + if (e.name () == "link_set_defaults_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_set_defaults_request::type > r ( + link_set_defaults_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_set_defaults_request ()) + continue; + this->link_set_defaults_request (r); + continue; + } + } + + // link_create_request + // + { + if (e.name () == "link_create_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_create_request::type > r ( + link_create_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_create_request ()) + continue; + this->link_create_request (r); + continue; + } + } + + // link_created_event + // + { + if (e.name () == "link_created_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_created_event::type > r ( + link_created_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_created_event ()) + continue; + this->link_created_event (r); + continue; + } + } + + // link_open_request + // + { + if (e.name () == "link_open_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_open_request::type > r ( + link_open_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_open_request ()) + continue; + this->link_open_request (r); + continue; + } + } + + // link_opened_event + // + { + if (e.name () == "link_opened_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_opened_event::type > r ( + link_opened_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_opened_event ()) + continue; + this->link_opened_event (r); + continue; + } + } + + // link_close_request + // + { + if (e.name () == "link_close_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_close_request::type > r ( + link_close_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_close_request ()) + continue; + this->link_close_request (r); + continue; + } + } + + // link_closed_event + // + { + if (e.name () == "link_closed_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_closed_event::type > r ( + link_closed_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_closed_event ()) + continue; + this->link_closed_event (r); + continue; + } + } + + // link_state_changed_event + // + { + if (e.name () == "link_state_changed_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_state_changed_event::type > r ( + link_state_changed_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_state_changed_event ()) + continue; + this->link_state_changed_event (r); + continue; + } + } + + // link_reconfigure_request + // + { + if (e.name () == "link_reconfigure_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_reconfigure_request::type > r ( + link_reconfigure_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_reconfigure_request ()) + continue; + this->link_reconfigure_request (r); + continue; + } + } + + // link_delete_request + // + { + if (e.name () == "link_delete_request" && e.namespace_ () == "") + { + ::std::auto_ptr< link_delete_request::type > r ( + link_delete_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_delete_request ()) + continue; + this->link_delete_request (r); + continue; + } + } + + // link_deleted_event + // + { + if (e.name () == "link_deleted_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_deleted_event::type > r ( + link_deleted_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_deleted_event ()) + continue; + this->link_deleted_event (r); + continue; + } + } + + // link_attribute_changed_event + // + { + if (e.name () == "link_attribute_changed_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_attribute_changed_event::type > r ( + link_attribute_changed_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_attribute_changed_event ()) + continue; + this->link_attribute_changed_event (r); + continue; + } + } + + // contact_attribute_changed_event + // + { + if (e.name () == "contact_attribute_changed_event" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_attribute_changed_event::type > r ( + contact_attribute_changed_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->contact_attribute_changed_event ()) + continue; + this->contact_attribute_changed_event (r); + continue; + } + } + + // link_add_reachable_event + // + { + if (e.name () == "link_add_reachable_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_add_reachable_event::type > r ( + link_add_reachable_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_add_reachable_event ()) + continue; + this->link_add_reachable_event (r); + continue; + } + } + + // bundle_send_request + // + { + if (e.name () == "bundle_send_request" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_send_request::type > r ( + bundle_send_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_send_request ()) + continue; + this->bundle_send_request (r); + continue; + } + } + + // bundle_receive_started_event + // + { + if (e.name () == "bundle_receive_started_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_receive_started_event::type > r ( + bundle_receive_started_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_receive_started_event ()) + continue; + this->bundle_receive_started_event (r); + continue; + } + } + + // bundle_received_event + // + { + if (e.name () == "bundle_received_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_received_event::type > r ( + bundle_received_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_received_event ()) + continue; + this->bundle_received_event (r); + continue; + } + } + + // bundle_transmitted_event + // + { + if (e.name () == "bundle_transmitted_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_transmitted_event::type > r ( + bundle_transmitted_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_transmitted_event ()) + continue; + this->bundle_transmitted_event (r); + continue; + } + } + + // bundle_cancel_request + // + { + if (e.name () == "bundle_cancel_request" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_cancel_request::type > r ( + bundle_cancel_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_cancel_request ()) + continue; + this->bundle_cancel_request (r); + continue; + } + } + + // bundle_canceled_event + // + { + if (e.name () == "bundle_canceled_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_canceled_event::type > r ( + bundle_canceled_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_canceled_event ()) + continue; + this->bundle_canceled_event (r); + continue; + } + } + + // query_bundle_queued + // + { + if (e.name () == "query_bundle_queued" && e.namespace_ () == "") + { + ::std::auto_ptr< query_bundle_queued::type > r ( + query_bundle_queued::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query_bundle_queued ()) + continue; + this->query_bundle_queued (r); + continue; + } + } + + // report_bundle_queued + // + { + if (e.name () == "report_bundle_queued" && e.namespace_ () == "") + { + ::std::auto_ptr< report_bundle_queued::type > r ( + report_bundle_queued::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->report_bundle_queued ()) + continue; + this->report_bundle_queued (r); + continue; + } + } + + // query_eid_reachable + // + { + if (e.name () == "query_eid_reachable" && e.namespace_ () == "") + { + ::std::auto_ptr< query_eid_reachable::type > r ( + query_eid_reachable::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query_eid_reachable ()) + continue; + this->query_eid_reachable (r); + continue; + } + } + + // report_eid_reachable + // + { + if (e.name () == "report_eid_reachable" && e.namespace_ () == "") + { + ::std::auto_ptr< report_eid_reachable::type > r ( + report_eid_reachable::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->report_eid_reachable ()) + continue; + this->report_eid_reachable (r); + continue; + } + } + + // query_link_attributes + // + { + if (e.name () == "query_link_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< query_link_attributes::type > r ( + query_link_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query_link_attributes ()) + continue; + this->query_link_attributes (r); + continue; + } + } + + // report_link_attributes + // + { + if (e.name () == "report_link_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< report_link_attributes::type > r ( + report_link_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->report_link_attributes ()) + continue; + this->report_link_attributes (r); + continue; + } + } + + // query_interface_attributes + // + { + if (e.name () == "query_interface_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< query_interface_attributes::type > r ( + query_interface_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query_interface_attributes ()) + continue; + this->query_interface_attributes (r); + continue; + } + } + + // report_interface_attributes + // + { + if (e.name () == "report_interface_attributes" && e.namespace_ () == "") + { + ::std::auto_ptr< report_interface_attributes::type > r ( + report_interface_attributes::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->report_interface_attributes ()) + continue; + this->report_interface_attributes (r); + continue; + } + } + + // query_cla_parameters + // + { + if (e.name () == "query_cla_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< query_cla_parameters::type > r ( + query_cla_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query_cla_parameters ()) + continue; + this->query_cla_parameters (r); + continue; + } + } + + // report_cla_parameters + // + { + if (e.name () == "report_cla_parameters" && e.namespace_ () == "") + { + ::std::auto_ptr< report_cla_parameters::type > r ( + report_cla_parameters::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->report_cla_parameters ()) + continue; + this->report_cla_parameters (r); + continue; + } + } + } + } + + cl_message* cl_message:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cl_message (*this, f, c); + } + } +} + +#include +#include +#include +#include + +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 +#include +#include +#include + +namespace dtn +{ + namespace clmessage + { + void + operator<< (::xercesc::DOMElement& e, + linkTypeType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + linkTypeType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + linkTypeType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + linkStateType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + linkStateType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + linkStateType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + linkReasonType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + linkReasonType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + linkReasonType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + bundlePassMethodType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + bundlePassMethodType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + bundlePassMethodType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + const percentType& i) + { + e << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + const percentType& i) + { + a << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + const percentType& i) + { + l << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::integer, char, ::xml_schema::simple_type >& > (i); + } + + void + cl_message_ (::xercesc::DOMDocument& d, + const ::dtn::clmessage::cl_message& s, + ::xml_schema::flags) + { + ::xsd::cxx::xml::dom::element< char > e (*d.getDocumentElement ()); + + if (e.name () == "cl_message" && + e.namespace_ () == "") + { + e.dom_element () << s; + } + else + { + throw ::xsd::cxx::tree::unexpected_element < char > ( + e.name (), + e.namespace_ (), + "cl_message", + ""); + } + } + + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > + cl_message_ (const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + ::xml_schema::flags f) + { + try + { + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::serialize< char > ( + "cl_message", + "", + m, + f)); + ::dtn::clmessage::cl_message_ (*d, s, f); + return d; + } + catch (const ::xsd::cxx::xml::dom::mapping< char >& e) + { + throw ::xsd::cxx::tree::no_namespace_mapping< char > (e.name ()); + } + catch (const ::xsd::cxx::xml::dom::xsi_already_in_use&) + { + throw ::xsd::cxx::tree::xsi_already_in_use< char > (); + } + } + + void + cl_message_ (::xercesc::XMLFormatTarget& t, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + + ::xsd::cxx::tree::error_handler< char > h; + + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > (); + } + } + + void + cl_message_ (::xercesc::XMLFormatTarget& t, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + ::xsd::cxx::xml::error_handler< char >& h, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + cl_message_ (::xercesc::XMLFormatTarget& t, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + ::xercesc::DOMErrorHandler& h, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + cl_message_ (::std::ostream& o, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0); + + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + + ::xsd::cxx::tree::error_handler< char > h; + + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > (); + } + } + + void + cl_message_ (::std::ostream& o, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + ::xsd::cxx::xml::error_handler< char >& h, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0); + + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + cl_message_ (::std::ostream& o, + const ::dtn::clmessage::cl_message& s, + const ::xsd::cxx::xml::dom::namespace_infomap< char >& m, + ::xercesc::DOMErrorHandler& h, + const ::std::basic_string< char >& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::dtn::clmessage::cl_message_ (s, m, f)); + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const attribute_name& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "value", + e); + + a.dom_attribute () << i.value (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const key_value_pair& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "name", + e); + + a.dom_attribute () << i.name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "value", + e); + + a.dom_attribute () << i.value (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "source_eid", + e); + + a.dom_attribute () << i.source_eid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "timestamp_seconds", + e); + + a.dom_attribute () << i.timestamp_seconds (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "timestamp_sequence", + e); + + a.dom_attribute () << i.timestamp_sequence (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_fragment", + e); + + a.dom_attribute () << i.is_fragment (); + } + + if (i.fragment_length ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "fragment_length", + e); + + a.dom_attribute () << *i.fragment_length (); + } + + if (i.fragment_offset ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "fragment_offset", + e); + + a.dom_attribute () << *i.fragment_offset (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (link_attributes::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + if (i.type ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "type", + e); + + a.dom_attribute () << *i.type (); + } + + if (i.state ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "state", + e); + + a.dom_attribute () << *i.state (); + } + + if (i.peer_eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << *i.peer_eid (); + } + + if (i.is_reachable ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_reachable", + e); + + a.dom_attribute () << *i.is_reachable (); + } + + if (i.is_usable ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_usable", + e); + + a.dom_attribute () << *i.is_usable (); + } + + if (i.how_reliable ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "how_reliable", + e); + + a.dom_attribute () << *i.how_reliable (); + } + + if (i.how_available ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "how_available", + e); + + a.dom_attribute () << *i.how_available (); + } + + if (i.reactive_fragment ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reactive_fragment", + e); + + a.dom_attribute () << *i.reactive_fragment (); + } + + if (i.nexthop ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "nexthop", + e); + + a.dom_attribute () << *i.nexthop (); + } + + if (i.cla_name ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "cla_name", + e); + + a.dom_attribute () << *i.cla_name (); + } + + if (i.high_water_mark ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "high_water_mark", + e); + + a.dom_attribute () << *i.high_water_mark (); + } + + if (i.low_water_mark ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "low_water_mark", + e); + + a.dom_attribute () << *i.low_water_mark (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_config_parameters& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (link_config_parameters::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + if (i.is_usable ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_usable", + e); + + a.dom_attribute () << *i.is_usable (); + } + + if (i.reactive_fragment ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reactive_fragment", + e); + + a.dom_attribute () << *i.reactive_fragment (); + } + + if (i.nexthop ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "nexthop", + e); + + a.dom_attribute () << *i.nexthop (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const contact_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "start_time", + e); + + a.dom_attribute () << i.start_time (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "duration", + e); + + a.dom_attribute () << i.duration (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bps", + e); + + a.dom_attribute () << i.bps (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "latency", + e); + + a.dom_attribute () << i.latency (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "packet_loss_prob", + e); + + a.dom_attribute () << i.packet_loss_prob (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cla_add_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "name", + e); + + a.dom_attribute () << i.name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cla_delete_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "name", + e); + + a.dom_attribute () << i.name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cla_set_params_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (cla_set_params_request::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + if (i.local_eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_eid", + e); + + a.dom_attribute () << *i.local_eid (); + } + + if (i.create_discovered_links ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "create_discovered_links", + e); + + a.dom_attribute () << *i.create_discovered_links (); + } + + if (i.bundle_pass_method ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bundle_pass_method", + e); + + a.dom_attribute () << *i.bundle_pass_method (); + } + + if (i.reactive_fragment_enabled ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reactive_fragment_enabled", + e); + + a.dom_attribute () << *i.reactive_fragment_enabled (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cla_params_set_event&) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + } + + void + operator<< (::xercesc::DOMAttr&, + const cla_params_set_event&) + { + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >&, + const cla_params_set_event&) + { + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_set_defaults_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (interface_set_defaults_request::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_create_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (interface_create_request::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_created_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_reconfigure_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (interface_reconfigure_request::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + + if (i.up ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "up", + e); + + a.dom_attribute () << *i.up (); + } + + if (i.discovery ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "discovery", + e); + + a.dom_attribute () << *i.discovery (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_reconfigured_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const interface_destroy_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const eid_reachable_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_set_defaults_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_parameters", + e); + s.dom_element () << i.link_config_parameters (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_create_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_parameters", + e); + s.dom_element () << i.link_config_parameters (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "type", + e); + + a.dom_attribute () << i.type (); + } + + if (i.peer_eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << *i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_created_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attributes", + e); + s.dom_element () << i.link_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_open_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_opened_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_attributes", + e); + s.dom_element () << i.contact_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_close_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_closed_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_attributes", + e); + s.dom_element () << i.contact_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_state_changed_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "new_state", + e); + + a.dom_attribute () << i.new_state (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_reconfigure_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_parameters", + e); + s.dom_element () << i.link_config_parameters (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_delete_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_deleted_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_attribute_changed_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attributes", + e); + s.dom_element () << i.link_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const contact_attribute_changed_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_attributes", + e); + s.dom_element () << i.contact_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_add_reachable_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_parameters", + e); + s.dom_element () << i.link_config_parameters (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_send_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes", + e); + s.dom_element () << i.bundle_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "location", + e); + + a.dom_attribute () << i.location (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_receive_started_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "location", + e); + + a.dom_attribute () << i.location (); + } + + if (i.peer_eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << *i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_received_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "location", + e); + + a.dom_attribute () << i.location (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bytes_received", + e); + + a.dom_attribute () << i.bytes_received (); + } + + if (i.peer_eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << *i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_transmitted_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes", + e); + s.dom_element () << i.bundle_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bytes_sent", + e); + + a.dom_attribute () << i.bytes_sent (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reliably_sent", + e); + + a.dom_attribute () << i.reliably_sent (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_cancel_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes", + e); + s.dom_element () << i.bundle_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_canceled_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes", + e); + s.dom_element () << i.bundle_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const query_bundle_queued& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes", + e); + s.dom_element () << i.bundle_attributes (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const report_bundle_queued& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_queued", + e); + + a.dom_attribute () << i.is_queued (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const query_eid_reachable& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "peer_eid", + e); + + a.dom_attribute () << i.peer_eid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const report_eid_reachable& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_reachable", + e); + + a.dom_attribute () << i.is_reachable (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const query_link_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (query_link_attributes::attribute_name::const_iterator + b (i.attribute_name ().begin ()), n (i.attribute_name ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "attribute_name", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_name", + e); + + a.dom_attribute () << i.link_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const report_link_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (report_link_attributes::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const query_interface_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (query_interface_attributes::attribute_name::const_iterator + b (i.attribute_name ().begin ()), n (i.attribute_name ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "attribute_name", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const report_interface_attributes& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (report_interface_attributes::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const query_cla_parameters& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (query_cla_parameters::attribute_name::const_iterator + b (i.attribute_name ().begin ()), n (i.attribute_name ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "attribute_name", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const report_cla_parameters& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (report_cla_parameters::key_value_pair::const_iterator + b (i.key_value_pair ().begin ()), n (i.key_value_pair ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "key_value_pair", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "query_id", + e); + + a.dom_attribute () << i.query_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cl_message& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.cla_add_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cla_add_request", + e); + s.dom_element () << *i.cla_add_request (); + } + } + + { + if (i.cla_delete_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cla_delete_request", + e); + s.dom_element () << *i.cla_delete_request (); + } + } + + { + if (i.cla_set_params_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cla_set_params_request", + e); + s.dom_element () << *i.cla_set_params_request (); + } + } + + { + if (i.cla_params_set_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cla_params_set_event", + e); + s.dom_element () << *i.cla_params_set_event (); + } + } + + { + if (i.interface_set_defaults_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_set_defaults_request", + e); + s.dom_element () << *i.interface_set_defaults_request (); + } + } + + { + if (i.interface_create_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_create_request", + e); + s.dom_element () << *i.interface_create_request (); + } + } + + { + if (i.interface_created_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_created_event", + e); + s.dom_element () << *i.interface_created_event (); + } + } + + { + if (i.interface_reconfigure_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_reconfigure_request", + e); + s.dom_element () << *i.interface_reconfigure_request (); + } + } + + { + if (i.interface_reconfigured_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_reconfigured_event", + e); + s.dom_element () << *i.interface_reconfigured_event (); + } + } + + { + if (i.interface_destroy_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "interface_destroy_request", + e); + s.dom_element () << *i.interface_destroy_request (); + } + } + + { + if (i.eid_reachable_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "eid_reachable_event", + e); + s.dom_element () << *i.eid_reachable_event (); + } + } + + { + if (i.link_set_defaults_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_set_defaults_request", + e); + s.dom_element () << *i.link_set_defaults_request (); + } + } + + { + if (i.link_create_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_create_request", + e); + s.dom_element () << *i.link_create_request (); + } + } + + { + if (i.link_created_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_created_event", + e); + s.dom_element () << *i.link_created_event (); + } + } + + { + if (i.link_open_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_open_request", + e); + s.dom_element () << *i.link_open_request (); + } + } + + { + if (i.link_opened_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_opened_event", + e); + s.dom_element () << *i.link_opened_event (); + } + } + + { + if (i.link_close_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_close_request", + e); + s.dom_element () << *i.link_close_request (); + } + } + + { + if (i.link_closed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_closed_event", + e); + s.dom_element () << *i.link_closed_event (); + } + } + + { + if (i.link_state_changed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_state_changed_event", + e); + s.dom_element () << *i.link_state_changed_event (); + } + } + + { + if (i.link_reconfigure_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_reconfigure_request", + e); + s.dom_element () << *i.link_reconfigure_request (); + } + } + + { + if (i.link_delete_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_delete_request", + e); + s.dom_element () << *i.link_delete_request (); + } + } + + { + if (i.link_deleted_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_deleted_event", + e); + s.dom_element () << *i.link_deleted_event (); + } + } + + { + if (i.link_attribute_changed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attribute_changed_event", + e); + s.dom_element () << *i.link_attribute_changed_event (); + } + } + + { + if (i.contact_attribute_changed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_attribute_changed_event", + e); + s.dom_element () << *i.contact_attribute_changed_event (); + } + } + + { + if (i.link_add_reachable_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_add_reachable_event", + e); + s.dom_element () << *i.link_add_reachable_event (); + } + } + + { + if (i.bundle_send_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_send_request", + e); + s.dom_element () << *i.bundle_send_request (); + } + } + + { + if (i.bundle_receive_started_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_receive_started_event", + e); + s.dom_element () << *i.bundle_receive_started_event (); + } + } + + { + if (i.bundle_received_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_received_event", + e); + s.dom_element () << *i.bundle_received_event (); + } + } + + { + if (i.bundle_transmitted_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_transmitted_event", + e); + s.dom_element () << *i.bundle_transmitted_event (); + } + } + + { + if (i.bundle_cancel_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_cancel_request", + e); + s.dom_element () << *i.bundle_cancel_request (); + } + } + + { + if (i.bundle_canceled_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_canceled_event", + e); + s.dom_element () << *i.bundle_canceled_event (); + } + } + + { + if (i.query_bundle_queued ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_bundle_queued", + e); + s.dom_element () << *i.query_bundle_queued (); + } + } + + { + if (i.report_bundle_queued ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_bundle_queued", + e); + s.dom_element () << *i.report_bundle_queued (); + } + } + + { + if (i.query_eid_reachable ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_eid_reachable", + e); + s.dom_element () << *i.query_eid_reachable (); + } + } + + { + if (i.report_eid_reachable ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_eid_reachable", + e); + s.dom_element () << *i.report_eid_reachable (); + } + } + + { + if (i.query_link_attributes ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_link_attributes", + e); + s.dom_element () << *i.query_link_attributes (); + } + } + + { + if (i.report_link_attributes ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_link_attributes", + e); + s.dom_element () << *i.report_link_attributes (); + } + } + + { + if (i.query_interface_attributes ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_interface_attributes", + e); + s.dom_element () << *i.query_interface_attributes (); + } + } + + { + if (i.report_interface_attributes ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_interface_attributes", + e); + s.dom_element () << *i.report_interface_attributes (); + } + } + + { + if (i.query_cla_parameters ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_cla_parameters", + e); + s.dom_element () << *i.query_cla_parameters (); + } + } + + { + if (i.report_cla_parameters ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_cla_parameters", + e); + s.dom_element () << *i.report_cla_parameters (); + } + } + } + } +} + +#include + +// Begin epilogue. +// +#endif +// +// End epilogue. +