diff -r 000000000000 -r 2b3e5ec03512 servlib/routing/router.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servlib/routing/router.cc Thu Apr 21 14:57:45 2011 +0100 @@ -0,0 +1,24342 @@ +// 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_DP_ENABLED) +// +// End prologue. + +#include + +#include "router.h" + +namespace dtn +{ + namespace rtrmessage + { + // dtnStatusType + // + + dtnStatusType:: + dtnStatusType () + : ::xml_schema::string () + { + } + + dtnStatusType:: + dtnStatusType (_xsd_dtnStatusType v) + : ::xml_schema::string (_xsd_dtnStatusType_literals_[v]) + { + } + + dtnStatusType:: + dtnStatusType (const ::xml_schema::string& _xsd_dtnStatusType) + : ::xml_schema::string (_xsd_dtnStatusType) + { + } + + dtnStatusType:: + dtnStatusType (const dtnStatusType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + dtnStatusType& dtnStatusType:: + operator= (_xsd_dtnStatusType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_dtnStatusType_literals_[v]); + + return *this; + } + + + // bundlePriorityType + // + + bundlePriorityType:: + bundlePriorityType () + : ::xml_schema::string () + { + } + + bundlePriorityType:: + bundlePriorityType (_xsd_bundlePriorityType v) + : ::xml_schema::string (_xsd_bundlePriorityType_literals_[v]) + { + } + + bundlePriorityType:: + bundlePriorityType (const ::xml_schema::string& _xsd_bundlePriorityType) + : ::xml_schema::string (_xsd_bundlePriorityType) + { + } + + bundlePriorityType:: + bundlePriorityType (const bundlePriorityType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + bundlePriorityType& bundlePriorityType:: + operator= (_xsd_bundlePriorityType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_bundlePriorityType_literals_[v]); + + return *this; + } + + + // eventSourceType + // + + eventSourceType:: + eventSourceType () + : ::xml_schema::string () + { + } + + eventSourceType:: + eventSourceType (_xsd_eventSourceType v) + : ::xml_schema::string (_xsd_eventSourceType_literals_[v]) + { + } + + eventSourceType:: + eventSourceType (const ::xml_schema::string& _xsd_eventSourceType) + : ::xml_schema::string (_xsd_eventSourceType) + { + } + + eventSourceType:: + eventSourceType (const eventSourceType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + eventSourceType& eventSourceType:: + operator= (_xsd_eventSourceType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_eventSourceType_literals_[v]); + + return *this; + } + + + // bundleForwardActionType + // + + bundleForwardActionType:: + bundleForwardActionType () + : ::xml_schema::string () + { + } + + bundleForwardActionType:: + bundleForwardActionType (_xsd_bundleForwardActionType v) + : ::xml_schema::string (_xsd_bundleForwardActionType_literals_[v]) + { + } + + bundleForwardActionType:: + bundleForwardActionType (const ::xml_schema::string& _xsd_bundleForwardActionType) + : ::xml_schema::string (_xsd_bundleForwardActionType) + { + } + + bundleForwardActionType:: + bundleForwardActionType (const bundleForwardActionType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + bundleForwardActionType& bundleForwardActionType:: + operator= (_xsd_bundleForwardActionType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_bundleForwardActionType_literals_[v]); + + return *this; + } + + + // contactReasonType + // + + contactReasonType:: + contactReasonType () + : ::xml_schema::string () + { + } + + contactReasonType:: + contactReasonType (_xsd_contactReasonType v) + : ::xml_schema::string (_xsd_contactReasonType_literals_[v]) + { + } + + contactReasonType:: + contactReasonType (const ::xml_schema::string& _xsd_contactReasonType) + : ::xml_schema::string (_xsd_contactReasonType) + { + } + + contactReasonType:: + contactReasonType (const contactReasonType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + contactReasonType& contactReasonType:: + operator= (_xsd_contactReasonType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_contactReasonType_literals_[v]); + + return *this; + } + + + // 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; + } + + + // eidTypeType + // + + eidTypeType:: + eidTypeType () + : ::xml_schema::string () + { + } + + eidTypeType:: + eidTypeType (const ::std::basic_string< char >& s) + : ::xml_schema::string (s) + { + } + + eidTypeType:: + eidTypeType (const eidTypeType& o, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (o, f, c) + { + } + + // percentType + // + + + // failureActionType + // + + failureActionType:: + failureActionType () + : ::xml_schema::string () + { + } + + failureActionType:: + failureActionType (_xsd_failureActionType v) + : ::xml_schema::string (_xsd_failureActionType_literals_[v]) + { + } + + failureActionType:: + failureActionType (const ::xml_schema::string& _xsd_failureActionType) + : ::xml_schema::string (_xsd_failureActionType) + { + } + + failureActionType:: + failureActionType (const failureActionType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + failureActionType& failureActionType:: + operator= (_xsd_failureActionType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_failureActionType_literals_[v]); + + return *this; + } + + + // bundleLocationType + // + + bundleLocationType:: + bundleLocationType () + : ::xml_schema::string () + { + } + + bundleLocationType:: + bundleLocationType (_xsd_bundleLocationType v) + : ::xml_schema::string (_xsd_bundleLocationType_literals_[v]) + { + } + + bundleLocationType:: + bundleLocationType (const ::xml_schema::string& _xsd_bundleLocationType) + : ::xml_schema::string (_xsd_bundleLocationType) + { + } + + bundleLocationType:: + bundleLocationType (const bundleLocationType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + bundleLocationType& bundleLocationType:: + operator= (_xsd_bundleLocationType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_bundleLocationType_literals_[v]); + + return *this; + } + + + // eidType_base + // + + const eidType_base::uri::type& eidType_base:: + uri () const + { + return this->_xsd_uri_.get (); + } + + eidType_base::uri::type& eidType_base:: + uri () + { + return this->_xsd_uri_.get (); + } + + void eidType_base:: + uri (const uri::type& uri) + { + this->_xsd_uri_.set (uri); + } + + void eidType_base:: + uri (::std::auto_ptr< uri::type > uri) + { + this->_xsd_uri_.set (uri); + } + + + // gbofIdType_base + // + + const gbofIdType_base::source::type& gbofIdType_base:: + source () const + { + return this->_xsd_source_.get (); + } + + gbofIdType_base::source::type& gbofIdType_base:: + source () + { + return this->_xsd_source_.get (); + } + + void gbofIdType_base:: + source (const source::type& source) + { + this->_xsd_source_.set (source); + } + + void gbofIdType_base:: + source (::std::auto_ptr< source::type > source) + { + this->_xsd_source_.set (source); + } + + const gbofIdType_base::creation_ts::type& gbofIdType_base:: + creation_ts () const + { + return this->_xsd_creation_ts_.get (); + } + + gbofIdType_base::creation_ts::type& gbofIdType_base:: + creation_ts () + { + return this->_xsd_creation_ts_.get (); + } + + void gbofIdType_base:: + creation_ts (const creation_ts::type& creation_ts) + { + this->_xsd_creation_ts_.set (creation_ts); + } + + const gbofIdType_base::is_fragment::type& gbofIdType_base:: + is_fragment () const + { + return this->_xsd_is_fragment_.get (); + } + + gbofIdType_base::is_fragment::type& gbofIdType_base:: + is_fragment () + { + return this->_xsd_is_fragment_.get (); + } + + void gbofIdType_base:: + is_fragment (const is_fragment::type& is_fragment) + { + this->_xsd_is_fragment_.set (is_fragment); + } + + const gbofIdType_base::frag_length::type& gbofIdType_base:: + frag_length () const + { + return this->_xsd_frag_length_.get (); + } + + gbofIdType_base::frag_length::type& gbofIdType_base:: + frag_length () + { + return this->_xsd_frag_length_.get (); + } + + void gbofIdType_base:: + frag_length (const frag_length::type& frag_length) + { + this->_xsd_frag_length_.set (frag_length); + } + + const gbofIdType_base::frag_offset::type& gbofIdType_base:: + frag_offset () const + { + return this->_xsd_frag_offset_.get (); + } + + gbofIdType_base::frag_offset::type& gbofIdType_base:: + frag_offset () + { + return this->_xsd_frag_offset_.get (); + } + + void gbofIdType_base:: + frag_offset (const frag_offset::type& frag_offset) + { + this->_xsd_frag_offset_.set (frag_offset); + } + + + // bundleType_base + // + + const bundleType_base::source::type& bundleType_base:: + source () const + { + return this->_xsd_source_.get (); + } + + bundleType_base::source::type& bundleType_base:: + source () + { + return this->_xsd_source_.get (); + } + + void bundleType_base:: + source (const source::type& source) + { + this->_xsd_source_.set (source); + } + + void bundleType_base:: + source (::std::auto_ptr< source::type > source) + { + this->_xsd_source_.set (source); + } + + const bundleType_base::dest::type& bundleType_base:: + dest () const + { + return this->_xsd_dest_.get (); + } + + bundleType_base::dest::type& bundleType_base:: + dest () + { + return this->_xsd_dest_.get (); + } + + void bundleType_base:: + dest (const dest::type& dest) + { + this->_xsd_dest_.set (dest); + } + + void bundleType_base:: + dest (::std::auto_ptr< dest::type > dest) + { + this->_xsd_dest_.set (dest); + } + + const bundleType_base::custodian::type& bundleType_base:: + custodian () const + { + return this->_xsd_custodian_.get (); + } + + bundleType_base::custodian::type& bundleType_base:: + custodian () + { + return this->_xsd_custodian_.get (); + } + + void bundleType_base:: + custodian (const custodian::type& custodian) + { + this->_xsd_custodian_.set (custodian); + } + + void bundleType_base:: + custodian (::std::auto_ptr< custodian::type > custodian) + { + this->_xsd_custodian_.set (custodian); + } + + const bundleType_base::replyto::type& bundleType_base:: + replyto () const + { + return this->_xsd_replyto_.get (); + } + + bundleType_base::replyto::type& bundleType_base:: + replyto () + { + return this->_xsd_replyto_.get (); + } + + void bundleType_base:: + replyto (const replyto::type& replyto) + { + this->_xsd_replyto_.set (replyto); + } + + void bundleType_base:: + replyto (::std::auto_ptr< replyto::type > replyto) + { + this->_xsd_replyto_.set (replyto); + } + + const bundleType_base::prevhop::type& bundleType_base:: + prevhop () const + { + return this->_xsd_prevhop_.get (); + } + + bundleType_base::prevhop::type& bundleType_base:: + prevhop () + { + return this->_xsd_prevhop_.get (); + } + + void bundleType_base:: + prevhop (const prevhop::type& prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + void bundleType_base:: + prevhop (::std::auto_ptr< prevhop::type > prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + const bundleType_base::length::type& bundleType_base:: + length () const + { + return this->_xsd_length_.get (); + } + + bundleType_base::length::type& bundleType_base:: + length () + { + return this->_xsd_length_.get (); + } + + void bundleType_base:: + length (const length::type& length) + { + this->_xsd_length_.set (length); + } + + const bundleType_base::location::type& bundleType_base:: + location () const + { + return this->_xsd_location_.get (); + } + + bundleType_base::location::type& bundleType_base:: + location () + { + return this->_xsd_location_.get (); + } + + void bundleType_base:: + location (const location::type& location) + { + this->_xsd_location_.set (location); + } + + void bundleType_base:: + location (::std::auto_ptr< location::type > location) + { + this->_xsd_location_.set (location); + } + + const bundleType_base::payload_file::container& bundleType_base:: + payload_file () const + { + return this->_xsd_payload_file_; + } + + bundleType_base::payload_file::container& bundleType_base:: + payload_file () + { + return this->_xsd_payload_file_; + } + + void bundleType_base:: + payload_file (const payload_file::type& payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + void bundleType_base:: + payload_file (const payload_file::container& payload_file) + { + this->_xsd_payload_file_ = payload_file; + } + + void bundleType_base:: + payload_file (::std::auto_ptr< payload_file::type > payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + const bundleType_base::bundleid::type& bundleType_base:: + bundleid () const + { + return this->_xsd_bundleid_.get (); + } + + bundleType_base::bundleid::type& bundleType_base:: + bundleid () + { + return this->_xsd_bundleid_.get (); + } + + void bundleType_base:: + bundleid (const bundleid::type& bundleid) + { + this->_xsd_bundleid_.set (bundleid); + } + + const bundleType_base::is_fragment::type& bundleType_base:: + is_fragment () const + { + return this->_xsd_is_fragment_.get (); + } + + bundleType_base::is_fragment::type& bundleType_base:: + is_fragment () + { + return this->_xsd_is_fragment_.get (); + } + + void bundleType_base:: + is_fragment (const is_fragment::type& is_fragment) + { + this->_xsd_is_fragment_.set (is_fragment); + } + + const bundleType_base::is_admin::type& bundleType_base:: + is_admin () const + { + return this->_xsd_is_admin_.get (); + } + + bundleType_base::is_admin::type& bundleType_base:: + is_admin () + { + return this->_xsd_is_admin_.get (); + } + + void bundleType_base:: + is_admin (const is_admin::type& is_admin) + { + this->_xsd_is_admin_.set (is_admin); + } + + const bundleType_base::do_not_fragment::type& bundleType_base:: + do_not_fragment () const + { + return this->_xsd_do_not_fragment_.get (); + } + + bundleType_base::do_not_fragment::type& bundleType_base:: + do_not_fragment () + { + return this->_xsd_do_not_fragment_.get (); + } + + void bundleType_base:: + do_not_fragment (const do_not_fragment::type& do_not_fragment) + { + this->_xsd_do_not_fragment_.set (do_not_fragment); + } + + const bundleType_base::priority::type& bundleType_base:: + priority () const + { + return this->_xsd_priority_.get (); + } + + bundleType_base::priority::type& bundleType_base:: + priority () + { + return this->_xsd_priority_.get (); + } + + void bundleType_base:: + priority (const priority::type& priority) + { + this->_xsd_priority_.set (priority); + } + + void bundleType_base:: + priority (::std::auto_ptr< priority::type > priority) + { + this->_xsd_priority_.set (priority); + } + + const bundleType_base::custody_requested::type& bundleType_base:: + custody_requested () const + { + return this->_xsd_custody_requested_.get (); + } + + bundleType_base::custody_requested::type& bundleType_base:: + custody_requested () + { + return this->_xsd_custody_requested_.get (); + } + + void bundleType_base:: + custody_requested (const custody_requested::type& custody_requested) + { + this->_xsd_custody_requested_.set (custody_requested); + } + + const bundleType_base::local_custody::type& bundleType_base:: + local_custody () const + { + return this->_xsd_local_custody_.get (); + } + + bundleType_base::local_custody::type& bundleType_base:: + local_custody () + { + return this->_xsd_local_custody_.get (); + } + + void bundleType_base:: + local_custody (const local_custody::type& local_custody) + { + this->_xsd_local_custody_.set (local_custody); + } + + const bundleType_base::singleton_dest::type& bundleType_base:: + singleton_dest () const + { + return this->_xsd_singleton_dest_.get (); + } + + bundleType_base::singleton_dest::type& bundleType_base:: + singleton_dest () + { + return this->_xsd_singleton_dest_.get (); + } + + void bundleType_base:: + singleton_dest (const singleton_dest::type& singleton_dest) + { + this->_xsd_singleton_dest_.set (singleton_dest); + } + + const bundleType_base::custody_rcpt::type& bundleType_base:: + custody_rcpt () const + { + return this->_xsd_custody_rcpt_.get (); + } + + bundleType_base::custody_rcpt::type& bundleType_base:: + custody_rcpt () + { + return this->_xsd_custody_rcpt_.get (); + } + + void bundleType_base:: + custody_rcpt (const custody_rcpt::type& custody_rcpt) + { + this->_xsd_custody_rcpt_.set (custody_rcpt); + } + + const bundleType_base::receive_rcpt::type& bundleType_base:: + receive_rcpt () const + { + return this->_xsd_receive_rcpt_.get (); + } + + bundleType_base::receive_rcpt::type& bundleType_base:: + receive_rcpt () + { + return this->_xsd_receive_rcpt_.get (); + } + + void bundleType_base:: + receive_rcpt (const receive_rcpt::type& receive_rcpt) + { + this->_xsd_receive_rcpt_.set (receive_rcpt); + } + + const bundleType_base::forward_rcpt::type& bundleType_base:: + forward_rcpt () const + { + return this->_xsd_forward_rcpt_.get (); + } + + bundleType_base::forward_rcpt::type& bundleType_base:: + forward_rcpt () + { + return this->_xsd_forward_rcpt_.get (); + } + + void bundleType_base:: + forward_rcpt (const forward_rcpt::type& forward_rcpt) + { + this->_xsd_forward_rcpt_.set (forward_rcpt); + } + + const bundleType_base::delivery_rcpt::type& bundleType_base:: + delivery_rcpt () const + { + return this->_xsd_delivery_rcpt_.get (); + } + + bundleType_base::delivery_rcpt::type& bundleType_base:: + delivery_rcpt () + { + return this->_xsd_delivery_rcpt_.get (); + } + + void bundleType_base:: + delivery_rcpt (const delivery_rcpt::type& delivery_rcpt) + { + this->_xsd_delivery_rcpt_.set (delivery_rcpt); + } + + const bundleType_base::deletion_rcpt::type& bundleType_base:: + deletion_rcpt () const + { + return this->_xsd_deletion_rcpt_.get (); + } + + bundleType_base::deletion_rcpt::type& bundleType_base:: + deletion_rcpt () + { + return this->_xsd_deletion_rcpt_.get (); + } + + void bundleType_base:: + deletion_rcpt (const deletion_rcpt::type& deletion_rcpt) + { + this->_xsd_deletion_rcpt_.set (deletion_rcpt); + } + + const bundleType_base::app_acked_rcpt::type& bundleType_base:: + app_acked_rcpt () const + { + return this->_xsd_app_acked_rcpt_.get (); + } + + bundleType_base::app_acked_rcpt::type& bundleType_base:: + app_acked_rcpt () + { + return this->_xsd_app_acked_rcpt_.get (); + } + + void bundleType_base:: + app_acked_rcpt (const app_acked_rcpt::type& app_acked_rcpt) + { + this->_xsd_app_acked_rcpt_.set (app_acked_rcpt); + } + + const bundleType_base::creation_ts_seconds::type& bundleType_base:: + creation_ts_seconds () const + { + return this->_xsd_creation_ts_seconds_.get (); + } + + bundleType_base::creation_ts_seconds::type& bundleType_base:: + creation_ts_seconds () + { + return this->_xsd_creation_ts_seconds_.get (); + } + + void bundleType_base:: + creation_ts_seconds (const creation_ts_seconds::type& creation_ts_seconds) + { + this->_xsd_creation_ts_seconds_.set (creation_ts_seconds); + } + + const bundleType_base::creation_ts_seqno::type& bundleType_base:: + creation_ts_seqno () const + { + return this->_xsd_creation_ts_seqno_.get (); + } + + bundleType_base::creation_ts_seqno::type& bundleType_base:: + creation_ts_seqno () + { + return this->_xsd_creation_ts_seqno_.get (); + } + + void bundleType_base:: + creation_ts_seqno (const creation_ts_seqno::type& creation_ts_seqno) + { + this->_xsd_creation_ts_seqno_.set (creation_ts_seqno); + } + + const bundleType_base::expiration::type& bundleType_base:: + expiration () const + { + return this->_xsd_expiration_.get (); + } + + bundleType_base::expiration::type& bundleType_base:: + expiration () + { + return this->_xsd_expiration_.get (); + } + + void bundleType_base:: + expiration (const expiration::type& expiration) + { + this->_xsd_expiration_.set (expiration); + } + + const bundleType_base::orig_length::type& bundleType_base:: + orig_length () const + { + return this->_xsd_orig_length_.get (); + } + + bundleType_base::orig_length::type& bundleType_base:: + orig_length () + { + return this->_xsd_orig_length_.get (); + } + + void bundleType_base:: + orig_length (const orig_length::type& orig_length) + { + this->_xsd_orig_length_.set (orig_length); + } + + const bundleType_base::frag_offset::type& bundleType_base:: + frag_offset () const + { + return this->_xsd_frag_offset_.get (); + } + + bundleType_base::frag_offset::type& bundleType_base:: + frag_offset () + { + return this->_xsd_frag_offset_.get (); + } + + void bundleType_base:: + frag_offset (const frag_offset::type& frag_offset) + { + this->_xsd_frag_offset_.set (frag_offset); + } + + const bundleType_base::owner::type& bundleType_base:: + owner () const + { + return this->_xsd_owner_.get (); + } + + bundleType_base::owner::type& bundleType_base:: + owner () + { + return this->_xsd_owner_.get (); + } + + void bundleType_base:: + owner (const owner::type& owner) + { + this->_xsd_owner_.set (owner); + } + + void bundleType_base:: + owner (::std::auto_ptr< owner::type > owner) + { + this->_xsd_owner_.set (owner); + } + + + // contactType_base + // + + const contactType_base::link_attr::type& contactType_base:: + link_attr () const + { + return this->_xsd_link_attr_.get (); + } + + contactType_base::link_attr::type& contactType_base:: + link_attr () + { + return this->_xsd_link_attr_.get (); + } + + void contactType_base:: + link_attr (const link_attr::type& link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + void contactType_base:: + link_attr (::std::auto_ptr< link_attr::type > link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + const contactType_base::start_time_sec::type& contactType_base:: + start_time_sec () const + { + return this->_xsd_start_time_sec_.get (); + } + + contactType_base::start_time_sec::type& contactType_base:: + start_time_sec () + { + return this->_xsd_start_time_sec_.get (); + } + + void contactType_base:: + start_time_sec (const start_time_sec::type& start_time_sec) + { + this->_xsd_start_time_sec_.set (start_time_sec); + } + + const contactType_base::start_time_usec::type& contactType_base:: + start_time_usec () const + { + return this->_xsd_start_time_usec_.get (); + } + + contactType_base::start_time_usec::type& contactType_base:: + start_time_usec () + { + return this->_xsd_start_time_usec_.get (); + } + + void contactType_base:: + start_time_usec (const start_time_usec::type& start_time_usec) + { + this->_xsd_start_time_usec_.set (start_time_usec); + } + + const contactType_base::duration::type& contactType_base:: + duration () const + { + return this->_xsd_duration_.get (); + } + + contactType_base::duration::type& contactType_base:: + duration () + { + return this->_xsd_duration_.get (); + } + + void contactType_base:: + duration (const duration::type& duration) + { + this->_xsd_duration_.set (duration); + } + + const contactType_base::bps::type& contactType_base:: + bps () const + { + return this->_xsd_bps_.get (); + } + + contactType_base::bps::type& contactType_base:: + bps () + { + return this->_xsd_bps_.get (); + } + + void contactType_base:: + bps (const bps::type& bps) + { + this->_xsd_bps_.set (bps); + } + + const contactType_base::latency::type& contactType_base:: + latency () const + { + return this->_xsd_latency_.get (); + } + + contactType_base::latency::type& contactType_base:: + latency () + { + return this->_xsd_latency_.get (); + } + + void contactType_base:: + latency (const latency::type& latency) + { + this->_xsd_latency_.set (latency); + } + + const contactType_base::pkt_loss_prob::type& contactType_base:: + pkt_loss_prob () const + { + return this->_xsd_pkt_loss_prob_.get (); + } + + contactType_base::pkt_loss_prob::type& contactType_base:: + pkt_loss_prob () + { + return this->_xsd_pkt_loss_prob_.get (); + } + + void contactType_base:: + pkt_loss_prob (const pkt_loss_prob::type& pkt_loss_prob) + { + this->_xsd_pkt_loss_prob_.set (pkt_loss_prob); + } + + void contactType_base:: + pkt_loss_prob (::std::auto_ptr< pkt_loss_prob::type > pkt_loss_prob) + { + this->_xsd_pkt_loss_prob_.set (pkt_loss_prob); + } + + + // clInfoType + // + + const clInfoType::local_addr::container& clInfoType:: + local_addr () const + { + return this->_xsd_local_addr_; + } + + clInfoType::local_addr::container& clInfoType:: + local_addr () + { + return this->_xsd_local_addr_; + } + + void clInfoType:: + local_addr (const local_addr::type& local_addr) + { + this->_xsd_local_addr_.set (local_addr); + } + + void clInfoType:: + local_addr (const local_addr::container& local_addr) + { + this->_xsd_local_addr_ = local_addr; + } + + void clInfoType:: + local_addr (::std::auto_ptr< local_addr::type > local_addr) + { + this->_xsd_local_addr_.set (local_addr); + } + + const clInfoType::remote_addr::container& clInfoType:: + remote_addr () const + { + return this->_xsd_remote_addr_; + } + + clInfoType::remote_addr::container& clInfoType:: + remote_addr () + { + return this->_xsd_remote_addr_; + } + + void clInfoType:: + remote_addr (const remote_addr::type& remote_addr) + { + this->_xsd_remote_addr_.set (remote_addr); + } + + void clInfoType:: + remote_addr (const remote_addr::container& remote_addr) + { + this->_xsd_remote_addr_ = remote_addr; + } + + void clInfoType:: + remote_addr (::std::auto_ptr< remote_addr::type > remote_addr) + { + this->_xsd_remote_addr_.set (remote_addr); + } + + const clInfoType::local_port::container& clInfoType:: + local_port () const + { + return this->_xsd_local_port_; + } + + clInfoType::local_port::container& clInfoType:: + local_port () + { + return this->_xsd_local_port_; + } + + void clInfoType:: + local_port (const local_port::type& local_port) + { + this->_xsd_local_port_.set (local_port); + } + + void clInfoType:: + local_port (const local_port::container& local_port) + { + this->_xsd_local_port_ = local_port; + } + + const clInfoType::remote_port::container& clInfoType:: + remote_port () const + { + return this->_xsd_remote_port_; + } + + clInfoType::remote_port::container& clInfoType:: + remote_port () + { + return this->_xsd_remote_port_; + } + + void clInfoType:: + remote_port (const remote_port::type& remote_port) + { + this->_xsd_remote_port_.set (remote_port); + } + + void clInfoType:: + remote_port (const remote_port::container& remote_port) + { + this->_xsd_remote_port_ = remote_port; + } + + const clInfoType::segment_ack_enabled::container& clInfoType:: + segment_ack_enabled () const + { + return this->_xsd_segment_ack_enabled_; + } + + clInfoType::segment_ack_enabled::container& clInfoType:: + segment_ack_enabled () + { + return this->_xsd_segment_ack_enabled_; + } + + void clInfoType:: + segment_ack_enabled (const segment_ack_enabled::type& segment_ack_enabled) + { + this->_xsd_segment_ack_enabled_.set (segment_ack_enabled); + } + + void clInfoType:: + segment_ack_enabled (const segment_ack_enabled::container& segment_ack_enabled) + { + this->_xsd_segment_ack_enabled_ = segment_ack_enabled; + } + + const clInfoType::negative_ack_enabled::container& clInfoType:: + negative_ack_enabled () const + { + return this->_xsd_negative_ack_enabled_; + } + + clInfoType::negative_ack_enabled::container& clInfoType:: + negative_ack_enabled () + { + return this->_xsd_negative_ack_enabled_; + } + + void clInfoType:: + negative_ack_enabled (const negative_ack_enabled::type& negative_ack_enabled) + { + this->_xsd_negative_ack_enabled_.set (negative_ack_enabled); + } + + void clInfoType:: + negative_ack_enabled (const negative_ack_enabled::container& negative_ack_enabled) + { + this->_xsd_negative_ack_enabled_ = negative_ack_enabled; + } + + const clInfoType::keepalive_interval::container& clInfoType:: + keepalive_interval () const + { + return this->_xsd_keepalive_interval_; + } + + clInfoType::keepalive_interval::container& clInfoType:: + keepalive_interval () + { + return this->_xsd_keepalive_interval_; + } + + void clInfoType:: + keepalive_interval (const keepalive_interval::type& keepalive_interval) + { + this->_xsd_keepalive_interval_.set (keepalive_interval); + } + + void clInfoType:: + keepalive_interval (const keepalive_interval::container& keepalive_interval) + { + this->_xsd_keepalive_interval_ = keepalive_interval; + } + + const clInfoType::segment_length::container& clInfoType:: + segment_length () const + { + return this->_xsd_segment_length_; + } + + clInfoType::segment_length::container& clInfoType:: + segment_length () + { + return this->_xsd_segment_length_; + } + + void clInfoType:: + segment_length (const segment_length::type& segment_length) + { + this->_xsd_segment_length_.set (segment_length); + } + + void clInfoType:: + segment_length (const segment_length::container& segment_length) + { + this->_xsd_segment_length_ = segment_length; + } + + const clInfoType::busy_queue_depth::container& clInfoType:: + busy_queue_depth () const + { + return this->_xsd_busy_queue_depth_; + } + + clInfoType::busy_queue_depth::container& clInfoType:: + busy_queue_depth () + { + return this->_xsd_busy_queue_depth_; + } + + void clInfoType:: + busy_queue_depth (const busy_queue_depth::type& busy_queue_depth) + { + this->_xsd_busy_queue_depth_.set (busy_queue_depth); + } + + void clInfoType:: + busy_queue_depth (const busy_queue_depth::container& busy_queue_depth) + { + this->_xsd_busy_queue_depth_ = busy_queue_depth; + } + + const clInfoType::reactive_frag_enabled::container& clInfoType:: + reactive_frag_enabled () const + { + return this->_xsd_reactive_frag_enabled_; + } + + clInfoType::reactive_frag_enabled::container& clInfoType:: + reactive_frag_enabled () + { + return this->_xsd_reactive_frag_enabled_; + } + + void clInfoType:: + reactive_frag_enabled (const reactive_frag_enabled::type& reactive_frag_enabled) + { + this->_xsd_reactive_frag_enabled_.set (reactive_frag_enabled); + } + + void clInfoType:: + reactive_frag_enabled (const reactive_frag_enabled::container& reactive_frag_enabled) + { + this->_xsd_reactive_frag_enabled_ = reactive_frag_enabled; + } + + const clInfoType::sendbuf_length::container& clInfoType:: + sendbuf_length () const + { + return this->_xsd_sendbuf_length_; + } + + clInfoType::sendbuf_length::container& clInfoType:: + sendbuf_length () + { + return this->_xsd_sendbuf_length_; + } + + void clInfoType:: + sendbuf_length (const sendbuf_length::type& sendbuf_length) + { + this->_xsd_sendbuf_length_.set (sendbuf_length); + } + + void clInfoType:: + sendbuf_length (const sendbuf_length::container& sendbuf_length) + { + this->_xsd_sendbuf_length_ = sendbuf_length; + } + + const clInfoType::recvbuf_length::container& clInfoType:: + recvbuf_length () const + { + return this->_xsd_recvbuf_length_; + } + + clInfoType::recvbuf_length::container& clInfoType:: + recvbuf_length () + { + return this->_xsd_recvbuf_length_; + } + + void clInfoType:: + recvbuf_length (const recvbuf_length::type& recvbuf_length) + { + this->_xsd_recvbuf_length_.set (recvbuf_length); + } + + void clInfoType:: + recvbuf_length (const recvbuf_length::container& recvbuf_length) + { + this->_xsd_recvbuf_length_ = recvbuf_length; + } + + const clInfoType::data_timeout::container& clInfoType:: + data_timeout () const + { + return this->_xsd_data_timeout_; + } + + clInfoType::data_timeout::container& clInfoType:: + data_timeout () + { + return this->_xsd_data_timeout_; + } + + void clInfoType:: + data_timeout (const data_timeout::type& data_timeout) + { + this->_xsd_data_timeout_.set (data_timeout); + } + + void clInfoType:: + data_timeout (const data_timeout::container& data_timeout) + { + this->_xsd_data_timeout_ = data_timeout; + } + + const clInfoType::rate::container& clInfoType:: + rate () const + { + return this->_xsd_rate_; + } + + clInfoType::rate::container& clInfoType:: + rate () + { + return this->_xsd_rate_; + } + + void clInfoType:: + rate (const rate::type& rate) + { + this->_xsd_rate_.set (rate); + } + + void clInfoType:: + rate (const rate::container& rate) + { + this->_xsd_rate_ = rate; + } + + const clInfoType::bucket_depth::container& clInfoType:: + bucket_depth () const + { + return this->_xsd_bucket_depth_; + } + + clInfoType::bucket_depth::container& clInfoType:: + bucket_depth () + { + return this->_xsd_bucket_depth_; + } + + void clInfoType:: + bucket_depth (const bucket_depth::type& bucket_depth) + { + this->_xsd_bucket_depth_.set (bucket_depth); + } + + void clInfoType:: + bucket_depth (const bucket_depth::container& bucket_depth) + { + this->_xsd_bucket_depth_ = bucket_depth; + } + + const clInfoType::channel::container& clInfoType:: + channel () const + { + return this->_xsd_channel_; + } + + clInfoType::channel::container& clInfoType:: + channel () + { + return this->_xsd_channel_; + } + + void clInfoType:: + channel (const channel::type& channel) + { + this->_xsd_channel_.set (channel); + } + + void clInfoType:: + channel (const channel::container& channel) + { + this->_xsd_channel_ = channel; + } + + + // linkType_base + // + + const linkType_base::clinfo::container& linkType_base:: + clinfo () const + { + return this->_xsd_clinfo_; + } + + linkType_base::clinfo::container& linkType_base:: + clinfo () + { + return this->_xsd_clinfo_; + } + + void linkType_base:: + clinfo (const clinfo::type& clinfo) + { + this->_xsd_clinfo_.set (clinfo); + } + + void linkType_base:: + clinfo (const clinfo::container& clinfo) + { + this->_xsd_clinfo_ = clinfo; + } + + void linkType_base:: + clinfo (::std::auto_ptr< clinfo::type > clinfo) + { + this->_xsd_clinfo_.set (clinfo); + } + + const linkType_base::remote_eid::type& linkType_base:: + remote_eid () const + { + return this->_xsd_remote_eid_.get (); + } + + linkType_base::remote_eid::type& linkType_base:: + remote_eid () + { + return this->_xsd_remote_eid_.get (); + } + + void linkType_base:: + remote_eid (const remote_eid::type& remote_eid) + { + this->_xsd_remote_eid_.set (remote_eid); + } + + void linkType_base:: + remote_eid (::std::auto_ptr< remote_eid::type > remote_eid) + { + this->_xsd_remote_eid_.set (remote_eid); + } + + const linkType_base::type::type_& linkType_base:: + type () const + { + return this->_xsd_type_.get (); + } + + linkType_base::type::type_& linkType_base:: + type () + { + return this->_xsd_type_.get (); + } + + void linkType_base:: + type (const type::type_& type) + { + this->_xsd_type_.set (type); + } + + void linkType_base:: + type (::std::auto_ptr< type::type_ > type) + { + this->_xsd_type_.set (type); + } + + const linkType_base::nexthop::type& linkType_base:: + nexthop () const + { + return this->_xsd_nexthop_.get (); + } + + linkType_base::nexthop::type& linkType_base:: + nexthop () + { + return this->_xsd_nexthop_.get (); + } + + void linkType_base:: + nexthop (const nexthop::type& nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + void linkType_base:: + nexthop (::std::auto_ptr< nexthop::type > nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + const linkType_base::state::type& linkType_base:: + state () const + { + return this->_xsd_state_.get (); + } + + linkType_base::state::type& linkType_base:: + state () + { + return this->_xsd_state_.get (); + } + + void linkType_base:: + state (const state::type& state) + { + this->_xsd_state_.set (state); + } + + void linkType_base:: + state (::std::auto_ptr< state::type > state) + { + this->_xsd_state_.set (state); + } + + const linkType_base::is_reachable::type& linkType_base:: + is_reachable () const + { + return this->_xsd_is_reachable_.get (); + } + + linkType_base::is_reachable::type& linkType_base:: + is_reachable () + { + return this->_xsd_is_reachable_.get (); + } + + void linkType_base:: + is_reachable (const is_reachable::type& is_reachable) + { + this->_xsd_is_reachable_.set (is_reachable); + } + + const linkType_base::is_usable::type& linkType_base:: + is_usable () const + { + return this->_xsd_is_usable_.get (); + } + + linkType_base::is_usable::type& linkType_base:: + is_usable () + { + return this->_xsd_is_usable_.get (); + } + + void linkType_base:: + is_usable (const is_usable::type& is_usable) + { + this->_xsd_is_usable_.set (is_usable); + } + + const linkType_base::how_reliable::type& linkType_base:: + how_reliable () const + { + return this->_xsd_how_reliable_.get (); + } + + linkType_base::how_reliable::type& linkType_base:: + how_reliable () + { + return this->_xsd_how_reliable_.get (); + } + + void linkType_base:: + how_reliable (const how_reliable::type& how_reliable) + { + this->_xsd_how_reliable_.set (how_reliable); + } + + void linkType_base:: + how_reliable (::std::auto_ptr< how_reliable::type > how_reliable) + { + this->_xsd_how_reliable_.set (how_reliable); + } + + const linkType_base::how_available::type& linkType_base:: + how_available () const + { + return this->_xsd_how_available_.get (); + } + + linkType_base::how_available::type& linkType_base:: + how_available () + { + return this->_xsd_how_available_.get (); + } + + void linkType_base:: + how_available (const how_available::type& how_available) + { + this->_xsd_how_available_.set (how_available); + } + + void linkType_base:: + how_available (::std::auto_ptr< how_available::type > how_available) + { + this->_xsd_how_available_.set (how_available); + } + + const linkType_base::clayer::type& linkType_base:: + clayer () const + { + return this->_xsd_clayer_.get (); + } + + linkType_base::clayer::type& linkType_base:: + clayer () + { + return this->_xsd_clayer_.get (); + } + + void linkType_base:: + clayer (const clayer::type& clayer) + { + this->_xsd_clayer_.set (clayer); + } + + void linkType_base:: + clayer (::std::auto_ptr< clayer::type > clayer) + { + this->_xsd_clayer_.set (clayer); + } + + const linkType_base::min_retry_interval::type& linkType_base:: + min_retry_interval () const + { + return this->_xsd_min_retry_interval_.get (); + } + + linkType_base::min_retry_interval::type& linkType_base:: + min_retry_interval () + { + return this->_xsd_min_retry_interval_.get (); + } + + void linkType_base:: + min_retry_interval (const min_retry_interval::type& min_retry_interval) + { + this->_xsd_min_retry_interval_.set (min_retry_interval); + } + + const linkType_base::max_retry_interval::type& linkType_base:: + max_retry_interval () const + { + return this->_xsd_max_retry_interval_.get (); + } + + linkType_base::max_retry_interval::type& linkType_base:: + max_retry_interval () + { + return this->_xsd_max_retry_interval_.get (); + } + + void linkType_base:: + max_retry_interval (const max_retry_interval::type& max_retry_interval) + { + this->_xsd_max_retry_interval_.set (max_retry_interval); + } + + const linkType_base::idle_close_time::type& linkType_base:: + idle_close_time () const + { + return this->_xsd_idle_close_time_.get (); + } + + linkType_base::idle_close_time::type& linkType_base:: + idle_close_time () + { + return this->_xsd_idle_close_time_.get (); + } + + void linkType_base:: + idle_close_time (const idle_close_time::type& idle_close_time) + { + this->_xsd_idle_close_time_.set (idle_close_time); + } + + + // routeEntryType_base + // + + const routeEntryType_base::dest_pattern::type& routeEntryType_base:: + dest_pattern () const + { + return this->_xsd_dest_pattern_.get (); + } + + routeEntryType_base::dest_pattern::type& routeEntryType_base:: + dest_pattern () + { + return this->_xsd_dest_pattern_.get (); + } + + void routeEntryType_base:: + dest_pattern (const dest_pattern::type& dest_pattern) + { + this->_xsd_dest_pattern_.set (dest_pattern); + } + + void routeEntryType_base:: + dest_pattern (::std::auto_ptr< dest_pattern::type > dest_pattern) + { + this->_xsd_dest_pattern_.set (dest_pattern); + } + + const routeEntryType_base::source_pattern::type& routeEntryType_base:: + source_pattern () const + { + return this->_xsd_source_pattern_.get (); + } + + routeEntryType_base::source_pattern::type& routeEntryType_base:: + source_pattern () + { + return this->_xsd_source_pattern_.get (); + } + + void routeEntryType_base:: + source_pattern (const source_pattern::type& source_pattern) + { + this->_xsd_source_pattern_.set (source_pattern); + } + + void routeEntryType_base:: + source_pattern (::std::auto_ptr< source_pattern::type > source_pattern) + { + this->_xsd_source_pattern_.set (source_pattern); + } + + const routeEntryType_base::route_priority::type& routeEntryType_base:: + route_priority () const + { + return this->_xsd_route_priority_.get (); + } + + routeEntryType_base::route_priority::type& routeEntryType_base:: + route_priority () + { + return this->_xsd_route_priority_.get (); + } + + void routeEntryType_base:: + route_priority (const route_priority::type& route_priority) + { + this->_xsd_route_priority_.set (route_priority); + } + + const routeEntryType_base::action::type& routeEntryType_base:: + action () const + { + return this->_xsd_action_.get (); + } + + routeEntryType_base::action::type& routeEntryType_base:: + action () + { + return this->_xsd_action_.get (); + } + + void routeEntryType_base:: + action (const action::type& action) + { + this->_xsd_action_.set (action); + } + + void routeEntryType_base:: + action (::std::auto_ptr< action::type > action) + { + this->_xsd_action_.set (action); + } + + const routeEntryType_base::link::type& routeEntryType_base:: + link () const + { + return this->_xsd_link_.get (); + } + + routeEntryType_base::link::type& routeEntryType_base:: + link () + { + return this->_xsd_link_.get (); + } + + void routeEntryType_base:: + link (const link::type& link) + { + this->_xsd_link_.set (link); + } + + void routeEntryType_base:: + link (::std::auto_ptr< link::type > link) + { + this->_xsd_link_.set (link); + } + + + // custodySignalType + // + + const custodySignalType::admin_type::type& custodySignalType:: + admin_type () const + { + return this->_xsd_admin_type_.get (); + } + + custodySignalType::admin_type::type& custodySignalType:: + admin_type () + { + return this->_xsd_admin_type_.get (); + } + + void custodySignalType:: + admin_type (const admin_type::type& admin_type) + { + this->_xsd_admin_type_.set (admin_type); + } + + const custodySignalType::admin_flags::type& custodySignalType:: + admin_flags () const + { + return this->_xsd_admin_flags_.get (); + } + + custodySignalType::admin_flags::type& custodySignalType:: + admin_flags () + { + return this->_xsd_admin_flags_.get (); + } + + void custodySignalType:: + admin_flags (const admin_flags::type& admin_flags) + { + this->_xsd_admin_flags_.set (admin_flags); + } + + const custodySignalType::succeeded::type& custodySignalType:: + succeeded () const + { + return this->_xsd_succeeded_.get (); + } + + custodySignalType::succeeded::type& custodySignalType:: + succeeded () + { + return this->_xsd_succeeded_.get (); + } + + void custodySignalType:: + succeeded (const succeeded::type& succeeded) + { + this->_xsd_succeeded_.set (succeeded); + } + + const custodySignalType::reason::type& custodySignalType:: + reason () const + { + return this->_xsd_reason_.get (); + } + + custodySignalType::reason::type& custodySignalType:: + reason () + { + return this->_xsd_reason_.get (); + } + + void custodySignalType:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + const custodySignalType::orig_frag_offset::type& custodySignalType:: + orig_frag_offset () const + { + return this->_xsd_orig_frag_offset_.get (); + } + + custodySignalType::orig_frag_offset::type& custodySignalType:: + orig_frag_offset () + { + return this->_xsd_orig_frag_offset_.get (); + } + + void custodySignalType:: + orig_frag_offset (const orig_frag_offset::type& orig_frag_offset) + { + this->_xsd_orig_frag_offset_.set (orig_frag_offset); + } + + const custodySignalType::orig_frag_length::type& custodySignalType:: + orig_frag_length () const + { + return this->_xsd_orig_frag_length_.get (); + } + + custodySignalType::orig_frag_length::type& custodySignalType:: + orig_frag_length () + { + return this->_xsd_orig_frag_length_.get (); + } + + void custodySignalType:: + orig_frag_length (const orig_frag_length::type& orig_frag_length) + { + this->_xsd_orig_frag_length_.set (orig_frag_length); + } + + const custodySignalType::custody_signal_seconds::type& custodySignalType:: + custody_signal_seconds () const + { + return this->_xsd_custody_signal_seconds_.get (); + } + + custodySignalType::custody_signal_seconds::type& custodySignalType:: + custody_signal_seconds () + { + return this->_xsd_custody_signal_seconds_.get (); + } + + void custodySignalType:: + custody_signal_seconds (const custody_signal_seconds::type& custody_signal_seconds) + { + this->_xsd_custody_signal_seconds_.set (custody_signal_seconds); + } + + const custodySignalType::custody_signal_seqno::type& custodySignalType:: + custody_signal_seqno () const + { + return this->_xsd_custody_signal_seqno_.get (); + } + + custodySignalType::custody_signal_seqno::type& custodySignalType:: + custody_signal_seqno () + { + return this->_xsd_custody_signal_seqno_.get (); + } + + void custodySignalType:: + custody_signal_seqno (const custody_signal_seqno::type& custody_signal_seqno) + { + this->_xsd_custody_signal_seqno_.set (custody_signal_seqno); + } + + const custodySignalType::orig_creation_seconds::type& custodySignalType:: + orig_creation_seconds () const + { + return this->_xsd_orig_creation_seconds_.get (); + } + + custodySignalType::orig_creation_seconds::type& custodySignalType:: + orig_creation_seconds () + { + return this->_xsd_orig_creation_seconds_.get (); + } + + void custodySignalType:: + orig_creation_seconds (const orig_creation_seconds::type& orig_creation_seconds) + { + this->_xsd_orig_creation_seconds_.set (orig_creation_seconds); + } + + const custodySignalType::orig_creation_seqno::type& custodySignalType:: + orig_creation_seqno () const + { + return this->_xsd_orig_creation_seqno_.get (); + } + + custodySignalType::orig_creation_seqno::type& custodySignalType:: + orig_creation_seqno () + { + return this->_xsd_orig_creation_seqno_.get (); + } + + void custodySignalType:: + orig_creation_seqno (const orig_creation_seqno::type& orig_creation_seqno) + { + this->_xsd_orig_creation_seqno_.set (orig_creation_seqno); + } + + + // registrationType_base + // + + const registrationType_base::endpoint::type& registrationType_base:: + endpoint () const + { + return this->_xsd_endpoint_.get (); + } + + registrationType_base::endpoint::type& registrationType_base:: + endpoint () + { + return this->_xsd_endpoint_.get (); + } + + void registrationType_base:: + endpoint (const endpoint::type& endpoint) + { + this->_xsd_endpoint_.set (endpoint); + } + + void registrationType_base:: + endpoint (::std::auto_ptr< endpoint::type > endpoint) + { + this->_xsd_endpoint_.set (endpoint); + } + + const registrationType_base::regid::type& registrationType_base:: + regid () const + { + return this->_xsd_regid_.get (); + } + + registrationType_base::regid::type& registrationType_base:: + regid () + { + return this->_xsd_regid_.get (); + } + + void registrationType_base:: + regid (const regid::type& regid) + { + this->_xsd_regid_.set (regid); + } + + const registrationType_base::action::type& registrationType_base:: + action () const + { + return this->_xsd_action_.get (); + } + + registrationType_base::action::type& registrationType_base:: + action () + { + return this->_xsd_action_.get (); + } + + void registrationType_base:: + action (const action::type& action) + { + this->_xsd_action_.set (action); + } + + void registrationType_base:: + action (::std::auto_ptr< action::type > action) + { + this->_xsd_action_.set (action); + } + + const registrationType_base::script::type& registrationType_base:: + script () const + { + return this->_xsd_script_.get (); + } + + registrationType_base::script::type& registrationType_base:: + script () + { + return this->_xsd_script_.get (); + } + + void registrationType_base:: + script (const script::type& script) + { + this->_xsd_script_.set (script); + } + + void registrationType_base:: + script (::std::auto_ptr< script::type > script) + { + this->_xsd_script_.set (script); + } + + const registrationType_base::expiration::type& registrationType_base:: + expiration () const + { + return this->_xsd_expiration_.get (); + } + + registrationType_base::expiration::type& registrationType_base:: + expiration () + { + return this->_xsd_expiration_.get (); + } + + void registrationType_base:: + expiration (const expiration::type& expiration) + { + this->_xsd_expiration_.set (expiration); + } + + + // linkConfigType + // + + const linkConfigType::cl_params::container& linkConfigType:: + cl_params () const + { + return this->_xsd_cl_params_; + } + + linkConfigType::cl_params::container& linkConfigType:: + cl_params () + { + return this->_xsd_cl_params_; + } + + void linkConfigType:: + cl_params (const cl_params::container& cl_params) + { + this->_xsd_cl_params_ = cl_params; + } + + const linkConfigType::is_usable::container& linkConfigType:: + is_usable () const + { + return this->_xsd_is_usable_; + } + + linkConfigType::is_usable::container& linkConfigType:: + is_usable () + { + return this->_xsd_is_usable_; + } + + void linkConfigType:: + is_usable (const is_usable::type& is_usable) + { + this->_xsd_is_usable_.set (is_usable); + } + + void linkConfigType:: + is_usable (const is_usable::container& is_usable) + { + this->_xsd_is_usable_ = is_usable; + } + + const linkConfigType::reactive_frag_enabled::container& linkConfigType:: + reactive_frag_enabled () const + { + return this->_xsd_reactive_frag_enabled_; + } + + linkConfigType::reactive_frag_enabled::container& linkConfigType:: + reactive_frag_enabled () + { + return this->_xsd_reactive_frag_enabled_; + } + + void linkConfigType:: + reactive_frag_enabled (const reactive_frag_enabled::type& reactive_frag_enabled) + { + this->_xsd_reactive_frag_enabled_.set (reactive_frag_enabled); + } + + void linkConfigType:: + reactive_frag_enabled (const reactive_frag_enabled::container& reactive_frag_enabled) + { + this->_xsd_reactive_frag_enabled_ = reactive_frag_enabled; + } + + const linkConfigType::nexthop::container& linkConfigType:: + nexthop () const + { + return this->_xsd_nexthop_; + } + + linkConfigType::nexthop::container& linkConfigType:: + nexthop () + { + return this->_xsd_nexthop_; + } + + void linkConfigType:: + nexthop (const nexthop::type& nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + void linkConfigType:: + nexthop (const nexthop::container& nexthop) + { + this->_xsd_nexthop_ = nexthop; + } + + void linkConfigType:: + nexthop (::std::auto_ptr< nexthop::type > nexthop) + { + this->_xsd_nexthop_.set (nexthop); + } + + const linkConfigType::min_retry_interval::container& linkConfigType:: + min_retry_interval () const + { + return this->_xsd_min_retry_interval_; + } + + linkConfigType::min_retry_interval::container& linkConfigType:: + min_retry_interval () + { + return this->_xsd_min_retry_interval_; + } + + void linkConfigType:: + min_retry_interval (const min_retry_interval::type& min_retry_interval) + { + this->_xsd_min_retry_interval_.set (min_retry_interval); + } + + void linkConfigType:: + min_retry_interval (const min_retry_interval::container& min_retry_interval) + { + this->_xsd_min_retry_interval_ = min_retry_interval; + } + + const linkConfigType::max_retry_interval::container& linkConfigType:: + max_retry_interval () const + { + return this->_xsd_max_retry_interval_; + } + + linkConfigType::max_retry_interval::container& linkConfigType:: + max_retry_interval () + { + return this->_xsd_max_retry_interval_; + } + + void linkConfigType:: + max_retry_interval (const max_retry_interval::type& max_retry_interval) + { + this->_xsd_max_retry_interval_.set (max_retry_interval); + } + + void linkConfigType:: + max_retry_interval (const max_retry_interval::container& max_retry_interval) + { + this->_xsd_max_retry_interval_ = max_retry_interval; + } + + const linkConfigType::idle_close_time::container& linkConfigType:: + idle_close_time () const + { + return this->_xsd_idle_close_time_; + } + + linkConfigType::idle_close_time::container& linkConfigType:: + idle_close_time () + { + return this->_xsd_idle_close_time_; + } + + void linkConfigType:: + idle_close_time (const idle_close_time::type& idle_close_time) + { + this->_xsd_idle_close_time_.set (idle_close_time); + } + + void linkConfigType:: + idle_close_time (const idle_close_time::container& idle_close_time) + { + this->_xsd_idle_close_time_ = idle_close_time; + } + + + // key_value_pair_base + // + + const key_value_pair_base::name::type& key_value_pair_base:: + name () const + { + return this->_xsd_name_.get (); + } + + key_value_pair_base::name::type& key_value_pair_base:: + name () + { + return this->_xsd_name_.get (); + } + + void key_value_pair_base:: + name (const name::type& name) + { + this->_xsd_name_.set (name); + } + + void key_value_pair_base:: + name (::std::auto_ptr< name::type > name) + { + this->_xsd_name_.set (name); + } + + const key_value_pair_base::bool_value::container& key_value_pair_base:: + bool_value () const + { + return this->_xsd_bool_value_; + } + + key_value_pair_base::bool_value::container& key_value_pair_base:: + bool_value () + { + return this->_xsd_bool_value_; + } + + void key_value_pair_base:: + bool_value (const bool_value::type& bool_value) + { + this->_xsd_bool_value_.set (bool_value); + } + + void key_value_pair_base:: + bool_value (const bool_value::container& bool_value) + { + this->_xsd_bool_value_ = bool_value; + } + + const key_value_pair_base::u_int_value::container& key_value_pair_base:: + u_int_value () const + { + return this->_xsd_u_int_value_; + } + + key_value_pair_base::u_int_value::container& key_value_pair_base:: + u_int_value () + { + return this->_xsd_u_int_value_; + } + + void key_value_pair_base:: + u_int_value (const u_int_value::type& u_int_value) + { + this->_xsd_u_int_value_.set (u_int_value); + } + + void key_value_pair_base:: + u_int_value (const u_int_value::container& u_int_value) + { + this->_xsd_u_int_value_ = u_int_value; + } + + const key_value_pair_base::int_value::container& key_value_pair_base:: + int_value () const + { + return this->_xsd_int_value_; + } + + key_value_pair_base::int_value::container& key_value_pair_base:: + int_value () + { + return this->_xsd_int_value_; + } + + void key_value_pair_base:: + int_value (const int_value::type& int_value) + { + this->_xsd_int_value_.set (int_value); + } + + void key_value_pair_base:: + int_value (const int_value::container& int_value) + { + this->_xsd_int_value_ = int_value; + } + + const key_value_pair_base::str_value::container& key_value_pair_base:: + str_value () const + { + return this->_xsd_str_value_; + } + + key_value_pair_base::str_value::container& key_value_pair_base:: + str_value () + { + return this->_xsd_str_value_; + } + + void key_value_pair_base:: + str_value (const str_value::type& str_value) + { + this->_xsd_str_value_.set (str_value); + } + + void key_value_pair_base:: + str_value (const str_value::container& str_value) + { + this->_xsd_str_value_ = str_value; + } + + void key_value_pair_base:: + str_value (::std::auto_ptr< str_value::type > str_value) + { + this->_xsd_str_value_.set (str_value); + } + + + // bundleAttributesSimpleQueryType + // + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType () + : ::xml_schema::string () + { + } + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (_xsd_bundleAttributesSimpleQueryType v) + : ::xml_schema::string (_xsd_bundleAttributesSimpleQueryType_literals_[v]) + { + } + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (const ::xml_schema::string& _xsd_bundleAttributesSimpleQueryType) + : ::xml_schema::string (_xsd_bundleAttributesSimpleQueryType) + { + } + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (const bundleAttributesSimpleQueryType& v, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (v, f, c) + { + } + + bundleAttributesSimpleQueryType& bundleAttributesSimpleQueryType:: + operator= (_xsd_bundleAttributesSimpleQueryType v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_bundleAttributesSimpleQueryType_literals_[v]); + + return *this; + } + + + // bundleMetaBlockQueryType + // + + const bundleMetaBlockQueryType::type::container& bundleMetaBlockQueryType:: + type () const + { + return this->_xsd_type_; + } + + bundleMetaBlockQueryType::type::container& bundleMetaBlockQueryType:: + type () + { + return this->_xsd_type_; + } + + void bundleMetaBlockQueryType:: + type (const type::type_& type) + { + this->_xsd_type_.set (type); + } + + void bundleMetaBlockQueryType:: + type (const type::container& type) + { + this->_xsd_type_ = type; + } + + const bundleMetaBlockQueryType::identifier::container& bundleMetaBlockQueryType:: + identifier () const + { + return this->_xsd_identifier_; + } + + bundleMetaBlockQueryType::identifier::container& bundleMetaBlockQueryType:: + identifier () + { + return this->_xsd_identifier_; + } + + void bundleMetaBlockQueryType:: + identifier (const identifier::type& identifier) + { + this->_xsd_identifier_.set (identifier); + } + + void bundleMetaBlockQueryType:: + identifier (const identifier::container& identifier) + { + this->_xsd_identifier_ = identifier; + } + + + // bundleAttributesQueryType + // + + const bundleAttributesQueryType::query::container& bundleAttributesQueryType:: + query () const + { + return this->_xsd_query_; + } + + bundleAttributesQueryType::query::container& bundleAttributesQueryType:: + query () + { + return this->_xsd_query_; + } + + void bundleAttributesQueryType:: + query (const query::type& query) + { + this->_xsd_query_.set (query); + } + + void bundleAttributesQueryType:: + query (const query::container& query) + { + this->_xsd_query_ = query; + } + + void bundleAttributesQueryType:: + query (::std::auto_ptr< query::type > query) + { + this->_xsd_query_.set (query); + } + + const bundleAttributesQueryType::meta_blocks::container& bundleAttributesQueryType:: + meta_blocks () const + { + return this->_xsd_meta_blocks_; + } + + bundleAttributesQueryType::meta_blocks::container& bundleAttributesQueryType:: + meta_blocks () + { + return this->_xsd_meta_blocks_; + } + + void bundleAttributesQueryType:: + meta_blocks (const meta_blocks::type& meta_blocks) + { + this->_xsd_meta_blocks_.set (meta_blocks); + } + + void bundleAttributesQueryType:: + meta_blocks (const meta_blocks::container& meta_blocks) + { + this->_xsd_meta_blocks_ = meta_blocks; + } + + void bundleAttributesQueryType:: + meta_blocks (::std::auto_ptr< meta_blocks::type > meta_blocks) + { + this->_xsd_meta_blocks_.set (meta_blocks); + } + + + // metadataBlockType + // + + const metadataBlockType::identifier::type& metadataBlockType:: + identifier () const + { + return this->_xsd_identifier_.get (); + } + + metadataBlockType::identifier::type& metadataBlockType:: + identifier () + { + return this->_xsd_identifier_.get (); + } + + void metadataBlockType:: + identifier (const identifier::type& identifier) + { + this->_xsd_identifier_.set (identifier); + } + + const metadataBlockType::generated::type& metadataBlockType:: + generated () const + { + return this->_xsd_generated_.get (); + } + + metadataBlockType::generated::type& metadataBlockType:: + generated () + { + return this->_xsd_generated_.get (); + } + + void metadataBlockType:: + generated (const generated::type& generated) + { + this->_xsd_generated_.set (generated); + } + + const metadataBlockType::type::type_& metadataBlockType:: + type () const + { + return this->_xsd_type_.get (); + } + + metadataBlockType::type::type_& metadataBlockType:: + type () + { + return this->_xsd_type_.get (); + } + + void metadataBlockType:: + type (const type::type_& type) + { + this->_xsd_type_.set (type); + } + + const metadataBlockType::contents::type& metadataBlockType:: + contents () const + { + return this->_xsd_contents_.get (); + } + + metadataBlockType::contents::type& metadataBlockType:: + contents () + { + return this->_xsd_contents_.get (); + } + + void metadataBlockType:: + contents (const contents::type& contents) + { + this->_xsd_contents_.set (contents); + } + + void metadataBlockType:: + contents (::std::auto_ptr< contents::type > contents) + { + this->_xsd_contents_.set (contents); + } + + + // bundleAttributesReportType + // + + const bundleAttributesReportType::dest::container& bundleAttributesReportType:: + dest () const + { + return this->_xsd_dest_; + } + + bundleAttributesReportType::dest::container& bundleAttributesReportType:: + dest () + { + return this->_xsd_dest_; + } + + void bundleAttributesReportType:: + dest (const dest::type& dest) + { + this->_xsd_dest_.set (dest); + } + + void bundleAttributesReportType:: + dest (const dest::container& dest) + { + this->_xsd_dest_ = dest; + } + + void bundleAttributesReportType:: + dest (::std::auto_ptr< dest::type > dest) + { + this->_xsd_dest_.set (dest); + } + + const bundleAttributesReportType::custodian::container& bundleAttributesReportType:: + custodian () const + { + return this->_xsd_custodian_; + } + + bundleAttributesReportType::custodian::container& bundleAttributesReportType:: + custodian () + { + return this->_xsd_custodian_; + } + + void bundleAttributesReportType:: + custodian (const custodian::type& custodian) + { + this->_xsd_custodian_.set (custodian); + } + + void bundleAttributesReportType:: + custodian (const custodian::container& custodian) + { + this->_xsd_custodian_ = custodian; + } + + void bundleAttributesReportType:: + custodian (::std::auto_ptr< custodian::type > custodian) + { + this->_xsd_custodian_.set (custodian); + } + + const bundleAttributesReportType::replyto::container& bundleAttributesReportType:: + replyto () const + { + return this->_xsd_replyto_; + } + + bundleAttributesReportType::replyto::container& bundleAttributesReportType:: + replyto () + { + return this->_xsd_replyto_; + } + + void bundleAttributesReportType:: + replyto (const replyto::type& replyto) + { + this->_xsd_replyto_.set (replyto); + } + + void bundleAttributesReportType:: + replyto (const replyto::container& replyto) + { + this->_xsd_replyto_ = replyto; + } + + void bundleAttributesReportType:: + replyto (::std::auto_ptr< replyto::type > replyto) + { + this->_xsd_replyto_.set (replyto); + } + + const bundleAttributesReportType::prevhop::container& bundleAttributesReportType:: + prevhop () const + { + return this->_xsd_prevhop_; + } + + bundleAttributesReportType::prevhop::container& bundleAttributesReportType:: + prevhop () + { + return this->_xsd_prevhop_; + } + + void bundleAttributesReportType:: + prevhop (const prevhop::type& prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + void bundleAttributesReportType:: + prevhop (const prevhop::container& prevhop) + { + this->_xsd_prevhop_ = prevhop; + } + + void bundleAttributesReportType:: + prevhop (::std::auto_ptr< prevhop::type > prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + const bundleAttributesReportType::meta_blocks::container& bundleAttributesReportType:: + meta_blocks () const + { + return this->_xsd_meta_blocks_; + } + + bundleAttributesReportType::meta_blocks::container& bundleAttributesReportType:: + meta_blocks () + { + return this->_xsd_meta_blocks_; + } + + void bundleAttributesReportType:: + meta_blocks (const meta_blocks::container& meta_blocks) + { + this->_xsd_meta_blocks_ = meta_blocks; + } + + const bundleAttributesReportType::bundleid::container& bundleAttributesReportType:: + bundleid () const + { + return this->_xsd_bundleid_; + } + + bundleAttributesReportType::bundleid::container& bundleAttributesReportType:: + bundleid () + { + return this->_xsd_bundleid_; + } + + void bundleAttributesReportType:: + bundleid (const bundleid::type& bundleid) + { + this->_xsd_bundleid_.set (bundleid); + } + + void bundleAttributesReportType:: + bundleid (const bundleid::container& bundleid) + { + this->_xsd_bundleid_ = bundleid; + } + + const bundleAttributesReportType::is_admin::container& bundleAttributesReportType:: + is_admin () const + { + return this->_xsd_is_admin_; + } + + bundleAttributesReportType::is_admin::container& bundleAttributesReportType:: + is_admin () + { + return this->_xsd_is_admin_; + } + + void bundleAttributesReportType:: + is_admin (const is_admin::type& is_admin) + { + this->_xsd_is_admin_.set (is_admin); + } + + void bundleAttributesReportType:: + is_admin (const is_admin::container& is_admin) + { + this->_xsd_is_admin_ = is_admin; + } + + const bundleAttributesReportType::do_not_fragment::container& bundleAttributesReportType:: + do_not_fragment () const + { + return this->_xsd_do_not_fragment_; + } + + bundleAttributesReportType::do_not_fragment::container& bundleAttributesReportType:: + do_not_fragment () + { + return this->_xsd_do_not_fragment_; + } + + void bundleAttributesReportType:: + do_not_fragment (const do_not_fragment::type& do_not_fragment) + { + this->_xsd_do_not_fragment_.set (do_not_fragment); + } + + void bundleAttributesReportType:: + do_not_fragment (const do_not_fragment::container& do_not_fragment) + { + this->_xsd_do_not_fragment_ = do_not_fragment; + } + + const bundleAttributesReportType::priority::container& bundleAttributesReportType:: + priority () const + { + return this->_xsd_priority_; + } + + bundleAttributesReportType::priority::container& bundleAttributesReportType:: + priority () + { + return this->_xsd_priority_; + } + + void bundleAttributesReportType:: + priority (const priority::type& priority) + { + this->_xsd_priority_.set (priority); + } + + void bundleAttributesReportType:: + priority (const priority::container& priority) + { + this->_xsd_priority_ = priority; + } + + void bundleAttributesReportType:: + priority (::std::auto_ptr< priority::type > priority) + { + this->_xsd_priority_.set (priority); + } + + const bundleAttributesReportType::custody_requested::container& bundleAttributesReportType:: + custody_requested () const + { + return this->_xsd_custody_requested_; + } + + bundleAttributesReportType::custody_requested::container& bundleAttributesReportType:: + custody_requested () + { + return this->_xsd_custody_requested_; + } + + void bundleAttributesReportType:: + custody_requested (const custody_requested::type& custody_requested) + { + this->_xsd_custody_requested_.set (custody_requested); + } + + void bundleAttributesReportType:: + custody_requested (const custody_requested::container& custody_requested) + { + this->_xsd_custody_requested_ = custody_requested; + } + + const bundleAttributesReportType::local_custody::container& bundleAttributesReportType:: + local_custody () const + { + return this->_xsd_local_custody_; + } + + bundleAttributesReportType::local_custody::container& bundleAttributesReportType:: + local_custody () + { + return this->_xsd_local_custody_; + } + + void bundleAttributesReportType:: + local_custody (const local_custody::type& local_custody) + { + this->_xsd_local_custody_.set (local_custody); + } + + void bundleAttributesReportType:: + local_custody (const local_custody::container& local_custody) + { + this->_xsd_local_custody_ = local_custody; + } + + const bundleAttributesReportType::singleton_dest::container& bundleAttributesReportType:: + singleton_dest () const + { + return this->_xsd_singleton_dest_; + } + + bundleAttributesReportType::singleton_dest::container& bundleAttributesReportType:: + singleton_dest () + { + return this->_xsd_singleton_dest_; + } + + void bundleAttributesReportType:: + singleton_dest (const singleton_dest::type& singleton_dest) + { + this->_xsd_singleton_dest_.set (singleton_dest); + } + + void bundleAttributesReportType:: + singleton_dest (const singleton_dest::container& singleton_dest) + { + this->_xsd_singleton_dest_ = singleton_dest; + } + + const bundleAttributesReportType::custody_rcpt::container& bundleAttributesReportType:: + custody_rcpt () const + { + return this->_xsd_custody_rcpt_; + } + + bundleAttributesReportType::custody_rcpt::container& bundleAttributesReportType:: + custody_rcpt () + { + return this->_xsd_custody_rcpt_; + } + + void bundleAttributesReportType:: + custody_rcpt (const custody_rcpt::type& custody_rcpt) + { + this->_xsd_custody_rcpt_.set (custody_rcpt); + } + + void bundleAttributesReportType:: + custody_rcpt (const custody_rcpt::container& custody_rcpt) + { + this->_xsd_custody_rcpt_ = custody_rcpt; + } + + const bundleAttributesReportType::receive_rcpt::container& bundleAttributesReportType:: + receive_rcpt () const + { + return this->_xsd_receive_rcpt_; + } + + bundleAttributesReportType::receive_rcpt::container& bundleAttributesReportType:: + receive_rcpt () + { + return this->_xsd_receive_rcpt_; + } + + void bundleAttributesReportType:: + receive_rcpt (const receive_rcpt::type& receive_rcpt) + { + this->_xsd_receive_rcpt_.set (receive_rcpt); + } + + void bundleAttributesReportType:: + receive_rcpt (const receive_rcpt::container& receive_rcpt) + { + this->_xsd_receive_rcpt_ = receive_rcpt; + } + + const bundleAttributesReportType::forward_rcpt::container& bundleAttributesReportType:: + forward_rcpt () const + { + return this->_xsd_forward_rcpt_; + } + + bundleAttributesReportType::forward_rcpt::container& bundleAttributesReportType:: + forward_rcpt () + { + return this->_xsd_forward_rcpt_; + } + + void bundleAttributesReportType:: + forward_rcpt (const forward_rcpt::type& forward_rcpt) + { + this->_xsd_forward_rcpt_.set (forward_rcpt); + } + + void bundleAttributesReportType:: + forward_rcpt (const forward_rcpt::container& forward_rcpt) + { + this->_xsd_forward_rcpt_ = forward_rcpt; + } + + const bundleAttributesReportType::delivery_rcpt::container& bundleAttributesReportType:: + delivery_rcpt () const + { + return this->_xsd_delivery_rcpt_; + } + + bundleAttributesReportType::delivery_rcpt::container& bundleAttributesReportType:: + delivery_rcpt () + { + return this->_xsd_delivery_rcpt_; + } + + void bundleAttributesReportType:: + delivery_rcpt (const delivery_rcpt::type& delivery_rcpt) + { + this->_xsd_delivery_rcpt_.set (delivery_rcpt); + } + + void bundleAttributesReportType:: + delivery_rcpt (const delivery_rcpt::container& delivery_rcpt) + { + this->_xsd_delivery_rcpt_ = delivery_rcpt; + } + + const bundleAttributesReportType::deletion_rcpt::container& bundleAttributesReportType:: + deletion_rcpt () const + { + return this->_xsd_deletion_rcpt_; + } + + bundleAttributesReportType::deletion_rcpt::container& bundleAttributesReportType:: + deletion_rcpt () + { + return this->_xsd_deletion_rcpt_; + } + + void bundleAttributesReportType:: + deletion_rcpt (const deletion_rcpt::type& deletion_rcpt) + { + this->_xsd_deletion_rcpt_.set (deletion_rcpt); + } + + void bundleAttributesReportType:: + deletion_rcpt (const deletion_rcpt::container& deletion_rcpt) + { + this->_xsd_deletion_rcpt_ = deletion_rcpt; + } + + const bundleAttributesReportType::app_acked_rcpt::container& bundleAttributesReportType:: + app_acked_rcpt () const + { + return this->_xsd_app_acked_rcpt_; + } + + bundleAttributesReportType::app_acked_rcpt::container& bundleAttributesReportType:: + app_acked_rcpt () + { + return this->_xsd_app_acked_rcpt_; + } + + void bundleAttributesReportType:: + app_acked_rcpt (const app_acked_rcpt::type& app_acked_rcpt) + { + this->_xsd_app_acked_rcpt_.set (app_acked_rcpt); + } + + void bundleAttributesReportType:: + app_acked_rcpt (const app_acked_rcpt::container& app_acked_rcpt) + { + this->_xsd_app_acked_rcpt_ = app_acked_rcpt; + } + + const bundleAttributesReportType::expiration::container& bundleAttributesReportType:: + expiration () const + { + return this->_xsd_expiration_; + } + + bundleAttributesReportType::expiration::container& bundleAttributesReportType:: + expiration () + { + return this->_xsd_expiration_; + } + + void bundleAttributesReportType:: + expiration (const expiration::type& expiration) + { + this->_xsd_expiration_.set (expiration); + } + + void bundleAttributesReportType:: + expiration (const expiration::container& expiration) + { + this->_xsd_expiration_ = expiration; + } + + const bundleAttributesReportType::orig_length::container& bundleAttributesReportType:: + orig_length () const + { + return this->_xsd_orig_length_; + } + + bundleAttributesReportType::orig_length::container& bundleAttributesReportType:: + orig_length () + { + return this->_xsd_orig_length_; + } + + void bundleAttributesReportType:: + orig_length (const orig_length::type& orig_length) + { + this->_xsd_orig_length_.set (orig_length); + } + + void bundleAttributesReportType:: + orig_length (const orig_length::container& orig_length) + { + this->_xsd_orig_length_ = orig_length; + } + + const bundleAttributesReportType::owner::container& bundleAttributesReportType:: + owner () const + { + return this->_xsd_owner_; + } + + bundleAttributesReportType::owner::container& bundleAttributesReportType:: + owner () + { + return this->_xsd_owner_; + } + + void bundleAttributesReportType:: + owner (const owner::type& owner) + { + this->_xsd_owner_.set (owner); + } + + void bundleAttributesReportType:: + owner (const owner::container& owner) + { + this->_xsd_owner_ = owner; + } + + void bundleAttributesReportType:: + owner (::std::auto_ptr< owner::type > owner) + { + this->_xsd_owner_.set (owner); + } + + const bundleAttributesReportType::location::container& bundleAttributesReportType:: + location () const + { + return this->_xsd_location_; + } + + bundleAttributesReportType::location::container& bundleAttributesReportType:: + location () + { + return this->_xsd_location_; + } + + void bundleAttributesReportType:: + location (const location::type& location) + { + this->_xsd_location_.set (location); + } + + void bundleAttributesReportType:: + location (const location::container& location) + { + this->_xsd_location_ = location; + } + + void bundleAttributesReportType:: + location (::std::auto_ptr< location::type > location) + { + this->_xsd_location_.set (location); + } + + const bundleAttributesReportType::payload_file::container& bundleAttributesReportType:: + payload_file () const + { + return this->_xsd_payload_file_; + } + + bundleAttributesReportType::payload_file::container& bundleAttributesReportType:: + payload_file () + { + return this->_xsd_payload_file_; + } + + void bundleAttributesReportType:: + payload_file (const payload_file::type& payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + void bundleAttributesReportType:: + payload_file (const payload_file::container& payload_file) + { + this->_xsd_payload_file_ = payload_file; + } + + void bundleAttributesReportType:: + payload_file (::std::auto_ptr< payload_file::type > payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + + // bundle_received_event + // + + const bundle_received_event::gbof_id::type& bundle_received_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_received_event::gbof_id::type& bundle_received_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_received_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_received_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_received_event::dest::type& bundle_received_event:: + dest () const + { + return this->_xsd_dest_.get (); + } + + bundle_received_event::dest::type& bundle_received_event:: + dest () + { + return this->_xsd_dest_.get (); + } + + void bundle_received_event:: + dest (const dest::type& dest) + { + this->_xsd_dest_.set (dest); + } + + void bundle_received_event:: + dest (::std::auto_ptr< dest::type > dest) + { + this->_xsd_dest_.set (dest); + } + + const bundle_received_event::custodian::type& bundle_received_event:: + custodian () const + { + return this->_xsd_custodian_.get (); + } + + bundle_received_event::custodian::type& bundle_received_event:: + custodian () + { + return this->_xsd_custodian_.get (); + } + + void bundle_received_event:: + custodian (const custodian::type& custodian) + { + this->_xsd_custodian_.set (custodian); + } + + void bundle_received_event:: + custodian (::std::auto_ptr< custodian::type > custodian) + { + this->_xsd_custodian_.set (custodian); + } + + const bundle_received_event::replyto::type& bundle_received_event:: + replyto () const + { + return this->_xsd_replyto_.get (); + } + + bundle_received_event::replyto::type& bundle_received_event:: + replyto () + { + return this->_xsd_replyto_.get (); + } + + void bundle_received_event:: + replyto (const replyto::type& replyto) + { + this->_xsd_replyto_.set (replyto); + } + + void bundle_received_event:: + replyto (::std::auto_ptr< replyto::type > replyto) + { + this->_xsd_replyto_.set (replyto); + } + + const bundle_received_event::prevhop::container& bundle_received_event:: + prevhop () const + { + return this->_xsd_prevhop_; + } + + bundle_received_event::prevhop::container& bundle_received_event:: + prevhop () + { + return this->_xsd_prevhop_; + } + + void bundle_received_event:: + prevhop (const prevhop::type& prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + void bundle_received_event:: + prevhop (const prevhop::container& prevhop) + { + this->_xsd_prevhop_ = prevhop; + } + + void bundle_received_event:: + prevhop (::std::auto_ptr< prevhop::type > prevhop) + { + this->_xsd_prevhop_.set (prevhop); + } + + const bundle_received_event::local_id::type& bundle_received_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_received_event::local_id::type& bundle_received_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_received_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + const bundle_received_event::expiration::type& bundle_received_event:: + expiration () const + { + return this->_xsd_expiration_.get (); + } + + bundle_received_event::expiration::type& bundle_received_event:: + expiration () + { + return this->_xsd_expiration_.get (); + } + + void bundle_received_event:: + expiration (const expiration::type& expiration) + { + this->_xsd_expiration_.set (expiration); + } + + 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::num_meta_blocks::container& bundle_received_event:: + num_meta_blocks () const + { + return this->_xsd_num_meta_blocks_; + } + + bundle_received_event::num_meta_blocks::container& bundle_received_event:: + num_meta_blocks () + { + return this->_xsd_num_meta_blocks_; + } + + void bundle_received_event:: + num_meta_blocks (const num_meta_blocks::type& num_meta_blocks) + { + this->_xsd_num_meta_blocks_.set (num_meta_blocks); + } + + void bundle_received_event:: + num_meta_blocks (const num_meta_blocks::container& num_meta_blocks) + { + this->_xsd_num_meta_blocks_ = num_meta_blocks; + } + + + // data_transmitted_event + // + + const data_transmitted_event::gbof_id::type& data_transmitted_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + data_transmitted_event::gbof_id::type& data_transmitted_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void data_transmitted_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void data_transmitted_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const data_transmitted_event::local_id::type& data_transmitted_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + data_transmitted_event::local_id::type& data_transmitted_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void data_transmitted_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + const data_transmitted_event::link_id::type& data_transmitted_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + data_transmitted_event::link_id::type& data_transmitted_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void data_transmitted_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void data_transmitted_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const data_transmitted_event::bytes_sent::type& data_transmitted_event:: + bytes_sent () const + { + return this->_xsd_bytes_sent_.get (); + } + + data_transmitted_event::bytes_sent::type& data_transmitted_event:: + bytes_sent () + { + return this->_xsd_bytes_sent_.get (); + } + + void data_transmitted_event:: + bytes_sent (const bytes_sent::type& bytes_sent) + { + this->_xsd_bytes_sent_.set (bytes_sent); + } + + const data_transmitted_event::reliably_sent::type& data_transmitted_event:: + reliably_sent () const + { + return this->_xsd_reliably_sent_.get (); + } + + data_transmitted_event::reliably_sent::type& data_transmitted_event:: + reliably_sent () + { + return this->_xsd_reliably_sent_.get (); + } + + void data_transmitted_event:: + reliably_sent (const reliably_sent::type& reliably_sent) + { + this->_xsd_reliably_sent_.set (reliably_sent); + } + + + // bundle_delivered_event + // + + const bundle_delivered_event::gbof_id::type& bundle_delivered_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_delivered_event::gbof_id::type& bundle_delivered_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_delivered_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_delivered_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_delivered_event::local_id::type& bundle_delivered_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_delivered_event::local_id::type& bundle_delivered_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_delivered_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // bundle_delivery_event + // + + const bundle_delivery_event::gbof_id::type& bundle_delivery_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_delivery_event::gbof_id::type& bundle_delivery_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_delivery_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_delivery_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_delivery_event::bundle::type& bundle_delivery_event:: + bundle () const + { + return this->_xsd_bundle_.get (); + } + + bundle_delivery_event::bundle::type& bundle_delivery_event:: + bundle () + { + return this->_xsd_bundle_.get (); + } + + void bundle_delivery_event:: + bundle (const bundle::type& bundle) + { + this->_xsd_bundle_.set (bundle); + } + + void bundle_delivery_event:: + bundle (::std::auto_ptr< bundle::type > bundle) + { + this->_xsd_bundle_.set (bundle); + } + + const bundle_delivery_event::local_id::type& bundle_delivery_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_delivery_event::local_id::type& bundle_delivery_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_delivery_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // bundle_send_cancelled_event + // + + const bundle_send_cancelled_event::gbof_id::type& bundle_send_cancelled_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_send_cancelled_event::gbof_id::type& bundle_send_cancelled_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_send_cancelled_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_send_cancelled_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_send_cancelled_event::link_id::type& bundle_send_cancelled_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + bundle_send_cancelled_event::link_id::type& bundle_send_cancelled_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void bundle_send_cancelled_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void bundle_send_cancelled_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const bundle_send_cancelled_event::local_id::type& bundle_send_cancelled_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_send_cancelled_event::local_id::type& bundle_send_cancelled_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_send_cancelled_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // bundle_expired_event + // + + const bundle_expired_event::gbof_id::type& bundle_expired_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_expired_event::gbof_id::type& bundle_expired_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_expired_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_expired_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_expired_event::local_id::type& bundle_expired_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_expired_event::local_id::type& bundle_expired_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_expired_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // bundle_injected_event + // + + const bundle_injected_event::request_id::type& bundle_injected_event:: + request_id () const + { + return this->_xsd_request_id_.get (); + } + + bundle_injected_event::request_id::type& bundle_injected_event:: + request_id () + { + return this->_xsd_request_id_.get (); + } + + void bundle_injected_event:: + request_id (const request_id::type& request_id) + { + this->_xsd_request_id_.set (request_id); + } + + void bundle_injected_event:: + request_id (::std::auto_ptr< request_id::type > request_id) + { + this->_xsd_request_id_.set (request_id); + } + + const bundle_injected_event::gbof_id::type& bundle_injected_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_injected_event::gbof_id::type& bundle_injected_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_injected_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_injected_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_injected_event::local_id::type& bundle_injected_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_injected_event::local_id::type& bundle_injected_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_injected_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // link_opened_event + // + + const link_opened_event::contact_attr::type& link_opened_event:: + contact_attr () const + { + return this->_xsd_contact_attr_.get (); + } + + link_opened_event::contact_attr::type& link_opened_event:: + contact_attr () + { + return this->_xsd_contact_attr_.get (); + } + + void link_opened_event:: + contact_attr (const contact_attr::type& contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + void link_opened_event:: + contact_attr (::std::auto_ptr< contact_attr::type > contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + const link_opened_event::link_id::type& link_opened_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_opened_event::link_id::type& link_opened_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_opened_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_opened_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // link_closed_event + // + + const link_closed_event::contact_attr::type& link_closed_event:: + contact_attr () const + { + return this->_xsd_contact_attr_.get (); + } + + link_closed_event::contact_attr::type& link_closed_event:: + contact_attr () + { + return this->_xsd_contact_attr_.get (); + } + + void link_closed_event:: + contact_attr (const contact_attr::type& contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + void link_closed_event:: + contact_attr (::std::auto_ptr< contact_attr::type > contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + const link_closed_event::link_id::type& link_closed_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_closed_event::link_id::type& link_closed_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_closed_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_closed_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const link_closed_event::reason::type& link_closed_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_closed_event::reason::type& link_closed_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_closed_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_closed_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_created_event + // + + const link_created_event::link_attr::type& link_created_event:: + link_attr () const + { + return this->_xsd_link_attr_.get (); + } + + link_created_event::link_attr::type& link_created_event:: + link_attr () + { + return this->_xsd_link_attr_.get (); + } + + void link_created_event:: + link_attr (const link_attr::type& link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + void link_created_event:: + link_attr (::std::auto_ptr< link_attr::type > link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + const link_created_event::link_id::type& link_created_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_created_event::link_id::type& link_created_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_created_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_created_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + 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_deleted_event + // + + const link_deleted_event::link_id::type& link_deleted_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_deleted_event::link_id::type& link_deleted_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_deleted_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_deleted_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + 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_available_event + // + + const link_available_event::link_id::type& link_available_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_available_event::link_id::type& link_available_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_available_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_available_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const link_available_event::reason::type& link_available_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_available_event::reason::type& link_available_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_available_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_available_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_unavailable_event + // + + const link_unavailable_event::link_id::type& link_unavailable_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_unavailable_event::link_id::type& link_unavailable_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_unavailable_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_unavailable_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const link_unavailable_event::reason::type& link_unavailable_event:: + reason () const + { + return this->_xsd_reason_.get (); + } + + link_unavailable_event::reason::type& link_unavailable_event:: + reason () + { + return this->_xsd_reason_.get (); + } + + void link_unavailable_event:: + reason (const reason::type& reason) + { + this->_xsd_reason_.set (reason); + } + + void link_unavailable_event:: + reason (::std::auto_ptr< reason::type > reason) + { + this->_xsd_reason_.set (reason); + } + + + // link_attribute_changed_event + // + + const link_attribute_changed_event::link_attr::type& link_attribute_changed_event:: + link_attr () const + { + return this->_xsd_link_attr_.get (); + } + + link_attribute_changed_event::link_attr::type& link_attribute_changed_event:: + link_attr () + { + return this->_xsd_link_attr_.get (); + } + + void link_attribute_changed_event:: + link_attr (const link_attr::type& link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + void link_attribute_changed_event:: + link_attr (::std::auto_ptr< link_attr::type > link_attr) + { + this->_xsd_link_attr_.set (link_attr); + } + + const link_attribute_changed_event::link_id::type& link_attribute_changed_event:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_attribute_changed_event::link_id::type& link_attribute_changed_event:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_attribute_changed_event:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_attribute_changed_event:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + 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_eid::type& contact_attribute_changed_event:: + contact_eid () const + { + return this->_xsd_contact_eid_.get (); + } + + contact_attribute_changed_event::contact_eid::type& contact_attribute_changed_event:: + contact_eid () + { + return this->_xsd_contact_eid_.get (); + } + + void contact_attribute_changed_event:: + contact_eid (const contact_eid::type& contact_eid) + { + this->_xsd_contact_eid_.set (contact_eid); + } + + void contact_attribute_changed_event:: + contact_eid (::std::auto_ptr< contact_eid::type > contact_eid) + { + this->_xsd_contact_eid_.set (contact_eid); + } + + const contact_attribute_changed_event::contact_attr::type& contact_attribute_changed_event:: + contact_attr () const + { + return this->_xsd_contact_attr_.get (); + } + + contact_attribute_changed_event::contact_attr::type& contact_attribute_changed_event:: + contact_attr () + { + return this->_xsd_contact_attr_.get (); + } + + void contact_attribute_changed_event:: + contact_attr (const contact_attr::type& contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + void contact_attribute_changed_event:: + contact_attr (::std::auto_ptr< contact_attr::type > contact_attr) + { + this->_xsd_contact_attr_.set (contact_attr); + } + + 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_busy_event + // + + const link_busy_event::link::type& link_busy_event:: + link () const + { + return this->_xsd_link_.get (); + } + + link_busy_event::link::type& link_busy_event:: + link () + { + return this->_xsd_link_.get (); + } + + void link_busy_event:: + link (const link::type& link) + { + this->_xsd_link_.set (link); + } + + void link_busy_event:: + link (::std::auto_ptr< link::type > link) + { + this->_xsd_link_.set (link); + } + + + // eid_reachable_event + // + + 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); + } + + 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); + } + + + // route_add_event + // + + const route_add_event::route_entry::type& route_add_event:: + route_entry () const + { + return this->_xsd_route_entry_.get (); + } + + route_add_event::route_entry::type& route_add_event:: + route_entry () + { + return this->_xsd_route_entry_.get (); + } + + void route_add_event:: + route_entry (const route_entry::type& route_entry) + { + this->_xsd_route_entry_.set (route_entry); + } + + void route_add_event:: + route_entry (::std::auto_ptr< route_entry::type > route_entry) + { + this->_xsd_route_entry_.set (route_entry); + } + + + // route_delete_event + // + + const route_delete_event::dest::type& route_delete_event:: + dest () const + { + return this->_xsd_dest_.get (); + } + + route_delete_event::dest::type& route_delete_event:: + dest () + { + return this->_xsd_dest_.get (); + } + + void route_delete_event:: + dest (const dest::type& dest) + { + this->_xsd_dest_.set (dest); + } + + void route_delete_event:: + dest (::std::auto_ptr< dest::type > dest) + { + this->_xsd_dest_.set (dest); + } + + + // custody_signal_event + // + + const custody_signal_event::gbof_id::type& custody_signal_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + custody_signal_event::gbof_id::type& custody_signal_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void custody_signal_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void custody_signal_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const custody_signal_event::custody_signal_attr::type& custody_signal_event:: + custody_signal_attr () const + { + return this->_xsd_custody_signal_attr_.get (); + } + + custody_signal_event::custody_signal_attr::type& custody_signal_event:: + custody_signal_attr () + { + return this->_xsd_custody_signal_attr_.get (); + } + + void custody_signal_event:: + custody_signal_attr (const custody_signal_attr::type& custody_signal_attr) + { + this->_xsd_custody_signal_attr_.set (custody_signal_attr); + } + + void custody_signal_event:: + custody_signal_attr (::std::auto_ptr< custody_signal_attr::type > custody_signal_attr) + { + this->_xsd_custody_signal_attr_.set (custody_signal_attr); + } + + const custody_signal_event::local_id::type& custody_signal_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + custody_signal_event::local_id::type& custody_signal_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void custody_signal_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // custody_timeout_event + // + + const custody_timeout_event::gbof_id::type& custody_timeout_event:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + custody_timeout_event::gbof_id::type& custody_timeout_event:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void custody_timeout_event:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void custody_timeout_event:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const custody_timeout_event::local_id::type& custody_timeout_event:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + custody_timeout_event::local_id::type& custody_timeout_event:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void custody_timeout_event:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // intentional_name_resolved_event + // + + const intentional_name_resolved_event::request_id::type& intentional_name_resolved_event:: + request_id () const + { + return this->_xsd_request_id_.get (); + } + + intentional_name_resolved_event::request_id::type& intentional_name_resolved_event:: + request_id () + { + return this->_xsd_request_id_.get (); + } + + void intentional_name_resolved_event:: + request_id (const request_id::type& request_id) + { + this->_xsd_request_id_.set (request_id); + } + + void intentional_name_resolved_event:: + request_id (::std::auto_ptr< request_id::type > request_id) + { + this->_xsd_request_id_.set (request_id); + } + + const intentional_name_resolved_event::response_id::type& intentional_name_resolved_event:: + response_id () const + { + return this->_xsd_response_id_.get (); + } + + intentional_name_resolved_event::response_id::type& intentional_name_resolved_event:: + response_id () + { + return this->_xsd_response_id_.get (); + } + + void intentional_name_resolved_event:: + response_id (const response_id::type& response_id) + { + this->_xsd_response_id_.set (response_id); + } + + void intentional_name_resolved_event:: + response_id (::std::auto_ptr< response_id::type > response_id) + { + this->_xsd_response_id_.set (response_id); + } + + const intentional_name_resolved_event::router_eid::type& intentional_name_resolved_event:: + router_eid () const + { + return this->_xsd_router_eid_.get (); + } + + intentional_name_resolved_event::router_eid::type& intentional_name_resolved_event:: + router_eid () + { + return this->_xsd_router_eid_.get (); + } + + void intentional_name_resolved_event:: + router_eid (const router_eid::type& router_eid) + { + this->_xsd_router_eid_.set (router_eid); + } + + void intentional_name_resolved_event:: + router_eid (::std::auto_ptr< router_eid::type > router_eid) + { + this->_xsd_router_eid_.set (router_eid); + } + + const intentional_name_resolved_event::lb_dp_eid::container& intentional_name_resolved_event:: + lb_dp_eid () const + { + return this->_xsd_lb_dp_eid_; + } + + intentional_name_resolved_event::lb_dp_eid::container& intentional_name_resolved_event:: + lb_dp_eid () + { + return this->_xsd_lb_dp_eid_; + } + + void intentional_name_resolved_event:: + lb_dp_eid (const lb_dp_eid::type& lb_dp_eid) + { + this->_xsd_lb_dp_eid_.set (lb_dp_eid); + } + + void intentional_name_resolved_event:: + lb_dp_eid (const lb_dp_eid::container& lb_dp_eid) + { + this->_xsd_lb_dp_eid_ = lb_dp_eid; + } + + void intentional_name_resolved_event:: + lb_dp_eid (::std::auto_ptr< lb_dp_eid::type > lb_dp_eid) + { + this->_xsd_lb_dp_eid_.set (lb_dp_eid); + } + + const intentional_name_resolved_event::intentional_name::type& intentional_name_resolved_event:: + intentional_name () const + { + return this->_xsd_intentional_name_.get (); + } + + intentional_name_resolved_event::intentional_name::type& intentional_name_resolved_event:: + intentional_name () + { + return this->_xsd_intentional_name_.get (); + } + + void intentional_name_resolved_event:: + intentional_name (const intentional_name::type& intentional_name) + { + this->_xsd_intentional_name_.set (intentional_name); + } + + void intentional_name_resolved_event:: + intentional_name (::std::auto_ptr< intentional_name::type > intentional_name) + { + this->_xsd_intentional_name_.set (intentional_name); + } + + const intentional_name_resolved_event::grain_state::type& intentional_name_resolved_event:: + grain_state () const + { + return this->_xsd_grain_state_.get (); + } + + intentional_name_resolved_event::grain_state::type& intentional_name_resolved_event:: + grain_state () + { + return this->_xsd_grain_state_.get (); + } + + void intentional_name_resolved_event:: + grain_state (const grain_state::type& grain_state) + { + this->_xsd_grain_state_.set (grain_state); + } + + void intentional_name_resolved_event:: + grain_state (::std::auto_ptr< grain_state::type > grain_state) + { + this->_xsd_grain_state_.set (grain_state); + } + + const intentional_name_resolved_event::canonical_eids::container& intentional_name_resolved_event:: + canonical_eids () const + { + return this->_xsd_canonical_eids_; + } + + intentional_name_resolved_event::canonical_eids::container& intentional_name_resolved_event:: + canonical_eids () + { + return this->_xsd_canonical_eids_; + } + + void intentional_name_resolved_event:: + canonical_eids (const canonical_eids::container& canonical_eids) + { + this->_xsd_canonical_eids_ = canonical_eids; + } + + const intentional_name_resolved_event::app_eids::container& intentional_name_resolved_event:: + app_eids () const + { + return this->_xsd_app_eids_; + } + + intentional_name_resolved_event::app_eids::container& intentional_name_resolved_event:: + app_eids () + { + return this->_xsd_app_eids_; + } + + void intentional_name_resolved_event:: + app_eids (const app_eids::container& app_eids) + { + this->_xsd_app_eids_ = app_eids; + } + + + // registration_added_event + // + + const registration_added_event::registration::type& registration_added_event:: + registration () const + { + return this->_xsd_registration_.get (); + } + + registration_added_event::registration::type& registration_added_event:: + registration () + { + return this->_xsd_registration_.get (); + } + + void registration_added_event:: + registration (const registration::type& registration) + { + this->_xsd_registration_.set (registration); + } + + void registration_added_event:: + registration (::std::auto_ptr< registration::type > registration) + { + this->_xsd_registration_.set (registration); + } + + const registration_added_event::source::type& registration_added_event:: + source () const + { + return this->_xsd_source_.get (); + } + + registration_added_event::source::type& registration_added_event:: + source () + { + return this->_xsd_source_.get (); + } + + void registration_added_event:: + source (const source::type& source) + { + this->_xsd_source_.set (source); + } + + void registration_added_event:: + source (::std::auto_ptr< source::type > source) + { + this->_xsd_source_.set (source); + } + + + // registration_removed_event + // + + const registration_removed_event::registration::type& registration_removed_event:: + registration () const + { + return this->_xsd_registration_.get (); + } + + registration_removed_event::registration::type& registration_removed_event:: + registration () + { + return this->_xsd_registration_.get (); + } + + void registration_removed_event:: + registration (const registration::type& registration) + { + this->_xsd_registration_.set (registration); + } + + void registration_removed_event:: + registration (::std::auto_ptr< registration::type > registration) + { + this->_xsd_registration_.set (registration); + } + + + // registration_expired_event + // + + const registration_expired_event::regid::type& registration_expired_event:: + regid () const + { + return this->_xsd_regid_.get (); + } + + registration_expired_event::regid::type& registration_expired_event:: + regid () + { + return this->_xsd_regid_.get (); + } + + void registration_expired_event:: + regid (const regid::type& regid) + { + this->_xsd_regid_.set (regid); + } + + + // open_link_request + // + + const open_link_request::link_id::type& open_link_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + open_link_request::link_id::type& open_link_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void open_link_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void open_link_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // close_link_request + // + + const close_link_request::link_id::type& close_link_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + close_link_request::link_id::type& close_link_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void close_link_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void close_link_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // add_link_request + // + + const add_link_request::link_config_params::container& add_link_request:: + link_config_params () const + { + return this->_xsd_link_config_params_; + } + + add_link_request::link_config_params::container& add_link_request:: + link_config_params () + { + return this->_xsd_link_config_params_; + } + + void add_link_request:: + link_config_params (const link_config_params::type& link_config_params) + { + this->_xsd_link_config_params_.set (link_config_params); + } + + void add_link_request:: + link_config_params (const link_config_params::container& link_config_params) + { + this->_xsd_link_config_params_ = link_config_params; + } + + void add_link_request:: + link_config_params (::std::auto_ptr< link_config_params::type > link_config_params) + { + this->_xsd_link_config_params_.set (link_config_params); + } + + const add_link_request::remote_eid::type& add_link_request:: + remote_eid () const + { + return this->_xsd_remote_eid_.get (); + } + + add_link_request::remote_eid::type& add_link_request:: + remote_eid () + { + return this->_xsd_remote_eid_.get (); + } + + void add_link_request:: + remote_eid (const remote_eid::type& remote_eid) + { + this->_xsd_remote_eid_.set (remote_eid); + } + + void add_link_request:: + remote_eid (::std::auto_ptr< remote_eid::type > remote_eid) + { + this->_xsd_remote_eid_.set (remote_eid); + } + + const add_link_request::link_id::type& add_link_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + add_link_request::link_id::type& add_link_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void add_link_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void add_link_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const add_link_request::link_type::type& add_link_request:: + link_type () const + { + return this->_xsd_link_type_.get (); + } + + add_link_request::link_type::type& add_link_request:: + link_type () + { + return this->_xsd_link_type_.get (); + } + + void add_link_request:: + link_type (const link_type::type& link_type) + { + this->_xsd_link_type_.set (link_type); + } + + void add_link_request:: + link_type (::std::auto_ptr< link_type::type > link_type) + { + this->_xsd_link_type_.set (link_type); + } + + const add_link_request::clayer::type& add_link_request:: + clayer () const + { + return this->_xsd_clayer_.get (); + } + + add_link_request::clayer::type& add_link_request:: + clayer () + { + return this->_xsd_clayer_.get (); + } + + void add_link_request:: + clayer (const clayer::type& clayer) + { + this->_xsd_clayer_.set (clayer); + } + + void add_link_request:: + clayer (::std::auto_ptr< clayer::type > clayer) + { + this->_xsd_clayer_.set (clayer); + } + + + // delete_link_request + // + + const delete_link_request::link_id::type& delete_link_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + delete_link_request::link_id::type& delete_link_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void delete_link_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void delete_link_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // reconfigure_link_request + // + + const reconfigure_link_request::link_config_params::type& reconfigure_link_request:: + link_config_params () const + { + return this->_xsd_link_config_params_.get (); + } + + reconfigure_link_request::link_config_params::type& reconfigure_link_request:: + link_config_params () + { + return this->_xsd_link_config_params_.get (); + } + + void reconfigure_link_request:: + link_config_params (const link_config_params::type& link_config_params) + { + this->_xsd_link_config_params_.set (link_config_params); + } + + void reconfigure_link_request:: + link_config_params (::std::auto_ptr< link_config_params::type > link_config_params) + { + this->_xsd_link_config_params_.set (link_config_params); + } + + const reconfigure_link_request::link_id::type& reconfigure_link_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + reconfigure_link_request::link_id::type& reconfigure_link_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void reconfigure_link_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void reconfigure_link_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // send_bundle_request + // + + const send_bundle_request::gbof_id::type& send_bundle_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + send_bundle_request::gbof_id::type& send_bundle_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void send_bundle_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void send_bundle_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const send_bundle_request::metadata_block::container& send_bundle_request:: + metadata_block () const + { + return this->_xsd_metadata_block_; + } + + send_bundle_request::metadata_block::container& send_bundle_request:: + metadata_block () + { + return this->_xsd_metadata_block_; + } + + void send_bundle_request:: + metadata_block (const metadata_block::container& metadata_block) + { + this->_xsd_metadata_block_ = metadata_block; + } + + const send_bundle_request::local_id::type& send_bundle_request:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + send_bundle_request::local_id::type& send_bundle_request:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void send_bundle_request:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + const send_bundle_request::link_id::type& send_bundle_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + send_bundle_request::link_id::type& send_bundle_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void send_bundle_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void send_bundle_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const send_bundle_request::fwd_action::type& send_bundle_request:: + fwd_action () const + { + return this->_xsd_fwd_action_.get (); + } + + send_bundle_request::fwd_action::type& send_bundle_request:: + fwd_action () + { + return this->_xsd_fwd_action_.get (); + } + + void send_bundle_request:: + fwd_action (const fwd_action::type& fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + void send_bundle_request:: + fwd_action (::std::auto_ptr< fwd_action::type > fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + const send_bundle_request::frag_size::container& send_bundle_request:: + frag_size () const + { + return this->_xsd_frag_size_; + } + + send_bundle_request::frag_size::container& send_bundle_request:: + frag_size () + { + return this->_xsd_frag_size_; + } + + void send_bundle_request:: + frag_size (const frag_size::type& frag_size) + { + this->_xsd_frag_size_.set (frag_size); + } + + void send_bundle_request:: + frag_size (const frag_size::container& frag_size) + { + this->_xsd_frag_size_ = frag_size; + } + + const send_bundle_request::frag_offset::container& send_bundle_request:: + frag_offset () const + { + return this->_xsd_frag_offset_; + } + + send_bundle_request::frag_offset::container& send_bundle_request:: + frag_offset () + { + return this->_xsd_frag_offset_; + } + + void send_bundle_request:: + frag_offset (const frag_offset::type& frag_offset) + { + this->_xsd_frag_offset_.set (frag_offset); + } + + void send_bundle_request:: + frag_offset (const frag_offset::container& frag_offset) + { + this->_xsd_frag_offset_ = frag_offset; + } + + + // send_bundle_broadcast_request + // + + const send_bundle_broadcast_request::gbof_id::type& send_bundle_broadcast_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + send_bundle_broadcast_request::gbof_id::type& send_bundle_broadcast_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void send_bundle_broadcast_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void send_bundle_broadcast_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const send_bundle_broadcast_request::metadata_block::container& send_bundle_broadcast_request:: + metadata_block () const + { + return this->_xsd_metadata_block_; + } + + send_bundle_broadcast_request::metadata_block::container& send_bundle_broadcast_request:: + metadata_block () + { + return this->_xsd_metadata_block_; + } + + void send_bundle_broadcast_request:: + metadata_block (const metadata_block::container& metadata_block) + { + this->_xsd_metadata_block_ = metadata_block; + } + + const send_bundle_broadcast_request::local_id::type& send_bundle_broadcast_request:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + send_bundle_broadcast_request::local_id::type& send_bundle_broadcast_request:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void send_bundle_broadcast_request:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + const send_bundle_broadcast_request::fwd_action::type& send_bundle_broadcast_request:: + fwd_action () const + { + return this->_xsd_fwd_action_.get (); + } + + send_bundle_broadcast_request::fwd_action::type& send_bundle_broadcast_request:: + fwd_action () + { + return this->_xsd_fwd_action_.get (); + } + + void send_bundle_broadcast_request:: + fwd_action (const fwd_action::type& fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + void send_bundle_broadcast_request:: + fwd_action (::std::auto_ptr< fwd_action::type > fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + const send_bundle_broadcast_request::frag_size::container& send_bundle_broadcast_request:: + frag_size () const + { + return this->_xsd_frag_size_; + } + + send_bundle_broadcast_request::frag_size::container& send_bundle_broadcast_request:: + frag_size () + { + return this->_xsd_frag_size_; + } + + void send_bundle_broadcast_request:: + frag_size (const frag_size::type& frag_size) + { + this->_xsd_frag_size_.set (frag_size); + } + + void send_bundle_broadcast_request:: + frag_size (const frag_size::container& frag_size) + { + this->_xsd_frag_size_ = frag_size; + } + + const send_bundle_broadcast_request::frag_offset::container& send_bundle_broadcast_request:: + frag_offset () const + { + return this->_xsd_frag_offset_; + } + + send_bundle_broadcast_request::frag_offset::container& send_bundle_broadcast_request:: + frag_offset () + { + return this->_xsd_frag_offset_; + } + + void send_bundle_broadcast_request:: + frag_offset (const frag_offset::type& frag_offset) + { + this->_xsd_frag_offset_.set (frag_offset); + } + + void send_bundle_broadcast_request:: + frag_offset (const frag_offset::container& frag_offset) + { + this->_xsd_frag_offset_ = frag_offset; + } + + + // cancel_bundle_request + // + + const cancel_bundle_request::gbof_id::type& cancel_bundle_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + cancel_bundle_request::gbof_id::type& cancel_bundle_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void cancel_bundle_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void cancel_bundle_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const cancel_bundle_request::local_id::type& cancel_bundle_request:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + cancel_bundle_request::local_id::type& cancel_bundle_request:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void cancel_bundle_request:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + const cancel_bundle_request::link_id::type& cancel_bundle_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + cancel_bundle_request::link_id::type& cancel_bundle_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void cancel_bundle_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void cancel_bundle_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + + // inject_bundle_request + // + + const inject_bundle_request::source::type& inject_bundle_request:: + source () const + { + return this->_xsd_source_.get (); + } + + inject_bundle_request::source::type& inject_bundle_request:: + source () + { + return this->_xsd_source_.get (); + } + + void inject_bundle_request:: + source (const source::type& source) + { + this->_xsd_source_.set (source); + } + + void inject_bundle_request:: + source (::std::auto_ptr< source::type > source) + { + this->_xsd_source_.set (source); + } + + const inject_bundle_request::dest::type& inject_bundle_request:: + dest () const + { + return this->_xsd_dest_.get (); + } + + inject_bundle_request::dest::type& inject_bundle_request:: + dest () + { + return this->_xsd_dest_.get (); + } + + void inject_bundle_request:: + dest (const dest::type& dest) + { + this->_xsd_dest_.set (dest); + } + + void inject_bundle_request:: + dest (::std::auto_ptr< dest::type > dest) + { + this->_xsd_dest_.set (dest); + } + + const inject_bundle_request::replyto::container& inject_bundle_request:: + replyto () const + { + return this->_xsd_replyto_; + } + + inject_bundle_request::replyto::container& inject_bundle_request:: + replyto () + { + return this->_xsd_replyto_; + } + + void inject_bundle_request:: + replyto (const replyto::type& replyto) + { + this->_xsd_replyto_.set (replyto); + } + + void inject_bundle_request:: + replyto (const replyto::container& replyto) + { + this->_xsd_replyto_ = replyto; + } + + void inject_bundle_request:: + replyto (::std::auto_ptr< replyto::type > replyto) + { + this->_xsd_replyto_.set (replyto); + } + + const inject_bundle_request::custodian::container& inject_bundle_request:: + custodian () const + { + return this->_xsd_custodian_; + } + + inject_bundle_request::custodian::container& inject_bundle_request:: + custodian () + { + return this->_xsd_custodian_; + } + + void inject_bundle_request:: + custodian (const custodian::type& custodian) + { + this->_xsd_custodian_.set (custodian); + } + + void inject_bundle_request:: + custodian (const custodian::container& custodian) + { + this->_xsd_custodian_ = custodian; + } + + void inject_bundle_request:: + custodian (::std::auto_ptr< custodian::type > custodian) + { + this->_xsd_custodian_.set (custodian); + } + + const inject_bundle_request::request_id::type& inject_bundle_request:: + request_id () const + { + return this->_xsd_request_id_.get (); + } + + inject_bundle_request::request_id::type& inject_bundle_request:: + request_id () + { + return this->_xsd_request_id_.get (); + } + + void inject_bundle_request:: + request_id (const request_id::type& request_id) + { + this->_xsd_request_id_.set (request_id); + } + + void inject_bundle_request:: + request_id (::std::auto_ptr< request_id::type > request_id) + { + this->_xsd_request_id_.set (request_id); + } + + const inject_bundle_request::link_id::type& inject_bundle_request:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + inject_bundle_request::link_id::type& inject_bundle_request:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void inject_bundle_request:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void inject_bundle_request:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const inject_bundle_request::fwd_action::container& inject_bundle_request:: + fwd_action () const + { + return this->_xsd_fwd_action_; + } + + inject_bundle_request::fwd_action::container& inject_bundle_request:: + fwd_action () + { + return this->_xsd_fwd_action_; + } + + void inject_bundle_request:: + fwd_action (const fwd_action::type& fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + void inject_bundle_request:: + fwd_action (const fwd_action::container& fwd_action) + { + this->_xsd_fwd_action_ = fwd_action; + } + + void inject_bundle_request:: + fwd_action (::std::auto_ptr< fwd_action::type > fwd_action) + { + this->_xsd_fwd_action_.set (fwd_action); + } + + const inject_bundle_request::priority::container& inject_bundle_request:: + priority () const + { + return this->_xsd_priority_; + } + + inject_bundle_request::priority::container& inject_bundle_request:: + priority () + { + return this->_xsd_priority_; + } + + void inject_bundle_request:: + priority (const priority::type& priority) + { + this->_xsd_priority_.set (priority); + } + + void inject_bundle_request:: + priority (const priority::container& priority) + { + this->_xsd_priority_ = priority; + } + + void inject_bundle_request:: + priority (::std::auto_ptr< priority::type > priority) + { + this->_xsd_priority_.set (priority); + } + + const inject_bundle_request::expiration::container& inject_bundle_request:: + expiration () const + { + return this->_xsd_expiration_; + } + + inject_bundle_request::expiration::container& inject_bundle_request:: + expiration () + { + return this->_xsd_expiration_; + } + + void inject_bundle_request:: + expiration (const expiration::type& expiration) + { + this->_xsd_expiration_.set (expiration); + } + + void inject_bundle_request:: + expiration (const expiration::container& expiration) + { + this->_xsd_expiration_ = expiration; + } + + const inject_bundle_request::payload_file::type& inject_bundle_request:: + payload_file () const + { + return this->_xsd_payload_file_.get (); + } + + inject_bundle_request::payload_file::type& inject_bundle_request:: + payload_file () + { + return this->_xsd_payload_file_.get (); + } + + void inject_bundle_request:: + payload_file (const payload_file::type& payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + void inject_bundle_request:: + payload_file (::std::auto_ptr< payload_file::type > payload_file) + { + this->_xsd_payload_file_.set (payload_file); + } + + + // delete_bundle_request + // + + const delete_bundle_request::gbof_id::type& delete_bundle_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + delete_bundle_request::gbof_id::type& delete_bundle_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void delete_bundle_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void delete_bundle_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const delete_bundle_request::local_id::type& delete_bundle_request:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + delete_bundle_request::local_id::type& delete_bundle_request:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void delete_bundle_request:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // set_cl_params_request + // + + const set_cl_params_request::cl_params::container& set_cl_params_request:: + cl_params () const + { + return this->_xsd_cl_params_; + } + + set_cl_params_request::cl_params::container& set_cl_params_request:: + cl_params () + { + return this->_xsd_cl_params_; + } + + void set_cl_params_request:: + cl_params (const cl_params::container& cl_params) + { + this->_xsd_cl_params_ = cl_params; + } + + const set_cl_params_request::clayer::type& set_cl_params_request:: + clayer () const + { + return this->_xsd_clayer_.get (); + } + + set_cl_params_request::clayer::type& set_cl_params_request:: + clayer () + { + return this->_xsd_clayer_.get (); + } + + void set_cl_params_request:: + clayer (const clayer::type& clayer) + { + this->_xsd_clayer_.set (clayer); + } + + void set_cl_params_request:: + clayer (::std::auto_ptr< clayer::type > clayer) + { + this->_xsd_clayer_.set (clayer); + } + + + // intentional_name_resolution_request + // + + const intentional_name_resolution_request::gbof_id::type& intentional_name_resolution_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + intentional_name_resolution_request::gbof_id::type& intentional_name_resolution_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void intentional_name_resolution_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void intentional_name_resolution_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const intentional_name_resolution_request::request_id::type& intentional_name_resolution_request:: + request_id () const + { + return this->_xsd_request_id_.get (); + } + + intentional_name_resolution_request::request_id::type& intentional_name_resolution_request:: + request_id () + { + return this->_xsd_request_id_.get (); + } + + void intentional_name_resolution_request:: + request_id (const request_id::type& request_id) + { + this->_xsd_request_id_.set (request_id); + } + + void intentional_name_resolution_request:: + request_id (::std::auto_ptr< request_id::type > request_id) + { + this->_xsd_request_id_.set (request_id); + } + + const intentional_name_resolution_request::router_eid::type& intentional_name_resolution_request:: + router_eid () const + { + return this->_xsd_router_eid_.get (); + } + + intentional_name_resolution_request::router_eid::type& intentional_name_resolution_request:: + router_eid () + { + return this->_xsd_router_eid_.get (); + } + + void intentional_name_resolution_request:: + router_eid (const router_eid::type& router_eid) + { + this->_xsd_router_eid_.set (router_eid); + } + + void intentional_name_resolution_request:: + router_eid (::std::auto_ptr< router_eid::type > router_eid) + { + this->_xsd_router_eid_.set (router_eid); + } + + const intentional_name_resolution_request::intentional_name::type& intentional_name_resolution_request:: + intentional_name () const + { + return this->_xsd_intentional_name_.get (); + } + + intentional_name_resolution_request::intentional_name::type& intentional_name_resolution_request:: + intentional_name () + { + return this->_xsd_intentional_name_.get (); + } + + void intentional_name_resolution_request:: + intentional_name (const intentional_name::type& intentional_name) + { + this->_xsd_intentional_name_.set (intentional_name); + } + + void intentional_name_resolution_request:: + intentional_name (::std::auto_ptr< intentional_name::type > intentional_name) + { + this->_xsd_intentional_name_.set (intentional_name); + } + + const intentional_name_resolution_request::grain_state::type& intentional_name_resolution_request:: + grain_state () const + { + return this->_xsd_grain_state_.get (); + } + + intentional_name_resolution_request::grain_state::type& intentional_name_resolution_request:: + grain_state () + { + return this->_xsd_grain_state_.get (); + } + + void intentional_name_resolution_request:: + grain_state (const grain_state::type& grain_state) + { + this->_xsd_grain_state_.set (grain_state); + } + + void intentional_name_resolution_request:: + grain_state (::std::auto_ptr< grain_state::type > grain_state) + { + this->_xsd_grain_state_.set (grain_state); + } + + + // deliver_bundle_to_app_request + // + + const deliver_bundle_to_app_request::endpoint::type& deliver_bundle_to_app_request:: + endpoint () const + { + return this->_xsd_endpoint_.get (); + } + + deliver_bundle_to_app_request::endpoint::type& deliver_bundle_to_app_request:: + endpoint () + { + return this->_xsd_endpoint_.get (); + } + + void deliver_bundle_to_app_request:: + endpoint (const endpoint::type& endpoint) + { + this->_xsd_endpoint_.set (endpoint); + } + + void deliver_bundle_to_app_request:: + endpoint (::std::auto_ptr< endpoint::type > endpoint) + { + this->_xsd_endpoint_.set (endpoint); + } + + const deliver_bundle_to_app_request::gbof_id::type& deliver_bundle_to_app_request:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + deliver_bundle_to_app_request::gbof_id::type& deliver_bundle_to_app_request:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void deliver_bundle_to_app_request:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void deliver_bundle_to_app_request:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const deliver_bundle_to_app_request::local_id::type& deliver_bundle_to_app_request:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + deliver_bundle_to_app_request::local_id::type& deliver_bundle_to_app_request:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void deliver_bundle_to_app_request:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // link_report + // + + const link_report::link::container& link_report:: + link () const + { + return this->_xsd_link_; + } + + link_report::link::container& link_report:: + link () + { + return this->_xsd_link_; + } + + void link_report:: + link (const link::container& link) + { + this->_xsd_link_ = link; + } + + + // link_attributes_query + // + + const link_attributes_query::query_id::type& link_attributes_query:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + link_attributes_query::query_id::type& link_attributes_query:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void link_attributes_query:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void link_attributes_query:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const link_attributes_query::link_id::type& link_attributes_query:: + link_id () const + { + return this->_xsd_link_id_.get (); + } + + link_attributes_query::link_id::type& link_attributes_query:: + link_id () + { + return this->_xsd_link_id_.get (); + } + + void link_attributes_query:: + link_id (const link_id::type& link_id) + { + this->_xsd_link_id_.set (link_id); + } + + void link_attributes_query:: + link_id (::std::auto_ptr< link_id::type > link_id) + { + this->_xsd_link_id_.set (link_id); + } + + const link_attributes_query::query_params::container& link_attributes_query:: + query_params () const + { + return this->_xsd_query_params_; + } + + link_attributes_query::query_params::container& link_attributes_query:: + query_params () + { + return this->_xsd_query_params_; + } + + void link_attributes_query:: + query_params (const query_params::container& query_params) + { + this->_xsd_query_params_ = query_params; + } + + + // link_attributes_report + // + + const link_attributes_report::query_id::type& link_attributes_report:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + link_attributes_report::query_id::type& link_attributes_report:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void link_attributes_report:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void link_attributes_report:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const link_attributes_report::report_params::container& link_attributes_report:: + report_params () const + { + return this->_xsd_report_params_; + } + + link_attributes_report::report_params::container& link_attributes_report:: + report_params () + { + return this->_xsd_report_params_; + } + + void link_attributes_report:: + report_params (const report_params::container& report_params) + { + this->_xsd_report_params_ = report_params; + } + + + // contact_report + // + + const contact_report::contact::container& contact_report:: + contact () const + { + return this->_xsd_contact_; + } + + contact_report::contact::container& contact_report:: + contact () + { + return this->_xsd_contact_; + } + + void contact_report:: + contact (const contact::container& contact) + { + this->_xsd_contact_ = contact; + } + + + // route_report + // + + const route_report::route_entry::container& route_report:: + route_entry () const + { + return this->_xsd_route_entry_; + } + + route_report::route_entry::container& route_report:: + route_entry () + { + return this->_xsd_route_entry_; + } + + void route_report:: + route_entry (const route_entry::container& route_entry) + { + this->_xsd_route_entry_ = route_entry; + } + + + // bundle_report + // + + const bundle_report::bundle::container& bundle_report:: + bundle () const + { + return this->_xsd_bundle_; + } + + bundle_report::bundle::container& bundle_report:: + bundle () + { + return this->_xsd_bundle_; + } + + void bundle_report:: + bundle (const bundle::container& bundle) + { + this->_xsd_bundle_ = bundle; + } + + + // bundle_attributes_query + // + + const bundle_attributes_query::query_id::type& bundle_attributes_query:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + bundle_attributes_query::query_id::type& bundle_attributes_query:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void bundle_attributes_query:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void bundle_attributes_query:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const bundle_attributes_query::gbof_id::type& bundle_attributes_query:: + gbof_id () const + { + return this->_xsd_gbof_id_.get (); + } + + bundle_attributes_query::gbof_id::type& bundle_attributes_query:: + gbof_id () + { + return this->_xsd_gbof_id_.get (); + } + + void bundle_attributes_query:: + gbof_id (const gbof_id::type& gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + void bundle_attributes_query:: + gbof_id (::std::auto_ptr< gbof_id::type > gbof_id) + { + this->_xsd_gbof_id_.set (gbof_id); + } + + const bundle_attributes_query::query_params::container& bundle_attributes_query:: + query_params () const + { + return this->_xsd_query_params_; + } + + bundle_attributes_query::query_params::container& bundle_attributes_query:: + query_params () + { + return this->_xsd_query_params_; + } + + void bundle_attributes_query:: + query_params (const query_params::container& query_params) + { + this->_xsd_query_params_ = query_params; + } + + const bundle_attributes_query::local_id::type& bundle_attributes_query:: + local_id () const + { + return this->_xsd_local_id_.get (); + } + + bundle_attributes_query::local_id::type& bundle_attributes_query:: + local_id () + { + return this->_xsd_local_id_.get (); + } + + void bundle_attributes_query:: + local_id (const local_id::type& local_id) + { + this->_xsd_local_id_.set (local_id); + } + + + // bundle_attributes_report + // + + const bundle_attributes_report::query_id::type& bundle_attributes_report:: + query_id () const + { + return this->_xsd_query_id_.get (); + } + + bundle_attributes_report::query_id::type& bundle_attributes_report:: + query_id () + { + return this->_xsd_query_id_.get (); + } + + void bundle_attributes_report:: + query_id (const query_id::type& query_id) + { + this->_xsd_query_id_.set (query_id); + } + + void bundle_attributes_report:: + query_id (::std::auto_ptr< query_id::type > query_id) + { + this->_xsd_query_id_.set (query_id); + } + + const bundle_attributes_report::report_params::type& bundle_attributes_report:: + report_params () const + { + return this->_xsd_report_params_.get (); + } + + bundle_attributes_report::report_params::type& bundle_attributes_report:: + report_params () + { + return this->_xsd_report_params_.get (); + } + + void bundle_attributes_report:: + report_params (const report_params::type& report_params) + { + this->_xsd_report_params_.set (report_params); + } + + void bundle_attributes_report:: + report_params (::std::auto_ptr< report_params::type > report_params) + { + this->_xsd_report_params_.set (report_params); + } + + + // bpa + // + + const bpa::bundle_received_event::container& bpa:: + bundle_received_event () const + { + return this->_xsd_bundle_received_event_; + } + + bpa::bundle_received_event::container& bpa:: + bundle_received_event () + { + return this->_xsd_bundle_received_event_; + } + + void bpa:: + bundle_received_event (const bundle_received_event::type& bundle_received_event) + { + this->_xsd_bundle_received_event_.set (bundle_received_event); + } + + void bpa:: + bundle_received_event (const bundle_received_event::container& bundle_received_event) + { + this->_xsd_bundle_received_event_ = bundle_received_event; + } + + void bpa:: + bundle_received_event (::std::auto_ptr< bundle_received_event::type > bundle_received_event) + { + this->_xsd_bundle_received_event_.set (bundle_received_event); + } + + const bpa::data_transmitted_event::container& bpa:: + data_transmitted_event () const + { + return this->_xsd_data_transmitted_event_; + } + + bpa::data_transmitted_event::container& bpa:: + data_transmitted_event () + { + return this->_xsd_data_transmitted_event_; + } + + void bpa:: + data_transmitted_event (const data_transmitted_event::type& data_transmitted_event) + { + this->_xsd_data_transmitted_event_.set (data_transmitted_event); + } + + void bpa:: + data_transmitted_event (const data_transmitted_event::container& data_transmitted_event) + { + this->_xsd_data_transmitted_event_ = data_transmitted_event; + } + + void bpa:: + data_transmitted_event (::std::auto_ptr< data_transmitted_event::type > data_transmitted_event) + { + this->_xsd_data_transmitted_event_.set (data_transmitted_event); + } + + const bpa::bundle_delivered_event::container& bpa:: + bundle_delivered_event () const + { + return this->_xsd_bundle_delivered_event_; + } + + bpa::bundle_delivered_event::container& bpa:: + bundle_delivered_event () + { + return this->_xsd_bundle_delivered_event_; + } + + void bpa:: + bundle_delivered_event (const bundle_delivered_event::type& bundle_delivered_event) + { + this->_xsd_bundle_delivered_event_.set (bundle_delivered_event); + } + + void bpa:: + bundle_delivered_event (const bundle_delivered_event::container& bundle_delivered_event) + { + this->_xsd_bundle_delivered_event_ = bundle_delivered_event; + } + + void bpa:: + bundle_delivered_event (::std::auto_ptr< bundle_delivered_event::type > bundle_delivered_event) + { + this->_xsd_bundle_delivered_event_.set (bundle_delivered_event); + } + + const bpa::bundle_delivery_event::container& bpa:: + bundle_delivery_event () const + { + return this->_xsd_bundle_delivery_event_; + } + + bpa::bundle_delivery_event::container& bpa:: + bundle_delivery_event () + { + return this->_xsd_bundle_delivery_event_; + } + + void bpa:: + bundle_delivery_event (const bundle_delivery_event::type& bundle_delivery_event) + { + this->_xsd_bundle_delivery_event_.set (bundle_delivery_event); + } + + void bpa:: + bundle_delivery_event (const bundle_delivery_event::container& bundle_delivery_event) + { + this->_xsd_bundle_delivery_event_ = bundle_delivery_event; + } + + void bpa:: + bundle_delivery_event (::std::auto_ptr< bundle_delivery_event::type > bundle_delivery_event) + { + this->_xsd_bundle_delivery_event_.set (bundle_delivery_event); + } + + const bpa::bundle_expired_event::container& bpa:: + bundle_expired_event () const + { + return this->_xsd_bundle_expired_event_; + } + + bpa::bundle_expired_event::container& bpa:: + bundle_expired_event () + { + return this->_xsd_bundle_expired_event_; + } + + void bpa:: + bundle_expired_event (const bundle_expired_event::type& bundle_expired_event) + { + this->_xsd_bundle_expired_event_.set (bundle_expired_event); + } + + void bpa:: + bundle_expired_event (const bundle_expired_event::container& bundle_expired_event) + { + this->_xsd_bundle_expired_event_ = bundle_expired_event; + } + + void bpa:: + bundle_expired_event (::std::auto_ptr< bundle_expired_event::type > bundle_expired_event) + { + this->_xsd_bundle_expired_event_.set (bundle_expired_event); + } + + const bpa::bundle_send_cancelled_event::container& bpa:: + bundle_send_cancelled_event () const + { + return this->_xsd_bundle_send_cancelled_event_; + } + + bpa::bundle_send_cancelled_event::container& bpa:: + bundle_send_cancelled_event () + { + return this->_xsd_bundle_send_cancelled_event_; + } + + void bpa:: + bundle_send_cancelled_event (const bundle_send_cancelled_event::type& bundle_send_cancelled_event) + { + this->_xsd_bundle_send_cancelled_event_.set (bundle_send_cancelled_event); + } + + void bpa:: + bundle_send_cancelled_event (const bundle_send_cancelled_event::container& bundle_send_cancelled_event) + { + this->_xsd_bundle_send_cancelled_event_ = bundle_send_cancelled_event; + } + + void bpa:: + bundle_send_cancelled_event (::std::auto_ptr< bundle_send_cancelled_event::type > bundle_send_cancelled_event) + { + this->_xsd_bundle_send_cancelled_event_.set (bundle_send_cancelled_event); + } + + const bpa::bundle_injected_event::container& bpa:: + bundle_injected_event () const + { + return this->_xsd_bundle_injected_event_; + } + + bpa::bundle_injected_event::container& bpa:: + bundle_injected_event () + { + return this->_xsd_bundle_injected_event_; + } + + void bpa:: + bundle_injected_event (const bundle_injected_event::type& bundle_injected_event) + { + this->_xsd_bundle_injected_event_.set (bundle_injected_event); + } + + void bpa:: + bundle_injected_event (const bundle_injected_event::container& bundle_injected_event) + { + this->_xsd_bundle_injected_event_ = bundle_injected_event; + } + + void bpa:: + bundle_injected_event (::std::auto_ptr< bundle_injected_event::type > bundle_injected_event) + { + this->_xsd_bundle_injected_event_.set (bundle_injected_event); + } + + const bpa::link_opened_event::container& bpa:: + link_opened_event () const + { + return this->_xsd_link_opened_event_; + } + + bpa::link_opened_event::container& bpa:: + link_opened_event () + { + return this->_xsd_link_opened_event_; + } + + void bpa:: + link_opened_event (const link_opened_event::type& link_opened_event) + { + this->_xsd_link_opened_event_.set (link_opened_event); + } + + void bpa:: + link_opened_event (const link_opened_event::container& link_opened_event) + { + this->_xsd_link_opened_event_ = link_opened_event; + } + + void bpa:: + link_opened_event (::std::auto_ptr< link_opened_event::type > link_opened_event) + { + this->_xsd_link_opened_event_.set (link_opened_event); + } + + const bpa::link_closed_event::container& bpa:: + link_closed_event () const + { + return this->_xsd_link_closed_event_; + } + + bpa::link_closed_event::container& bpa:: + link_closed_event () + { + return this->_xsd_link_closed_event_; + } + + void bpa:: + link_closed_event (const link_closed_event::type& link_closed_event) + { + this->_xsd_link_closed_event_.set (link_closed_event); + } + + void bpa:: + link_closed_event (const link_closed_event::container& link_closed_event) + { + this->_xsd_link_closed_event_ = link_closed_event; + } + + void bpa:: + link_closed_event (::std::auto_ptr< link_closed_event::type > link_closed_event) + { + this->_xsd_link_closed_event_.set (link_closed_event); + } + + const bpa::link_created_event::container& bpa:: + link_created_event () const + { + return this->_xsd_link_created_event_; + } + + bpa::link_created_event::container& bpa:: + link_created_event () + { + return this->_xsd_link_created_event_; + } + + void bpa:: + link_created_event (const link_created_event::type& link_created_event) + { + this->_xsd_link_created_event_.set (link_created_event); + } + + void bpa:: + link_created_event (const link_created_event::container& link_created_event) + { + this->_xsd_link_created_event_ = link_created_event; + } + + void bpa:: + link_created_event (::std::auto_ptr< link_created_event::type > link_created_event) + { + this->_xsd_link_created_event_.set (link_created_event); + } + + const bpa::link_deleted_event::container& bpa:: + link_deleted_event () const + { + return this->_xsd_link_deleted_event_; + } + + bpa::link_deleted_event::container& bpa:: + link_deleted_event () + { + return this->_xsd_link_deleted_event_; + } + + void bpa:: + link_deleted_event (const link_deleted_event::type& link_deleted_event) + { + this->_xsd_link_deleted_event_.set (link_deleted_event); + } + + void bpa:: + link_deleted_event (const link_deleted_event::container& link_deleted_event) + { + this->_xsd_link_deleted_event_ = link_deleted_event; + } + + void bpa:: + link_deleted_event (::std::auto_ptr< link_deleted_event::type > link_deleted_event) + { + this->_xsd_link_deleted_event_.set (link_deleted_event); + } + + const bpa::link_available_event::container& bpa:: + link_available_event () const + { + return this->_xsd_link_available_event_; + } + + bpa::link_available_event::container& bpa:: + link_available_event () + { + return this->_xsd_link_available_event_; + } + + void bpa:: + link_available_event (const link_available_event::type& link_available_event) + { + this->_xsd_link_available_event_.set (link_available_event); + } + + void bpa:: + link_available_event (const link_available_event::container& link_available_event) + { + this->_xsd_link_available_event_ = link_available_event; + } + + void bpa:: + link_available_event (::std::auto_ptr< link_available_event::type > link_available_event) + { + this->_xsd_link_available_event_.set (link_available_event); + } + + const bpa::link_unavailable_event::container& bpa:: + link_unavailable_event () const + { + return this->_xsd_link_unavailable_event_; + } + + bpa::link_unavailable_event::container& bpa:: + link_unavailable_event () + { + return this->_xsd_link_unavailable_event_; + } + + void bpa:: + link_unavailable_event (const link_unavailable_event::type& link_unavailable_event) + { + this->_xsd_link_unavailable_event_.set (link_unavailable_event); + } + + void bpa:: + link_unavailable_event (const link_unavailable_event::container& link_unavailable_event) + { + this->_xsd_link_unavailable_event_ = link_unavailable_event; + } + + void bpa:: + link_unavailable_event (::std::auto_ptr< link_unavailable_event::type > link_unavailable_event) + { + this->_xsd_link_unavailable_event_.set (link_unavailable_event); + } + + const bpa::link_attribute_changed_event::container& bpa:: + link_attribute_changed_event () const + { + return this->_xsd_link_attribute_changed_event_; + } + + bpa::link_attribute_changed_event::container& bpa:: + link_attribute_changed_event () + { + return this->_xsd_link_attribute_changed_event_; + } + + void bpa:: + 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 bpa:: + 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 bpa:: + 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 bpa::contact_attribute_changed_event::container& bpa:: + contact_attribute_changed_event () const + { + return this->_xsd_contact_attribute_changed_event_; + } + + bpa::contact_attribute_changed_event::container& bpa:: + contact_attribute_changed_event () + { + return this->_xsd_contact_attribute_changed_event_; + } + + void bpa:: + 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 bpa:: + 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 bpa:: + 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 bpa::link_busy_event::container& bpa:: + link_busy_event () const + { + return this->_xsd_link_busy_event_; + } + + bpa::link_busy_event::container& bpa:: + link_busy_event () + { + return this->_xsd_link_busy_event_; + } + + void bpa:: + link_busy_event (const link_busy_event::type& link_busy_event) + { + this->_xsd_link_busy_event_.set (link_busy_event); + } + + void bpa:: + link_busy_event (const link_busy_event::container& link_busy_event) + { + this->_xsd_link_busy_event_ = link_busy_event; + } + + void bpa:: + link_busy_event (::std::auto_ptr< link_busy_event::type > link_busy_event) + { + this->_xsd_link_busy_event_.set (link_busy_event); + } + + const bpa::eid_reachable_event::container& bpa:: + eid_reachable_event () const + { + return this->_xsd_eid_reachable_event_; + } + + bpa::eid_reachable_event::container& bpa:: + eid_reachable_event () + { + return this->_xsd_eid_reachable_event_; + } + + void bpa:: + eid_reachable_event (const eid_reachable_event::type& eid_reachable_event) + { + this->_xsd_eid_reachable_event_.set (eid_reachable_event); + } + + void bpa:: + eid_reachable_event (const eid_reachable_event::container& eid_reachable_event) + { + this->_xsd_eid_reachable_event_ = eid_reachable_event; + } + + void bpa:: + eid_reachable_event (::std::auto_ptr< eid_reachable_event::type > eid_reachable_event) + { + this->_xsd_eid_reachable_event_.set (eid_reachable_event); + } + + const bpa::route_add_event::container& bpa:: + route_add_event () const + { + return this->_xsd_route_add_event_; + } + + bpa::route_add_event::container& bpa:: + route_add_event () + { + return this->_xsd_route_add_event_; + } + + void bpa:: + route_add_event (const route_add_event::type& route_add_event) + { + this->_xsd_route_add_event_.set (route_add_event); + } + + void bpa:: + route_add_event (const route_add_event::container& route_add_event) + { + this->_xsd_route_add_event_ = route_add_event; + } + + void bpa:: + route_add_event (::std::auto_ptr< route_add_event::type > route_add_event) + { + this->_xsd_route_add_event_.set (route_add_event); + } + + const bpa::route_delete_event::container& bpa:: + route_delete_event () const + { + return this->_xsd_route_delete_event_; + } + + bpa::route_delete_event::container& bpa:: + route_delete_event () + { + return this->_xsd_route_delete_event_; + } + + void bpa:: + route_delete_event (const route_delete_event::type& route_delete_event) + { + this->_xsd_route_delete_event_.set (route_delete_event); + } + + void bpa:: + route_delete_event (const route_delete_event::container& route_delete_event) + { + this->_xsd_route_delete_event_ = route_delete_event; + } + + void bpa:: + route_delete_event (::std::auto_ptr< route_delete_event::type > route_delete_event) + { + this->_xsd_route_delete_event_.set (route_delete_event); + } + + const bpa::custody_signal_event::container& bpa:: + custody_signal_event () const + { + return this->_xsd_custody_signal_event_; + } + + bpa::custody_signal_event::container& bpa:: + custody_signal_event () + { + return this->_xsd_custody_signal_event_; + } + + void bpa:: + custody_signal_event (const custody_signal_event::type& custody_signal_event) + { + this->_xsd_custody_signal_event_.set (custody_signal_event); + } + + void bpa:: + custody_signal_event (const custody_signal_event::container& custody_signal_event) + { + this->_xsd_custody_signal_event_ = custody_signal_event; + } + + void bpa:: + custody_signal_event (::std::auto_ptr< custody_signal_event::type > custody_signal_event) + { + this->_xsd_custody_signal_event_.set (custody_signal_event); + } + + const bpa::custody_timeout_event::container& bpa:: + custody_timeout_event () const + { + return this->_xsd_custody_timeout_event_; + } + + bpa::custody_timeout_event::container& bpa:: + custody_timeout_event () + { + return this->_xsd_custody_timeout_event_; + } + + void bpa:: + custody_timeout_event (const custody_timeout_event::type& custody_timeout_event) + { + this->_xsd_custody_timeout_event_.set (custody_timeout_event); + } + + void bpa:: + custody_timeout_event (const custody_timeout_event::container& custody_timeout_event) + { + this->_xsd_custody_timeout_event_ = custody_timeout_event; + } + + void bpa:: + custody_timeout_event (::std::auto_ptr< custody_timeout_event::type > custody_timeout_event) + { + this->_xsd_custody_timeout_event_.set (custody_timeout_event); + } + + const bpa::intentional_name_resolved_event::container& bpa:: + intentional_name_resolved_event () const + { + return this->_xsd_intentional_name_resolved_event_; + } + + bpa::intentional_name_resolved_event::container& bpa:: + intentional_name_resolved_event () + { + return this->_xsd_intentional_name_resolved_event_; + } + + void bpa:: + intentional_name_resolved_event (const intentional_name_resolved_event::type& intentional_name_resolved_event) + { + this->_xsd_intentional_name_resolved_event_.set (intentional_name_resolved_event); + } + + void bpa:: + intentional_name_resolved_event (const intentional_name_resolved_event::container& intentional_name_resolved_event) + { + this->_xsd_intentional_name_resolved_event_ = intentional_name_resolved_event; + } + + void bpa:: + intentional_name_resolved_event (::std::auto_ptr< intentional_name_resolved_event::type > intentional_name_resolved_event) + { + this->_xsd_intentional_name_resolved_event_.set (intentional_name_resolved_event); + } + + const bpa::registration_added_event::container& bpa:: + registration_added_event () const + { + return this->_xsd_registration_added_event_; + } + + bpa::registration_added_event::container& bpa:: + registration_added_event () + { + return this->_xsd_registration_added_event_; + } + + void bpa:: + registration_added_event (const registration_added_event::type& registration_added_event) + { + this->_xsd_registration_added_event_.set (registration_added_event); + } + + void bpa:: + registration_added_event (const registration_added_event::container& registration_added_event) + { + this->_xsd_registration_added_event_ = registration_added_event; + } + + void bpa:: + registration_added_event (::std::auto_ptr< registration_added_event::type > registration_added_event) + { + this->_xsd_registration_added_event_.set (registration_added_event); + } + + const bpa::registration_removed_event::container& bpa:: + registration_removed_event () const + { + return this->_xsd_registration_removed_event_; + } + + bpa::registration_removed_event::container& bpa:: + registration_removed_event () + { + return this->_xsd_registration_removed_event_; + } + + void bpa:: + registration_removed_event (const registration_removed_event::type& registration_removed_event) + { + this->_xsd_registration_removed_event_.set (registration_removed_event); + } + + void bpa:: + registration_removed_event (const registration_removed_event::container& registration_removed_event) + { + this->_xsd_registration_removed_event_ = registration_removed_event; + } + + void bpa:: + registration_removed_event (::std::auto_ptr< registration_removed_event::type > registration_removed_event) + { + this->_xsd_registration_removed_event_.set (registration_removed_event); + } + + const bpa::registration_expired_event::container& bpa:: + registration_expired_event () const + { + return this->_xsd_registration_expired_event_; + } + + bpa::registration_expired_event::container& bpa:: + registration_expired_event () + { + return this->_xsd_registration_expired_event_; + } + + void bpa:: + registration_expired_event (const registration_expired_event::type& registration_expired_event) + { + this->_xsd_registration_expired_event_.set (registration_expired_event); + } + + void bpa:: + registration_expired_event (const registration_expired_event::container& registration_expired_event) + { + this->_xsd_registration_expired_event_ = registration_expired_event; + } + + void bpa:: + registration_expired_event (::std::auto_ptr< registration_expired_event::type > registration_expired_event) + { + this->_xsd_registration_expired_event_.set (registration_expired_event); + } + + const bpa::open_link_request::container& bpa:: + open_link_request () const + { + return this->_xsd_open_link_request_; + } + + bpa::open_link_request::container& bpa:: + open_link_request () + { + return this->_xsd_open_link_request_; + } + + void bpa:: + open_link_request (const open_link_request::type& open_link_request) + { + this->_xsd_open_link_request_.set (open_link_request); + } + + void bpa:: + open_link_request (const open_link_request::container& open_link_request) + { + this->_xsd_open_link_request_ = open_link_request; + } + + void bpa:: + open_link_request (::std::auto_ptr< open_link_request::type > open_link_request) + { + this->_xsd_open_link_request_.set (open_link_request); + } + + const bpa::close_link_request::container& bpa:: + close_link_request () const + { + return this->_xsd_close_link_request_; + } + + bpa::close_link_request::container& bpa:: + close_link_request () + { + return this->_xsd_close_link_request_; + } + + void bpa:: + close_link_request (const close_link_request::type& close_link_request) + { + this->_xsd_close_link_request_.set (close_link_request); + } + + void bpa:: + close_link_request (const close_link_request::container& close_link_request) + { + this->_xsd_close_link_request_ = close_link_request; + } + + void bpa:: + close_link_request (::std::auto_ptr< close_link_request::type > close_link_request) + { + this->_xsd_close_link_request_.set (close_link_request); + } + + const bpa::add_link_request::container& bpa:: + add_link_request () const + { + return this->_xsd_add_link_request_; + } + + bpa::add_link_request::container& bpa:: + add_link_request () + { + return this->_xsd_add_link_request_; + } + + void bpa:: + add_link_request (const add_link_request::type& add_link_request) + { + this->_xsd_add_link_request_.set (add_link_request); + } + + void bpa:: + add_link_request (const add_link_request::container& add_link_request) + { + this->_xsd_add_link_request_ = add_link_request; + } + + void bpa:: + add_link_request (::std::auto_ptr< add_link_request::type > add_link_request) + { + this->_xsd_add_link_request_.set (add_link_request); + } + + const bpa::delete_link_request::container& bpa:: + delete_link_request () const + { + return this->_xsd_delete_link_request_; + } + + bpa::delete_link_request::container& bpa:: + delete_link_request () + { + return this->_xsd_delete_link_request_; + } + + void bpa:: + delete_link_request (const delete_link_request::type& delete_link_request) + { + this->_xsd_delete_link_request_.set (delete_link_request); + } + + void bpa:: + delete_link_request (const delete_link_request::container& delete_link_request) + { + this->_xsd_delete_link_request_ = delete_link_request; + } + + void bpa:: + delete_link_request (::std::auto_ptr< delete_link_request::type > delete_link_request) + { + this->_xsd_delete_link_request_.set (delete_link_request); + } + + const bpa::reconfigure_link_request::container& bpa:: + reconfigure_link_request () const + { + return this->_xsd_reconfigure_link_request_; + } + + bpa::reconfigure_link_request::container& bpa:: + reconfigure_link_request () + { + return this->_xsd_reconfigure_link_request_; + } + + void bpa:: + reconfigure_link_request (const reconfigure_link_request::type& reconfigure_link_request) + { + this->_xsd_reconfigure_link_request_.set (reconfigure_link_request); + } + + void bpa:: + reconfigure_link_request (const reconfigure_link_request::container& reconfigure_link_request) + { + this->_xsd_reconfigure_link_request_ = reconfigure_link_request; + } + + void bpa:: + reconfigure_link_request (::std::auto_ptr< reconfigure_link_request::type > reconfigure_link_request) + { + this->_xsd_reconfigure_link_request_.set (reconfigure_link_request); + } + + const bpa::send_bundle_request::container& bpa:: + send_bundle_request () const + { + return this->_xsd_send_bundle_request_; + } + + bpa::send_bundle_request::container& bpa:: + send_bundle_request () + { + return this->_xsd_send_bundle_request_; + } + + void bpa:: + send_bundle_request (const send_bundle_request::type& send_bundle_request) + { + this->_xsd_send_bundle_request_.set (send_bundle_request); + } + + void bpa:: + send_bundle_request (const send_bundle_request::container& send_bundle_request) + { + this->_xsd_send_bundle_request_ = send_bundle_request; + } + + void bpa:: + send_bundle_request (::std::auto_ptr< send_bundle_request::type > send_bundle_request) + { + this->_xsd_send_bundle_request_.set (send_bundle_request); + } + + const bpa::send_bundle_broadcast_request::container& bpa:: + send_bundle_broadcast_request () const + { + return this->_xsd_send_bundle_broadcast_request_; + } + + bpa::send_bundle_broadcast_request::container& bpa:: + send_bundle_broadcast_request () + { + return this->_xsd_send_bundle_broadcast_request_; + } + + void bpa:: + send_bundle_broadcast_request (const send_bundle_broadcast_request::type& send_bundle_broadcast_request) + { + this->_xsd_send_bundle_broadcast_request_.set (send_bundle_broadcast_request); + } + + void bpa:: + send_bundle_broadcast_request (const send_bundle_broadcast_request::container& send_bundle_broadcast_request) + { + this->_xsd_send_bundle_broadcast_request_ = send_bundle_broadcast_request; + } + + void bpa:: + send_bundle_broadcast_request (::std::auto_ptr< send_bundle_broadcast_request::type > send_bundle_broadcast_request) + { + this->_xsd_send_bundle_broadcast_request_.set (send_bundle_broadcast_request); + } + + const bpa::cancel_bundle_request::container& bpa:: + cancel_bundle_request () const + { + return this->_xsd_cancel_bundle_request_; + } + + bpa::cancel_bundle_request::container& bpa:: + cancel_bundle_request () + { + return this->_xsd_cancel_bundle_request_; + } + + void bpa:: + cancel_bundle_request (const cancel_bundle_request::type& cancel_bundle_request) + { + this->_xsd_cancel_bundle_request_.set (cancel_bundle_request); + } + + void bpa:: + cancel_bundle_request (const cancel_bundle_request::container& cancel_bundle_request) + { + this->_xsd_cancel_bundle_request_ = cancel_bundle_request; + } + + void bpa:: + cancel_bundle_request (::std::auto_ptr< cancel_bundle_request::type > cancel_bundle_request) + { + this->_xsd_cancel_bundle_request_.set (cancel_bundle_request); + } + + const bpa::inject_bundle_request::container& bpa:: + inject_bundle_request () const + { + return this->_xsd_inject_bundle_request_; + } + + bpa::inject_bundle_request::container& bpa:: + inject_bundle_request () + { + return this->_xsd_inject_bundle_request_; + } + + void bpa:: + inject_bundle_request (const inject_bundle_request::type& inject_bundle_request) + { + this->_xsd_inject_bundle_request_.set (inject_bundle_request); + } + + void bpa:: + inject_bundle_request (const inject_bundle_request::container& inject_bundle_request) + { + this->_xsd_inject_bundle_request_ = inject_bundle_request; + } + + void bpa:: + inject_bundle_request (::std::auto_ptr< inject_bundle_request::type > inject_bundle_request) + { + this->_xsd_inject_bundle_request_.set (inject_bundle_request); + } + + const bpa::delete_bundle_request::container& bpa:: + delete_bundle_request () const + { + return this->_xsd_delete_bundle_request_; + } + + bpa::delete_bundle_request::container& bpa:: + delete_bundle_request () + { + return this->_xsd_delete_bundle_request_; + } + + void bpa:: + delete_bundle_request (const delete_bundle_request::type& delete_bundle_request) + { + this->_xsd_delete_bundle_request_.set (delete_bundle_request); + } + + void bpa:: + delete_bundle_request (const delete_bundle_request::container& delete_bundle_request) + { + this->_xsd_delete_bundle_request_ = delete_bundle_request; + } + + void bpa:: + delete_bundle_request (::std::auto_ptr< delete_bundle_request::type > delete_bundle_request) + { + this->_xsd_delete_bundle_request_.set (delete_bundle_request); + } + + const bpa::set_cl_params_request::container& bpa:: + set_cl_params_request () const + { + return this->_xsd_set_cl_params_request_; + } + + bpa::set_cl_params_request::container& bpa:: + set_cl_params_request () + { + return this->_xsd_set_cl_params_request_; + } + + void bpa:: + set_cl_params_request (const set_cl_params_request::type& set_cl_params_request) + { + this->_xsd_set_cl_params_request_.set (set_cl_params_request); + } + + void bpa:: + set_cl_params_request (const set_cl_params_request::container& set_cl_params_request) + { + this->_xsd_set_cl_params_request_ = set_cl_params_request; + } + + void bpa:: + set_cl_params_request (::std::auto_ptr< set_cl_params_request::type > set_cl_params_request) + { + this->_xsd_set_cl_params_request_.set (set_cl_params_request); + } + + const bpa::intentional_name_resolution_request::container& bpa:: + intentional_name_resolution_request () const + { + return this->_xsd_intentional_name_resolution_request_; + } + + bpa::intentional_name_resolution_request::container& bpa:: + intentional_name_resolution_request () + { + return this->_xsd_intentional_name_resolution_request_; + } + + void bpa:: + intentional_name_resolution_request (const intentional_name_resolution_request::type& intentional_name_resolution_request) + { + this->_xsd_intentional_name_resolution_request_.set (intentional_name_resolution_request); + } + + void bpa:: + intentional_name_resolution_request (const intentional_name_resolution_request::container& intentional_name_resolution_request) + { + this->_xsd_intentional_name_resolution_request_ = intentional_name_resolution_request; + } + + void bpa:: + intentional_name_resolution_request (::std::auto_ptr< intentional_name_resolution_request::type > intentional_name_resolution_request) + { + this->_xsd_intentional_name_resolution_request_.set (intentional_name_resolution_request); + } + + const bpa::deliver_bundle_to_app_request::container& bpa:: + deliver_bundle_to_app_request () const + { + return this->_xsd_deliver_bundle_to_app_request_; + } + + bpa::deliver_bundle_to_app_request::container& bpa:: + deliver_bundle_to_app_request () + { + return this->_xsd_deliver_bundle_to_app_request_; + } + + void bpa:: + deliver_bundle_to_app_request (const deliver_bundle_to_app_request::type& deliver_bundle_to_app_request) + { + this->_xsd_deliver_bundle_to_app_request_.set (deliver_bundle_to_app_request); + } + + void bpa:: + deliver_bundle_to_app_request (const deliver_bundle_to_app_request::container& deliver_bundle_to_app_request) + { + this->_xsd_deliver_bundle_to_app_request_ = deliver_bundle_to_app_request; + } + + void bpa:: + deliver_bundle_to_app_request (::std::auto_ptr< deliver_bundle_to_app_request::type > deliver_bundle_to_app_request) + { + this->_xsd_deliver_bundle_to_app_request_.set (deliver_bundle_to_app_request); + } + + const bpa::link_query::container& bpa:: + link_query () const + { + return this->_xsd_link_query_; + } + + bpa::link_query::container& bpa:: + link_query () + { + return this->_xsd_link_query_; + } + + void bpa:: + link_query (const link_query::type& link_query) + { + this->_xsd_link_query_.set (link_query); + } + + void bpa:: + link_query (const link_query::container& link_query) + { + this->_xsd_link_query_ = link_query; + } + + void bpa:: + link_query (::std::auto_ptr< link_query::type > link_query) + { + this->_xsd_link_query_.set (link_query); + } + + const bpa::link_report::container& bpa:: + link_report () const + { + return this->_xsd_link_report_; + } + + bpa::link_report::container& bpa:: + link_report () + { + return this->_xsd_link_report_; + } + + void bpa:: + link_report (const link_report::type& link_report) + { + this->_xsd_link_report_.set (link_report); + } + + void bpa:: + link_report (const link_report::container& link_report) + { + this->_xsd_link_report_ = link_report; + } + + void bpa:: + link_report (::std::auto_ptr< link_report::type > link_report) + { + this->_xsd_link_report_.set (link_report); + } + + const bpa::link_attributes_query::container& bpa:: + link_attributes_query () const + { + return this->_xsd_link_attributes_query_; + } + + bpa::link_attributes_query::container& bpa:: + link_attributes_query () + { + return this->_xsd_link_attributes_query_; + } + + void bpa:: + link_attributes_query (const link_attributes_query::type& link_attributes_query) + { + this->_xsd_link_attributes_query_.set (link_attributes_query); + } + + void bpa:: + link_attributes_query (const link_attributes_query::container& link_attributes_query) + { + this->_xsd_link_attributes_query_ = link_attributes_query; + } + + void bpa:: + link_attributes_query (::std::auto_ptr< link_attributes_query::type > link_attributes_query) + { + this->_xsd_link_attributes_query_.set (link_attributes_query); + } + + const bpa::link_attributes_report::container& bpa:: + link_attributes_report () const + { + return this->_xsd_link_attributes_report_; + } + + bpa::link_attributes_report::container& bpa:: + link_attributes_report () + { + return this->_xsd_link_attributes_report_; + } + + void bpa:: + link_attributes_report (const link_attributes_report::type& link_attributes_report) + { + this->_xsd_link_attributes_report_.set (link_attributes_report); + } + + void bpa:: + link_attributes_report (const link_attributes_report::container& link_attributes_report) + { + this->_xsd_link_attributes_report_ = link_attributes_report; + } + + void bpa:: + link_attributes_report (::std::auto_ptr< link_attributes_report::type > link_attributes_report) + { + this->_xsd_link_attributes_report_.set (link_attributes_report); + } + + const bpa::contact_query::container& bpa:: + contact_query () const + { + return this->_xsd_contact_query_; + } + + bpa::contact_query::container& bpa:: + contact_query () + { + return this->_xsd_contact_query_; + } + + void bpa:: + contact_query (const contact_query::type& contact_query) + { + this->_xsd_contact_query_.set (contact_query); + } + + void bpa:: + contact_query (const contact_query::container& contact_query) + { + this->_xsd_contact_query_ = contact_query; + } + + void bpa:: + contact_query (::std::auto_ptr< contact_query::type > contact_query) + { + this->_xsd_contact_query_.set (contact_query); + } + + const bpa::contact_report::container& bpa:: + contact_report () const + { + return this->_xsd_contact_report_; + } + + bpa::contact_report::container& bpa:: + contact_report () + { + return this->_xsd_contact_report_; + } + + void bpa:: + contact_report (const contact_report::type& contact_report) + { + this->_xsd_contact_report_.set (contact_report); + } + + void bpa:: + contact_report (const contact_report::container& contact_report) + { + this->_xsd_contact_report_ = contact_report; + } + + void bpa:: + contact_report (::std::auto_ptr< contact_report::type > contact_report) + { + this->_xsd_contact_report_.set (contact_report); + } + + const bpa::route_query::container& bpa:: + route_query () const + { + return this->_xsd_route_query_; + } + + bpa::route_query::container& bpa:: + route_query () + { + return this->_xsd_route_query_; + } + + void bpa:: + route_query (const route_query::type& route_query) + { + this->_xsd_route_query_.set (route_query); + } + + void bpa:: + route_query (const route_query::container& route_query) + { + this->_xsd_route_query_ = route_query; + } + + void bpa:: + route_query (::std::auto_ptr< route_query::type > route_query) + { + this->_xsd_route_query_.set (route_query); + } + + const bpa::route_report::container& bpa:: + route_report () const + { + return this->_xsd_route_report_; + } + + bpa::route_report::container& bpa:: + route_report () + { + return this->_xsd_route_report_; + } + + void bpa:: + route_report (const route_report::type& route_report) + { + this->_xsd_route_report_.set (route_report); + } + + void bpa:: + route_report (const route_report::container& route_report) + { + this->_xsd_route_report_ = route_report; + } + + void bpa:: + route_report (::std::auto_ptr< route_report::type > route_report) + { + this->_xsd_route_report_.set (route_report); + } + + const bpa::bundle_query::container& bpa:: + bundle_query () const + { + return this->_xsd_bundle_query_; + } + + bpa::bundle_query::container& bpa:: + bundle_query () + { + return this->_xsd_bundle_query_; + } + + void bpa:: + bundle_query (const bundle_query::type& bundle_query) + { + this->_xsd_bundle_query_.set (bundle_query); + } + + void bpa:: + bundle_query (const bundle_query::container& bundle_query) + { + this->_xsd_bundle_query_ = bundle_query; + } + + void bpa:: + bundle_query (::std::auto_ptr< bundle_query::type > bundle_query) + { + this->_xsd_bundle_query_.set (bundle_query); + } + + const bpa::bundle_report::container& bpa:: + bundle_report () const + { + return this->_xsd_bundle_report_; + } + + bpa::bundle_report::container& bpa:: + bundle_report () + { + return this->_xsd_bundle_report_; + } + + void bpa:: + bundle_report (const bundle_report::type& bundle_report) + { + this->_xsd_bundle_report_.set (bundle_report); + } + + void bpa:: + bundle_report (const bundle_report::container& bundle_report) + { + this->_xsd_bundle_report_ = bundle_report; + } + + void bpa:: + bundle_report (::std::auto_ptr< bundle_report::type > bundle_report) + { + this->_xsd_bundle_report_.set (bundle_report); + } + + const bpa::bundle_attributes_query::container& bpa:: + bundle_attributes_query () const + { + return this->_xsd_bundle_attributes_query_; + } + + bpa::bundle_attributes_query::container& bpa:: + bundle_attributes_query () + { + return this->_xsd_bundle_attributes_query_; + } + + void bpa:: + bundle_attributes_query (const bundle_attributes_query::type& bundle_attributes_query) + { + this->_xsd_bundle_attributes_query_.set (bundle_attributes_query); + } + + void bpa:: + bundle_attributes_query (const bundle_attributes_query::container& bundle_attributes_query) + { + this->_xsd_bundle_attributes_query_ = bundle_attributes_query; + } + + void bpa:: + bundle_attributes_query (::std::auto_ptr< bundle_attributes_query::type > bundle_attributes_query) + { + this->_xsd_bundle_attributes_query_.set (bundle_attributes_query); + } + + const bpa::bundle_attributes_report::container& bpa:: + bundle_attributes_report () const + { + return this->_xsd_bundle_attributes_report_; + } + + bpa::bundle_attributes_report::container& bpa:: + bundle_attributes_report () + { + return this->_xsd_bundle_attributes_report_; + } + + void bpa:: + bundle_attributes_report (const bundle_attributes_report::type& bundle_attributes_report) + { + this->_xsd_bundle_attributes_report_.set (bundle_attributes_report); + } + + void bpa:: + bundle_attributes_report (const bundle_attributes_report::container& bundle_attributes_report) + { + this->_xsd_bundle_attributes_report_ = bundle_attributes_report; + } + + void bpa:: + bundle_attributes_report (::std::auto_ptr< bundle_attributes_report::type > bundle_attributes_report) + { + this->_xsd_bundle_attributes_report_.set (bundle_attributes_report); + } + + const bpa::eid::container& bpa:: + eid () const + { + return this->_xsd_eid_; + } + + bpa::eid::container& bpa:: + eid () + { + return this->_xsd_eid_; + } + + void bpa:: + eid (const eid::type& eid) + { + this->_xsd_eid_.set (eid); + } + + void bpa:: + eid (const eid::container& eid) + { + this->_xsd_eid_ = eid; + } + + void bpa:: + eid (::std::auto_ptr< eid::type > eid) + { + this->_xsd_eid_.set (eid); + } + + const bpa::hello_interval::container& bpa:: + hello_interval () const + { + return this->_xsd_hello_interval_; + } + + bpa::hello_interval::container& bpa:: + hello_interval () + { + return this->_xsd_hello_interval_; + } + + void bpa:: + hello_interval (const hello_interval::type& hello_interval) + { + this->_xsd_hello_interval_.set (hello_interval); + } + + void bpa:: + hello_interval (const hello_interval::container& hello_interval) + { + this->_xsd_hello_interval_ = hello_interval; + } + + const bpa::alert::container& bpa:: + alert () const + { + return this->_xsd_alert_; + } + + bpa::alert::container& bpa:: + alert () + { + return this->_xsd_alert_; + } + + void bpa:: + alert (const alert::type& alert) + { + this->_xsd_alert_.set (alert); + } + + void bpa:: + alert (const alert::container& alert) + { + this->_xsd_alert_ = alert; + } + + void bpa:: + alert (::std::auto_ptr< alert::type > alert) + { + this->_xsd_alert_.set (alert); + } + } +} + +#include +#include + +namespace dtn +{ + namespace rtrmessage + { + // dtnStatusType + // + + dtnStatusType:: + dtnStatusType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_dtnStatusType_convert (); + } + + dtnStatusType:: + dtnStatusType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_dtnStatusType_convert (); + } + + dtnStatusType:: + dtnStatusType (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_dtnStatusType_convert (); + } + + dtnStatusType* dtnStatusType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new dtnStatusType (*this, f, c); + } + + dtnStatusType::_xsd_dtnStatusType dtnStatusType:: + _xsd_dtnStatusType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_dtnStatusType_literals_); + const _xsd_dtnStatusType* i (::std::lower_bound ( + _xsd_dtnStatusType_indexes_, + _xsd_dtnStatusType_indexes_ + 2, + *this, + c)); + + if (i == _xsd_dtnStatusType_indexes_ + 2 || _xsd_dtnStatusType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const dtnStatusType:: + _xsd_dtnStatusType_literals_[2] = + { + "justBooted", + "shuttingDown" + }; + + const dtnStatusType::_xsd_dtnStatusType dtnStatusType:: + _xsd_dtnStatusType_indexes_[2] = + { + ::dtn::rtrmessage::dtnStatusType::justBooted, + ::dtn::rtrmessage::dtnStatusType::shuttingDown + }; + + // bundlePriorityType + // + + bundlePriorityType:: + bundlePriorityType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_bundlePriorityType_convert (); + } + + bundlePriorityType:: + bundlePriorityType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_bundlePriorityType_convert (); + } + + bundlePriorityType:: + bundlePriorityType (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_bundlePriorityType_convert (); + } + + bundlePriorityType* bundlePriorityType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundlePriorityType (*this, f, c); + } + + bundlePriorityType::_xsd_bundlePriorityType bundlePriorityType:: + _xsd_bundlePriorityType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundlePriorityType_literals_); + const _xsd_bundlePriorityType* i (::std::lower_bound ( + _xsd_bundlePriorityType_indexes_, + _xsd_bundlePriorityType_indexes_ + 4, + *this, + c)); + + if (i == _xsd_bundlePriorityType_indexes_ + 4 || _xsd_bundlePriorityType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const bundlePriorityType:: + _xsd_bundlePriorityType_literals_[4] = + { + "bulk", + "normal", + "expedited", + "_unknown_priority_" + }; + + const bundlePriorityType::_xsd_bundlePriorityType bundlePriorityType:: + _xsd_bundlePriorityType_indexes_[4] = + { + ::dtn::rtrmessage::bundlePriorityType::_unknown_priority_, + ::dtn::rtrmessage::bundlePriorityType::bulk, + ::dtn::rtrmessage::bundlePriorityType::expedited, + ::dtn::rtrmessage::bundlePriorityType::normal + }; + + // eventSourceType + // + + eventSourceType:: + eventSourceType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_eventSourceType_convert (); + } + + eventSourceType:: + eventSourceType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_eventSourceType_convert (); + } + + eventSourceType:: + eventSourceType (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_eventSourceType_convert (); + } + + eventSourceType* eventSourceType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new eventSourceType (*this, f, c); + } + + eventSourceType::_xsd_eventSourceType eventSourceType:: + _xsd_eventSourceType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_eventSourceType_literals_); + const _xsd_eventSourceType* i (::std::lower_bound ( + _xsd_eventSourceType_indexes_, + _xsd_eventSourceType_indexes_ + 5, + *this, + c)); + + if (i == _xsd_eventSourceType_indexes_ + 5 || _xsd_eventSourceType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const eventSourceType:: + _xsd_eventSourceType_literals_[5] = + { + "peer", + "application", + "dataStore", + "admin", + "fragmentation" + }; + + const eventSourceType::_xsd_eventSourceType eventSourceType:: + _xsd_eventSourceType_indexes_[5] = + { + ::dtn::rtrmessage::eventSourceType::admin, + ::dtn::rtrmessage::eventSourceType::application, + ::dtn::rtrmessage::eventSourceType::dataStore, + ::dtn::rtrmessage::eventSourceType::fragmentation, + ::dtn::rtrmessage::eventSourceType::peer + }; + + // bundleForwardActionType + // + + bundleForwardActionType:: + bundleForwardActionType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_bundleForwardActionType_convert (); + } + + bundleForwardActionType:: + bundleForwardActionType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_bundleForwardActionType_convert (); + } + + bundleForwardActionType:: + bundleForwardActionType (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_bundleForwardActionType_convert (); + } + + bundleForwardActionType* bundleForwardActionType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleForwardActionType (*this, f, c); + } + + bundleForwardActionType::_xsd_bundleForwardActionType bundleForwardActionType:: + _xsd_bundleForwardActionType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundleForwardActionType_literals_); + const _xsd_bundleForwardActionType* i (::std::lower_bound ( + _xsd_bundleForwardActionType_indexes_, + _xsd_bundleForwardActionType_indexes_ + 2, + *this, + c)); + + if (i == _xsd_bundleForwardActionType_indexes_ + 2 || _xsd_bundleForwardActionType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const bundleForwardActionType:: + _xsd_bundleForwardActionType_literals_[2] = + { + "forward", + "copy" + }; + + const bundleForwardActionType::_xsd_bundleForwardActionType bundleForwardActionType:: + _xsd_bundleForwardActionType_indexes_[2] = + { + ::dtn::rtrmessage::bundleForwardActionType::copy, + ::dtn::rtrmessage::bundleForwardActionType::forward + }; + + // contactReasonType + // + + contactReasonType:: + contactReasonType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_contactReasonType_convert (); + } + + contactReasonType:: + contactReasonType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_contactReasonType_convert (); + } + + contactReasonType:: + contactReasonType (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_contactReasonType_convert (); + } + + contactReasonType* contactReasonType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new contactReasonType (*this, f, c); + } + + contactReasonType::_xsd_contactReasonType contactReasonType:: + _xsd_contactReasonType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_contactReasonType_literals_); + const _xsd_contactReasonType* i (::std::lower_bound ( + _xsd_contactReasonType_indexes_, + _xsd_contactReasonType_indexes_ + 11, + *this, + c)); + + if (i == _xsd_contactReasonType_indexes_ + 11 || _xsd_contactReasonType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const contactReasonType:: + _xsd_contactReasonType_literals_[11] = + { + "no_info", + "user", + "broken", + "cl_error", + "cl_version", + "shutdown", + "reconnect", + "idle", + "timeout", + "blocked", + "unblocked" + }; + + const contactReasonType::_xsd_contactReasonType contactReasonType:: + _xsd_contactReasonType_indexes_[11] = + { + ::dtn::rtrmessage::contactReasonType::blocked, + ::dtn::rtrmessage::contactReasonType::broken, + ::dtn::rtrmessage::contactReasonType::cl_error, + ::dtn::rtrmessage::contactReasonType::cl_version, + ::dtn::rtrmessage::contactReasonType::idle, + ::dtn::rtrmessage::contactReasonType::no_info, + ::dtn::rtrmessage::contactReasonType::reconnect, + ::dtn::rtrmessage::contactReasonType::shutdown, + ::dtn::rtrmessage::contactReasonType::timeout, + ::dtn::rtrmessage::contactReasonType::unblocked, + ::dtn::rtrmessage::contactReasonType::user + }; + + // 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_ + 4, + *this, + c)); + + if (i == _xsd_linkTypeType_indexes_ + 4 || _xsd_linkTypeType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const linkTypeType:: + _xsd_linkTypeType_literals_[4] = + { + "alwayson", + "ondemand", + "scheduled", + "opportunistic" + }; + + const linkTypeType::_xsd_linkTypeType linkTypeType:: + _xsd_linkTypeType_indexes_[4] = + { + ::dtn::rtrmessage::linkTypeType::alwayson, + ::dtn::rtrmessage::linkTypeType::ondemand, + ::dtn::rtrmessage::linkTypeType::opportunistic, + ::dtn::rtrmessage::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_ + 5, + *this, + c)); + + if (i == _xsd_linkStateType_indexes_ + 5 || _xsd_linkStateType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const linkStateType:: + _xsd_linkStateType_literals_[5] = + { + "unavailable", + "available", + "opening", + "open", + "busy" + }; + + const linkStateType::_xsd_linkStateType linkStateType:: + _xsd_linkStateType_indexes_[5] = + { + ::dtn::rtrmessage::linkStateType::available, + ::dtn::rtrmessage::linkStateType::busy, + ::dtn::rtrmessage::linkStateType::open, + ::dtn::rtrmessage::linkStateType::opening, + ::dtn::rtrmessage::linkStateType::unavailable + }; + + // eidTypeType + // + + eidTypeType:: + eidTypeType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + } + + eidTypeType:: + eidTypeType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + } + + eidTypeType:: + eidTypeType (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) + { + } + + eidTypeType* eidTypeType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new eidTypeType (*this, f, c); + } + + // 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); + } + + // failureActionType + // + + failureActionType:: + failureActionType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_failureActionType_convert (); + } + + failureActionType:: + failureActionType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_failureActionType_convert (); + } + + failureActionType:: + failureActionType (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_failureActionType_convert (); + } + + failureActionType* failureActionType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new failureActionType (*this, f, c); + } + + failureActionType::_xsd_failureActionType failureActionType:: + _xsd_failureActionType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_failureActionType_literals_); + const _xsd_failureActionType* i (::std::lower_bound ( + _xsd_failureActionType_indexes_, + _xsd_failureActionType_indexes_ + 3, + *this, + c)); + + if (i == _xsd_failureActionType_indexes_ + 3 || _xsd_failureActionType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const failureActionType:: + _xsd_failureActionType_literals_[3] = + { + "drop", + "defer", + "exec" + }; + + const failureActionType::_xsd_failureActionType failureActionType:: + _xsd_failureActionType_indexes_[3] = + { + ::dtn::rtrmessage::failureActionType::defer, + ::dtn::rtrmessage::failureActionType::drop, + ::dtn::rtrmessage::failureActionType::exec + }; + + // bundleLocationType + // + + bundleLocationType:: + bundleLocationType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_bundleLocationType_convert (); + } + + bundleLocationType:: + bundleLocationType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_bundleLocationType_convert (); + } + + bundleLocationType:: + bundleLocationType (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_bundleLocationType_convert (); + } + + bundleLocationType* bundleLocationType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleLocationType (*this, f, c); + } + + bundleLocationType::_xsd_bundleLocationType bundleLocationType:: + _xsd_bundleLocationType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundleLocationType_literals_); + const _xsd_bundleLocationType* i (::std::lower_bound ( + _xsd_bundleLocationType_indexes_, + _xsd_bundleLocationType_indexes_ + 3, + *this, + c)); + + if (i == _xsd_bundleLocationType_indexes_ + 3 || _xsd_bundleLocationType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const bundleLocationType:: + _xsd_bundleLocationType_literals_[3] = + { + "memory", + "disk", + "nodata" + }; + + const bundleLocationType::_xsd_bundleLocationType bundleLocationType:: + _xsd_bundleLocationType_indexes_[3] = + { + ::dtn::rtrmessage::bundleLocationType::disk, + ::dtn::rtrmessage::bundleLocationType::memory, + ::dtn::rtrmessage::bundleLocationType::nodata + }; + + // eidType_base + // + + eidType_base:: + eidType_base () + : ::xml_schema::type (), + _xsd_uri_ (::xml_schema::flags (), this) + { + } + + eidType_base:: + eidType_base (const uri::type& _xsd_uri) + : ::xml_schema::type (), + _xsd_uri_ (_xsd_uri, + ::xml_schema::flags (), + this) + { + } + + eidType_base:: + eidType_base (const eidType_base& _xsd_eidType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_eidType_base, f, c), + _xsd_uri_ (_xsd_eidType_base._xsd_uri_, + f | ::xml_schema::flags::not_root, + this) + { + } + + eidType_base:: + eidType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_uri_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void eidType_base:: + 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 () == "uri" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< uri::type > r ( + uri::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->uri (r); + continue; + } + } + + if (!_xsd_uri_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "uri", + ""); + } + } + + eidType_base* eidType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new eidType_base (*this, f, c); + } + + // gbofIdType_base + // + + gbofIdType_base:: + gbofIdType_base () + : ::xml_schema::type (), + _xsd_source_ (::xml_schema::flags (), this), + _xsd_creation_ts_ (::xml_schema::flags (), this), + _xsd_is_fragment_ (::xml_schema::flags (), this), + _xsd_frag_length_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this) + { + } + + gbofIdType_base:: + gbofIdType_base (const source::type& _xsd_source, + const creation_ts::type& _xsd_creation_ts, + const is_fragment::type& _xsd_is_fragment, + const frag_length::type& _xsd_frag_length, + const frag_offset::type& _xsd_frag_offset) + : ::xml_schema::type (), + _xsd_source_ (_xsd_source, + ::xml_schema::flags (), + this), + _xsd_creation_ts_ (_xsd_creation_ts, + ::xml_schema::flags (), + this), + _xsd_is_fragment_ (_xsd_is_fragment, + ::xml_schema::flags (), + this), + _xsd_frag_length_ (_xsd_frag_length, + ::xml_schema::flags (), + this), + _xsd_frag_offset_ (_xsd_frag_offset, + ::xml_schema::flags (), + this) + { + } + + gbofIdType_base:: + gbofIdType_base (const gbofIdType_base& _xsd_gbofIdType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_gbofIdType_base, f, c), + _xsd_source_ (_xsd_gbofIdType_base._xsd_source_, + f | ::xml_schema::flags::not_root, + this), + _xsd_creation_ts_ (_xsd_gbofIdType_base._xsd_creation_ts_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_fragment_ (_xsd_gbofIdType_base._xsd_is_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_length_ (_xsd_gbofIdType_base._xsd_frag_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_offset_ (_xsd_gbofIdType_base._xsd_frag_offset_, + f | ::xml_schema::flags::not_root, + this) + { + } + + gbofIdType_base:: + gbofIdType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_source_ (f | ::xml_schema::flags::not_root, this), + _xsd_creation_ts_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_offset_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void gbofIdType_base:: + 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 ()); + + // source + // + { + if (e.name () == "source" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< source::type > r ( + source::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_source_.present ()) + continue; + this->source (r); + continue; + } + } + } + + if (!_xsd_source_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "source", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "creation_ts" && a.namespace_ ().empty ()) + { + this->creation_ts ( + creation_ts::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 () == "frag_length" && a.namespace_ ().empty ()) + { + this->frag_length ( + frag_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "frag_offset" && a.namespace_ ().empty ()) + { + this->frag_offset ( + frag_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_creation_ts_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "creation_ts", + ""); + } + + if (!_xsd_is_fragment_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_fragment", + ""); + } + + if (!_xsd_frag_length_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "frag_length", + ""); + } + + if (!_xsd_frag_offset_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "frag_offset", + ""); + } + } + + gbofIdType_base* gbofIdType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new gbofIdType_base (*this, f, c); + } + + // bundleType_base + // + + bundleType_base:: + bundleType_base () + : ::xml_schema::type (), + _xsd_source_ (::xml_schema::flags (), this), + _xsd_dest_ (::xml_schema::flags (), this), + _xsd_custodian_ (::xml_schema::flags (), this), + _xsd_replyto_ (::xml_schema::flags (), this), + _xsd_prevhop_ (::xml_schema::flags (), this), + _xsd_length_ (::xml_schema::flags (), this), + _xsd_location_ (::xml_schema::flags (), this), + _xsd_payload_file_ (::xml_schema::flags (), this), + _xsd_bundleid_ (::xml_schema::flags (), this), + _xsd_is_fragment_ (::xml_schema::flags (), this), + _xsd_is_admin_ (::xml_schema::flags (), this), + _xsd_do_not_fragment_ (::xml_schema::flags (), this), + _xsd_priority_ (::xml_schema::flags (), this), + _xsd_custody_requested_ (::xml_schema::flags (), this), + _xsd_local_custody_ (::xml_schema::flags (), this), + _xsd_singleton_dest_ (::xml_schema::flags (), this), + _xsd_custody_rcpt_ (::xml_schema::flags (), this), + _xsd_receive_rcpt_ (::xml_schema::flags (), this), + _xsd_forward_rcpt_ (::xml_schema::flags (), this), + _xsd_delivery_rcpt_ (::xml_schema::flags (), this), + _xsd_deletion_rcpt_ (::xml_schema::flags (), this), + _xsd_app_acked_rcpt_ (::xml_schema::flags (), this), + _xsd_creation_ts_seconds_ (::xml_schema::flags (), this), + _xsd_creation_ts_seqno_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this), + _xsd_orig_length_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this), + _xsd_owner_ (::xml_schema::flags (), this) + { + } + + bundleType_base:: + bundleType_base (const source::type& _xsd_source, + const dest::type& _xsd_dest, + const custodian::type& _xsd_custodian, + const replyto::type& _xsd_replyto, + const prevhop::type& _xsd_prevhop, + const length::type& _xsd_length, + const location::type& _xsd_location, + const bundleid::type& _xsd_bundleid, + const is_fragment::type& _xsd_is_fragment, + const is_admin::type& _xsd_is_admin, + const do_not_fragment::type& _xsd_do_not_fragment, + const priority::type& _xsd_priority, + const custody_requested::type& _xsd_custody_requested, + const local_custody::type& _xsd_local_custody, + const singleton_dest::type& _xsd_singleton_dest, + const custody_rcpt::type& _xsd_custody_rcpt, + const receive_rcpt::type& _xsd_receive_rcpt, + const forward_rcpt::type& _xsd_forward_rcpt, + const delivery_rcpt::type& _xsd_delivery_rcpt, + const deletion_rcpt::type& _xsd_deletion_rcpt, + const app_acked_rcpt::type& _xsd_app_acked_rcpt, + const creation_ts_seconds::type& _xsd_creation_ts_seconds, + const creation_ts_seqno::type& _xsd_creation_ts_seqno, + const expiration::type& _xsd_expiration, + const orig_length::type& _xsd_orig_length, + const frag_offset::type& _xsd_frag_offset, + const owner::type& _xsd_owner) + : ::xml_schema::type (), + _xsd_source_ (_xsd_source, + ::xml_schema::flags (), + this), + _xsd_dest_ (_xsd_dest, + ::xml_schema::flags (), + this), + _xsd_custodian_ (_xsd_custodian, + ::xml_schema::flags (), + this), + _xsd_replyto_ (_xsd_replyto, + ::xml_schema::flags (), + this), + _xsd_prevhop_ (_xsd_prevhop, + ::xml_schema::flags (), + this), + _xsd_length_ (_xsd_length, + ::xml_schema::flags (), + this), + _xsd_location_ (_xsd_location, + ::xml_schema::flags (), + this), + _xsd_payload_file_ (::xml_schema::flags (), this), + _xsd_bundleid_ (_xsd_bundleid, + ::xml_schema::flags (), + this), + _xsd_is_fragment_ (_xsd_is_fragment, + ::xml_schema::flags (), + this), + _xsd_is_admin_ (_xsd_is_admin, + ::xml_schema::flags (), + this), + _xsd_do_not_fragment_ (_xsd_do_not_fragment, + ::xml_schema::flags (), + this), + _xsd_priority_ (_xsd_priority, + ::xml_schema::flags (), + this), + _xsd_custody_requested_ (_xsd_custody_requested, + ::xml_schema::flags (), + this), + _xsd_local_custody_ (_xsd_local_custody, + ::xml_schema::flags (), + this), + _xsd_singleton_dest_ (_xsd_singleton_dest, + ::xml_schema::flags (), + this), + _xsd_custody_rcpt_ (_xsd_custody_rcpt, + ::xml_schema::flags (), + this), + _xsd_receive_rcpt_ (_xsd_receive_rcpt, + ::xml_schema::flags (), + this), + _xsd_forward_rcpt_ (_xsd_forward_rcpt, + ::xml_schema::flags (), + this), + _xsd_delivery_rcpt_ (_xsd_delivery_rcpt, + ::xml_schema::flags (), + this), + _xsd_deletion_rcpt_ (_xsd_deletion_rcpt, + ::xml_schema::flags (), + this), + _xsd_app_acked_rcpt_ (_xsd_app_acked_rcpt, + ::xml_schema::flags (), + this), + _xsd_creation_ts_seconds_ (_xsd_creation_ts_seconds, + ::xml_schema::flags (), + this), + _xsd_creation_ts_seqno_ (_xsd_creation_ts_seqno, + ::xml_schema::flags (), + this), + _xsd_expiration_ (_xsd_expiration, + ::xml_schema::flags (), + this), + _xsd_orig_length_ (_xsd_orig_length, + ::xml_schema::flags (), + this), + _xsd_frag_offset_ (_xsd_frag_offset, + ::xml_schema::flags (), + this), + _xsd_owner_ (_xsd_owner, + ::xml_schema::flags (), + this) + { + } + + bundleType_base:: + bundleType_base (const bundleType_base& _xsd_bundleType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundleType_base, f, c), + _xsd_source_ (_xsd_bundleType_base._xsd_source_, + f | ::xml_schema::flags::not_root, + this), + _xsd_dest_ (_xsd_bundleType_base._xsd_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custodian_ (_xsd_bundleType_base._xsd_custodian_, + f | ::xml_schema::flags::not_root, + this), + _xsd_replyto_ (_xsd_bundleType_base._xsd_replyto_, + f | ::xml_schema::flags::not_root, + this), + _xsd_prevhop_ (_xsd_bundleType_base._xsd_prevhop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_length_ (_xsd_bundleType_base._xsd_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_location_ (_xsd_bundleType_base._xsd_location_, + f | ::xml_schema::flags::not_root, + this), + _xsd_payload_file_ (_xsd_bundleType_base._xsd_payload_file_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundleid_ (_xsd_bundleType_base._xsd_bundleid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_fragment_ (_xsd_bundleType_base._xsd_is_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_admin_ (_xsd_bundleType_base._xsd_is_admin_, + f | ::xml_schema::flags::not_root, + this), + _xsd_do_not_fragment_ (_xsd_bundleType_base._xsd_do_not_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_priority_ (_xsd_bundleType_base._xsd_priority_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_requested_ (_xsd_bundleType_base._xsd_custody_requested_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_custody_ (_xsd_bundleType_base._xsd_local_custody_, + f | ::xml_schema::flags::not_root, + this), + _xsd_singleton_dest_ (_xsd_bundleType_base._xsd_singleton_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_rcpt_ (_xsd_bundleType_base._xsd_custody_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_receive_rcpt_ (_xsd_bundleType_base._xsd_receive_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_forward_rcpt_ (_xsd_bundleType_base._xsd_forward_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_delivery_rcpt_ (_xsd_bundleType_base._xsd_delivery_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_deletion_rcpt_ (_xsd_bundleType_base._xsd_deletion_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_app_acked_rcpt_ (_xsd_bundleType_base._xsd_app_acked_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_creation_ts_seconds_ (_xsd_bundleType_base._xsd_creation_ts_seconds_, + f | ::xml_schema::flags::not_root, + this), + _xsd_creation_ts_seqno_ (_xsd_bundleType_base._xsd_creation_ts_seqno_, + f | ::xml_schema::flags::not_root, + this), + _xsd_expiration_ (_xsd_bundleType_base._xsd_expiration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_length_ (_xsd_bundleType_base._xsd_orig_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_offset_ (_xsd_bundleType_base._xsd_frag_offset_, + f | ::xml_schema::flags::not_root, + this), + _xsd_owner_ (_xsd_bundleType_base._xsd_owner_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundleType_base:: + bundleType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_source_ (f | ::xml_schema::flags::not_root, this), + _xsd_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_custodian_ (f | ::xml_schema::flags::not_root, this), + _xsd_replyto_ (f | ::xml_schema::flags::not_root, this), + _xsd_prevhop_ (f | ::xml_schema::flags::not_root, this), + _xsd_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_location_ (f | ::xml_schema::flags::not_root, this), + _xsd_payload_file_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundleid_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_admin_ (f | ::xml_schema::flags::not_root, this), + _xsd_do_not_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_priority_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_requested_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_custody_ (f | ::xml_schema::flags::not_root, this), + _xsd_singleton_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_receive_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_forward_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_delivery_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_deletion_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_app_acked_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_creation_ts_seconds_ (f | ::xml_schema::flags::not_root, this), + _xsd_creation_ts_seqno_ (f | ::xml_schema::flags::not_root, this), + _xsd_expiration_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_offset_ (f | ::xml_schema::flags::not_root, this), + _xsd_owner_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundleType_base:: + 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 ()); + + // source + // + { + if (e.name () == "source" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< source::type > r ( + source::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_source_.present ()) + continue; + this->source (r); + continue; + } + } + + // dest + // + { + if (e.name () == "dest" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest::type > r ( + dest::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_dest_.present ()) + continue; + this->dest (r); + continue; + } + } + + // custodian + // + { + if (e.name () == "custodian" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< custodian::type > r ( + custodian::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_custodian_.present ()) + continue; + this->custodian (r); + continue; + } + } + + // replyto + // + { + if (e.name () == "replyto" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< replyto::type > r ( + replyto::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_replyto_.present ()) + continue; + this->replyto (r); + continue; + } + } + + // prevhop + // + { + if (e.name () == "prevhop" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< prevhop::type > r ( + prevhop::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_prevhop_.present ()) + continue; + this->prevhop (r); + continue; + } + } + + // length + // + { + if (e.name () == "length" && e.namespace_ ().empty ()) + { + if (_xsd_length_.present ()) + continue; + this->length ( + length::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + // location + // + { + if (e.name () == "location" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< location::type > r ( + location::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_location_.present ()) + continue; + this->location (r); + continue; + } + } + + // payload_file + // + { + if (e.name () == "payload_file" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< payload_file::type > r ( + payload_file::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->payload_file ()) + continue; + this->payload_file (r); + continue; + } + } + } + + if (!_xsd_source_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "source", + ""); + } + + if (!_xsd_dest_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "dest", + ""); + } + + if (!_xsd_custodian_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "custodian", + ""); + } + + if (!_xsd_replyto_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "replyto", + ""); + } + + if (!_xsd_prevhop_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "prevhop", + ""); + } + + if (!_xsd_length_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "length", + ""); + } + + if (!_xsd_location_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "location", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "bundleid" && a.namespace_ ().empty ()) + { + this->bundleid ( + bundleid::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 () == "is_admin" && a.namespace_ ().empty ()) + { + this->is_admin ( + is_admin::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "do_not_fragment" && a.namespace_ ().empty ()) + { + this->do_not_fragment ( + do_not_fragment::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "priority" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< priority::type > r ( + priority::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->priority (r); + continue; + } + + if (a.name () == "custody_requested" && a.namespace_ ().empty ()) + { + this->custody_requested ( + custody_requested::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "local_custody" && a.namespace_ ().empty ()) + { + this->local_custody ( + local_custody::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "singleton_dest" && a.namespace_ ().empty ()) + { + this->singleton_dest ( + singleton_dest::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "custody_rcpt" && a.namespace_ ().empty ()) + { + this->custody_rcpt ( + custody_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "receive_rcpt" && a.namespace_ ().empty ()) + { + this->receive_rcpt ( + receive_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "forward_rcpt" && a.namespace_ ().empty ()) + { + this->forward_rcpt ( + forward_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "delivery_rcpt" && a.namespace_ ().empty ()) + { + this->delivery_rcpt ( + delivery_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "deletion_rcpt" && a.namespace_ ().empty ()) + { + this->deletion_rcpt ( + deletion_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "app_acked_rcpt" && a.namespace_ ().empty ()) + { + this->app_acked_rcpt ( + app_acked_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "creation_ts_seconds" && a.namespace_ ().empty ()) + { + this->creation_ts_seconds ( + creation_ts_seconds::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "creation_ts_seqno" && a.namespace_ ().empty ()) + { + this->creation_ts_seqno ( + creation_ts_seqno::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "expiration" && a.namespace_ ().empty ()) + { + this->expiration ( + expiration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_length" && a.namespace_ ().empty ()) + { + this->orig_length ( + orig_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "frag_offset" && a.namespace_ ().empty ()) + { + this->frag_offset ( + frag_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "owner" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< owner::type > r ( + owner::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->owner (r); + continue; + } + } + + if (!_xsd_bundleid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "bundleid", + ""); + } + + if (!_xsd_is_fragment_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_fragment", + ""); + } + + if (!_xsd_is_admin_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_admin", + ""); + } + + if (!_xsd_do_not_fragment_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "do_not_fragment", + ""); + } + + if (!_xsd_priority_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "priority", + ""); + } + + if (!_xsd_custody_requested_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "custody_requested", + ""); + } + + if (!_xsd_local_custody_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_custody", + ""); + } + + if (!_xsd_singleton_dest_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "singleton_dest", + ""); + } + + if (!_xsd_custody_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "custody_rcpt", + ""); + } + + if (!_xsd_receive_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "receive_rcpt", + ""); + } + + if (!_xsd_forward_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "forward_rcpt", + ""); + } + + if (!_xsd_delivery_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "delivery_rcpt", + ""); + } + + if (!_xsd_deletion_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "deletion_rcpt", + ""); + } + + if (!_xsd_app_acked_rcpt_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "app_acked_rcpt", + ""); + } + + if (!_xsd_creation_ts_seconds_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "creation_ts_seconds", + ""); + } + + if (!_xsd_creation_ts_seqno_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "creation_ts_seqno", + ""); + } + + if (!_xsd_expiration_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "expiration", + ""); + } + + if (!_xsd_orig_length_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "orig_length", + ""); + } + + if (!_xsd_frag_offset_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "frag_offset", + ""); + } + + if (!_xsd_owner_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "owner", + ""); + } + } + + bundleType_base* bundleType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleType_base (*this, f, c); + } + + // contactType_base + // + + contactType_base:: + contactType_base () + : ::xml_schema::type (), + _xsd_link_attr_ (::xml_schema::flags (), this), + _xsd_start_time_sec_ (::xml_schema::flags (), this), + _xsd_start_time_usec_ (::xml_schema::flags (), this), + _xsd_duration_ (::xml_schema::flags (), this), + _xsd_bps_ (::xml_schema::flags (), this), + _xsd_latency_ (::xml_schema::flags (), this), + _xsd_pkt_loss_prob_ (::xml_schema::flags (), this) + { + } + + contactType_base:: + contactType_base (const link_attr::type& _xsd_link_attr, + const start_time_sec::type& _xsd_start_time_sec, + const start_time_usec::type& _xsd_start_time_usec, + const duration::type& _xsd_duration, + const bps::type& _xsd_bps, + const latency::type& _xsd_latency, + const pkt_loss_prob::type& _xsd_pkt_loss_prob) + : ::xml_schema::type (), + _xsd_link_attr_ (_xsd_link_attr, + ::xml_schema::flags (), + this), + _xsd_start_time_sec_ (_xsd_start_time_sec, + ::xml_schema::flags (), + this), + _xsd_start_time_usec_ (_xsd_start_time_usec, + ::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_pkt_loss_prob_ (_xsd_pkt_loss_prob, + ::xml_schema::flags (), + this) + { + } + + contactType_base:: + contactType_base (const contactType_base& _xsd_contactType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_contactType_base, f, c), + _xsd_link_attr_ (_xsd_contactType_base._xsd_link_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_start_time_sec_ (_xsd_contactType_base._xsd_start_time_sec_, + f | ::xml_schema::flags::not_root, + this), + _xsd_start_time_usec_ (_xsd_contactType_base._xsd_start_time_usec_, + f | ::xml_schema::flags::not_root, + this), + _xsd_duration_ (_xsd_contactType_base._xsd_duration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bps_ (_xsd_contactType_base._xsd_bps_, + f | ::xml_schema::flags::not_root, + this), + _xsd_latency_ (_xsd_contactType_base._xsd_latency_, + f | ::xml_schema::flags::not_root, + this), + _xsd_pkt_loss_prob_ (_xsd_contactType_base._xsd_pkt_loss_prob_, + f | ::xml_schema::flags::not_root, + this) + { + } + + contactType_base:: + contactType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_start_time_sec_ (f | ::xml_schema::flags::not_root, this), + _xsd_start_time_usec_ (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_pkt_loss_prob_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void contactType_base:: + 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_attr + // + { + if (e.name () == "link_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_attr::type > r ( + link_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_attr_.present ()) + continue; + this->link_attr (r); + continue; + } + } + } + + if (!_xsd_link_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "start_time_sec" && a.namespace_ ().empty ()) + { + this->start_time_sec ( + start_time_sec::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "start_time_usec" && a.namespace_ ().empty ()) + { + this->start_time_usec ( + start_time_usec::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 () == "pkt_loss_prob" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< pkt_loss_prob::type > r ( + pkt_loss_prob::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->pkt_loss_prob (r); + continue; + } + } + + if (!_xsd_start_time_sec_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "start_time_sec", + ""); + } + + if (!_xsd_start_time_usec_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "start_time_usec", + ""); + } + + 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_pkt_loss_prob_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "pkt_loss_prob", + ""); + } + } + + contactType_base* contactType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new contactType_base (*this, f, c); + } + + // clInfoType + // + + clInfoType:: + clInfoType () + : ::xml_schema::type (), + _xsd_local_addr_ (::xml_schema::flags (), this), + _xsd_remote_addr_ (::xml_schema::flags (), this), + _xsd_local_port_ (::xml_schema::flags (), this), + _xsd_remote_port_ (::xml_schema::flags (), this), + _xsd_segment_ack_enabled_ (::xml_schema::flags (), this), + _xsd_negative_ack_enabled_ (::xml_schema::flags (), this), + _xsd_keepalive_interval_ (::xml_schema::flags (), this), + _xsd_segment_length_ (::xml_schema::flags (), this), + _xsd_busy_queue_depth_ (::xml_schema::flags (), this), + _xsd_reactive_frag_enabled_ (::xml_schema::flags (), this), + _xsd_sendbuf_length_ (::xml_schema::flags (), this), + _xsd_recvbuf_length_ (::xml_schema::flags (), this), + _xsd_data_timeout_ (::xml_schema::flags (), this), + _xsd_rate_ (::xml_schema::flags (), this), + _xsd_bucket_depth_ (::xml_schema::flags (), this), + _xsd_channel_ (::xml_schema::flags (), this) + { + } + + clInfoType:: + clInfoType (const clInfoType& _xsd_clInfoType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_clInfoType, f, c), + _xsd_local_addr_ (_xsd_clInfoType._xsd_local_addr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_remote_addr_ (_xsd_clInfoType._xsd_remote_addr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_port_ (_xsd_clInfoType._xsd_local_port_, + f | ::xml_schema::flags::not_root, + this), + _xsd_remote_port_ (_xsd_clInfoType._xsd_remote_port_, + f | ::xml_schema::flags::not_root, + this), + _xsd_segment_ack_enabled_ (_xsd_clInfoType._xsd_segment_ack_enabled_, + f | ::xml_schema::flags::not_root, + this), + _xsd_negative_ack_enabled_ (_xsd_clInfoType._xsd_negative_ack_enabled_, + f | ::xml_schema::flags::not_root, + this), + _xsd_keepalive_interval_ (_xsd_clInfoType._xsd_keepalive_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_segment_length_ (_xsd_clInfoType._xsd_segment_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_busy_queue_depth_ (_xsd_clInfoType._xsd_busy_queue_depth_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reactive_frag_enabled_ (_xsd_clInfoType._xsd_reactive_frag_enabled_, + f | ::xml_schema::flags::not_root, + this), + _xsd_sendbuf_length_ (_xsd_clInfoType._xsd_sendbuf_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_recvbuf_length_ (_xsd_clInfoType._xsd_recvbuf_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_data_timeout_ (_xsd_clInfoType._xsd_data_timeout_, + f | ::xml_schema::flags::not_root, + this), + _xsd_rate_ (_xsd_clInfoType._xsd_rate_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bucket_depth_ (_xsd_clInfoType._xsd_bucket_depth_, + f | ::xml_schema::flags::not_root, + this), + _xsd_channel_ (_xsd_clInfoType._xsd_channel_, + f | ::xml_schema::flags::not_root, + this) + { + } + + clInfoType:: + clInfoType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_local_addr_ (f | ::xml_schema::flags::not_root, this), + _xsd_remote_addr_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_port_ (f | ::xml_schema::flags::not_root, this), + _xsd_remote_port_ (f | ::xml_schema::flags::not_root, this), + _xsd_segment_ack_enabled_ (f | ::xml_schema::flags::not_root, this), + _xsd_negative_ack_enabled_ (f | ::xml_schema::flags::not_root, this), + _xsd_keepalive_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_segment_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_busy_queue_depth_ (f | ::xml_schema::flags::not_root, this), + _xsd_reactive_frag_enabled_ (f | ::xml_schema::flags::not_root, this), + _xsd_sendbuf_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_recvbuf_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_data_timeout_ (f | ::xml_schema::flags::not_root, this), + _xsd_rate_ (f | ::xml_schema::flags::not_root, this), + _xsd_bucket_depth_ (f | ::xml_schema::flags::not_root, this), + _xsd_channel_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void clInfoType:: + 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 () == "local_addr" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< local_addr::type > r ( + local_addr::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->local_addr (r); + continue; + } + + if (a.name () == "remote_addr" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< remote_addr::type > r ( + remote_addr::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->remote_addr (r); + continue; + } + + if (a.name () == "local_port" && a.namespace_ ().empty ()) + { + this->local_port ( + local_port::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "remote_port" && a.namespace_ ().empty ()) + { + this->remote_port ( + remote_port::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "segment_ack_enabled" && a.namespace_ ().empty ()) + { + this->segment_ack_enabled ( + segment_ack_enabled::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "negative_ack_enabled" && a.namespace_ ().empty ()) + { + this->negative_ack_enabled ( + negative_ack_enabled::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "keepalive_interval" && a.namespace_ ().empty ()) + { + this->keepalive_interval ( + keepalive_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "segment_length" && a.namespace_ ().empty ()) + { + this->segment_length ( + segment_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "busy_queue_depth" && a.namespace_ ().empty ()) + { + this->busy_queue_depth ( + busy_queue_depth::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "reactive_frag_enabled" && a.namespace_ ().empty ()) + { + this->reactive_frag_enabled ( + reactive_frag_enabled::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "sendbuf_length" && a.namespace_ ().empty ()) + { + this->sendbuf_length ( + sendbuf_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "recvbuf_length" && a.namespace_ ().empty ()) + { + this->recvbuf_length ( + recvbuf_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "data_timeout" && a.namespace_ ().empty ()) + { + this->data_timeout ( + data_timeout::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "rate" && a.namespace_ ().empty ()) + { + this->rate ( + rate::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "bucket_depth" && a.namespace_ ().empty ()) + { + this->bucket_depth ( + bucket_depth::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "channel" && a.namespace_ ().empty ()) + { + this->channel ( + channel::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + } + + clInfoType* clInfoType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new clInfoType (*this, f, c); + } + + // linkType_base + // + + linkType_base:: + linkType_base () + : ::xml_schema::type (), + _xsd_clinfo_ (::xml_schema::flags (), this), + _xsd_remote_eid_ (::xml_schema::flags (), this), + _xsd_type_ (::xml_schema::flags (), this), + _xsd_nexthop_ (::xml_schema::flags (), this), + _xsd_state_ (::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_clayer_ (::xml_schema::flags (), this), + _xsd_min_retry_interval_ (::xml_schema::flags (), this), + _xsd_max_retry_interval_ (::xml_schema::flags (), this), + _xsd_idle_close_time_ (::xml_schema::flags (), this) + { + } + + linkType_base:: + linkType_base (const remote_eid::type& _xsd_remote_eid, + const type::type_& _xsd_type, + const nexthop::type& _xsd_nexthop, + const state::type& _xsd_state, + const is_reachable::type& _xsd_is_reachable, + const is_usable::type& _xsd_is_usable, + const how_reliable::type& _xsd_how_reliable, + const how_available::type& _xsd_how_available, + const clayer::type& _xsd_clayer, + const min_retry_interval::type& _xsd_min_retry_interval, + const max_retry_interval::type& _xsd_max_retry_interval, + const idle_close_time::type& _xsd_idle_close_time) + : ::xml_schema::type (), + _xsd_clinfo_ (::xml_schema::flags (), this), + _xsd_remote_eid_ (_xsd_remote_eid, + ::xml_schema::flags (), + this), + _xsd_type_ (_xsd_type, + ::xml_schema::flags (), + this), + _xsd_nexthop_ (_xsd_nexthop, + ::xml_schema::flags (), + this), + _xsd_state_ (_xsd_state, + ::xml_schema::flags (), + this), + _xsd_is_reachable_ (_xsd_is_reachable, + ::xml_schema::flags (), + this), + _xsd_is_usable_ (_xsd_is_usable, + ::xml_schema::flags (), + this), + _xsd_how_reliable_ (_xsd_how_reliable, + ::xml_schema::flags (), + this), + _xsd_how_available_ (_xsd_how_available, + ::xml_schema::flags (), + this), + _xsd_clayer_ (_xsd_clayer, + ::xml_schema::flags (), + this), + _xsd_min_retry_interval_ (_xsd_min_retry_interval, + ::xml_schema::flags (), + this), + _xsd_max_retry_interval_ (_xsd_max_retry_interval, + ::xml_schema::flags (), + this), + _xsd_idle_close_time_ (_xsd_idle_close_time, + ::xml_schema::flags (), + this) + { + } + + linkType_base:: + linkType_base (const linkType_base& _xsd_linkType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_linkType_base, f, c), + _xsd_clinfo_ (_xsd_linkType_base._xsd_clinfo_, + f | ::xml_schema::flags::not_root, + this), + _xsd_remote_eid_ (_xsd_linkType_base._xsd_remote_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_type_ (_xsd_linkType_base._xsd_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_nexthop_ (_xsd_linkType_base._xsd_nexthop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_state_ (_xsd_linkType_base._xsd_state_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_reachable_ (_xsd_linkType_base._xsd_is_reachable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_usable_ (_xsd_linkType_base._xsd_is_usable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_how_reliable_ (_xsd_linkType_base._xsd_how_reliable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_how_available_ (_xsd_linkType_base._xsd_how_available_, + f | ::xml_schema::flags::not_root, + this), + _xsd_clayer_ (_xsd_linkType_base._xsd_clayer_, + f | ::xml_schema::flags::not_root, + this), + _xsd_min_retry_interval_ (_xsd_linkType_base._xsd_min_retry_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_max_retry_interval_ (_xsd_linkType_base._xsd_max_retry_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_idle_close_time_ (_xsd_linkType_base._xsd_idle_close_time_, + f | ::xml_schema::flags::not_root, + this) + { + } + + linkType_base:: + linkType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_clinfo_ (f | ::xml_schema::flags::not_root, this), + _xsd_remote_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this), + _xsd_state_ (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_clayer_ (f | ::xml_schema::flags::not_root, this), + _xsd_min_retry_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_max_retry_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_idle_close_time_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void linkType_base:: + 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 ()); + + // clinfo + // + { + if (e.name () == "clinfo" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< clinfo::type > r ( + clinfo::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->clinfo ()) + continue; + this->clinfo (r); + continue; + } + } + + // remote_eid + // + { + if (e.name () == "remote_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< remote_eid::type > r ( + remote_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_remote_eid_.present ()) + continue; + this->remote_eid (r); + continue; + } + } + } + + if (!_xsd_remote_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "remote_eid", + ""); + } + + 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 () == "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 () == "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 () == "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 () == "clayer" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< clayer::type > r ( + clayer::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->clayer (r); + continue; + } + + if (a.name () == "min_retry_interval" && a.namespace_ ().empty ()) + { + this->min_retry_interval ( + min_retry_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "max_retry_interval" && a.namespace_ ().empty ()) + { + this->max_retry_interval ( + max_retry_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "idle_close_time" && a.namespace_ ().empty ()) + { + this->idle_close_time ( + idle_close_time::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_type_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "type", + ""); + } + + if (!_xsd_nexthop_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "nexthop", + ""); + } + + if (!_xsd_state_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "state", + ""); + } + + if (!_xsd_is_reachable_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_reachable", + ""); + } + + if (!_xsd_is_usable_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "is_usable", + ""); + } + + if (!_xsd_how_reliable_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "how_reliable", + ""); + } + + if (!_xsd_how_available_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "how_available", + ""); + } + + if (!_xsd_clayer_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "clayer", + ""); + } + + if (!_xsd_min_retry_interval_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "min_retry_interval", + ""); + } + + if (!_xsd_max_retry_interval_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "max_retry_interval", + ""); + } + + if (!_xsd_idle_close_time_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "idle_close_time", + ""); + } + } + + linkType_base* linkType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new linkType_base (*this, f, c); + } + + // routeEntryType_base + // + + routeEntryType_base:: + routeEntryType_base () + : ::xml_schema::type (), + _xsd_dest_pattern_ (::xml_schema::flags (), this), + _xsd_source_pattern_ (::xml_schema::flags (), this), + _xsd_route_priority_ (::xml_schema::flags (), this), + _xsd_action_ (::xml_schema::flags (), this), + _xsd_link_ (::xml_schema::flags (), this) + { + } + + routeEntryType_base:: + routeEntryType_base (const dest_pattern::type& _xsd_dest_pattern, + const source_pattern::type& _xsd_source_pattern, + const route_priority::type& _xsd_route_priority, + const action::type& _xsd_action, + const link::type& _xsd_link) + : ::xml_schema::type (), + _xsd_dest_pattern_ (_xsd_dest_pattern, + ::xml_schema::flags (), + this), + _xsd_source_pattern_ (_xsd_source_pattern, + ::xml_schema::flags (), + this), + _xsd_route_priority_ (_xsd_route_priority, + ::xml_schema::flags (), + this), + _xsd_action_ (_xsd_action, + ::xml_schema::flags (), + this), + _xsd_link_ (_xsd_link, + ::xml_schema::flags (), + this) + { + } + + routeEntryType_base:: + routeEntryType_base (const routeEntryType_base& _xsd_routeEntryType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_routeEntryType_base, f, c), + _xsd_dest_pattern_ (_xsd_routeEntryType_base._xsd_dest_pattern_, + f | ::xml_schema::flags::not_root, + this), + _xsd_source_pattern_ (_xsd_routeEntryType_base._xsd_source_pattern_, + f | ::xml_schema::flags::not_root, + this), + _xsd_route_priority_ (_xsd_routeEntryType_base._xsd_route_priority_, + f | ::xml_schema::flags::not_root, + this), + _xsd_action_ (_xsd_routeEntryType_base._xsd_action_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_ (_xsd_routeEntryType_base._xsd_link_, + f | ::xml_schema::flags::not_root, + this) + { + } + + routeEntryType_base:: + routeEntryType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_dest_pattern_ (f | ::xml_schema::flags::not_root, this), + _xsd_source_pattern_ (f | ::xml_schema::flags::not_root, this), + _xsd_route_priority_ (f | ::xml_schema::flags::not_root, this), + _xsd_action_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void routeEntryType_base:: + 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 ()); + + // dest_pattern + // + { + if (e.name () == "dest_pattern" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest_pattern::type > r ( + dest_pattern::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_dest_pattern_.present ()) + continue; + this->dest_pattern (r); + continue; + } + } + + // source_pattern + // + { + if (e.name () == "source_pattern" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< source_pattern::type > r ( + source_pattern::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_source_pattern_.present ()) + continue; + this->source_pattern (r); + continue; + } + } + } + + if (!_xsd_dest_pattern_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "dest_pattern", + ""); + } + + if (!_xsd_source_pattern_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "source_pattern", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "route_priority" && a.namespace_ ().empty ()) + { + this->route_priority ( + route_priority::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "action" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< action::type > r ( + action::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->action (r); + continue; + } + + if (a.name () == "link" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link::type > r ( + link::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link (r); + continue; + } + } + + if (!_xsd_route_priority_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "route_priority", + ""); + } + + if (!_xsd_action_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "action", + ""); + } + + if (!_xsd_link_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link", + ""); + } + } + + routeEntryType_base* routeEntryType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new routeEntryType_base (*this, f, c); + } + + // custodySignalType + // + + custodySignalType:: + custodySignalType () + : ::xml_schema::type (), + _xsd_admin_type_ (::xml_schema::flags (), this), + _xsd_admin_flags_ (::xml_schema::flags (), this), + _xsd_succeeded_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this), + _xsd_orig_frag_offset_ (::xml_schema::flags (), this), + _xsd_orig_frag_length_ (::xml_schema::flags (), this), + _xsd_custody_signal_seconds_ (::xml_schema::flags (), this), + _xsd_custody_signal_seqno_ (::xml_schema::flags (), this), + _xsd_orig_creation_seconds_ (::xml_schema::flags (), this), + _xsd_orig_creation_seqno_ (::xml_schema::flags (), this) + { + } + + custodySignalType:: + custodySignalType (const admin_type::type& _xsd_admin_type, + const admin_flags::type& _xsd_admin_flags, + const succeeded::type& _xsd_succeeded, + const reason::type& _xsd_reason, + const orig_frag_offset::type& _xsd_orig_frag_offset, + const orig_frag_length::type& _xsd_orig_frag_length, + const custody_signal_seconds::type& _xsd_custody_signal_seconds, + const custody_signal_seqno::type& _xsd_custody_signal_seqno, + const orig_creation_seconds::type& _xsd_orig_creation_seconds, + const orig_creation_seqno::type& _xsd_orig_creation_seqno) + : ::xml_schema::type (), + _xsd_admin_type_ (_xsd_admin_type, + ::xml_schema::flags (), + this), + _xsd_admin_flags_ (_xsd_admin_flags, + ::xml_schema::flags (), + this), + _xsd_succeeded_ (_xsd_succeeded, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this), + _xsd_orig_frag_offset_ (_xsd_orig_frag_offset, + ::xml_schema::flags (), + this), + _xsd_orig_frag_length_ (_xsd_orig_frag_length, + ::xml_schema::flags (), + this), + _xsd_custody_signal_seconds_ (_xsd_custody_signal_seconds, + ::xml_schema::flags (), + this), + _xsd_custody_signal_seqno_ (_xsd_custody_signal_seqno, + ::xml_schema::flags (), + this), + _xsd_orig_creation_seconds_ (_xsd_orig_creation_seconds, + ::xml_schema::flags (), + this), + _xsd_orig_creation_seqno_ (_xsd_orig_creation_seqno, + ::xml_schema::flags (), + this) + { + } + + custodySignalType:: + custodySignalType (const custodySignalType& _xsd_custodySignalType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_custodySignalType, f, c), + _xsd_admin_type_ (_xsd_custodySignalType._xsd_admin_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_admin_flags_ (_xsd_custodySignalType._xsd_admin_flags_, + f | ::xml_schema::flags::not_root, + this), + _xsd_succeeded_ (_xsd_custodySignalType._xsd_succeeded_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_custodySignalType._xsd_reason_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_frag_offset_ (_xsd_custodySignalType._xsd_orig_frag_offset_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_frag_length_ (_xsd_custodySignalType._xsd_orig_frag_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_signal_seconds_ (_xsd_custodySignalType._xsd_custody_signal_seconds_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_signal_seqno_ (_xsd_custodySignalType._xsd_custody_signal_seqno_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_creation_seconds_ (_xsd_custodySignalType._xsd_orig_creation_seconds_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_creation_seqno_ (_xsd_custodySignalType._xsd_orig_creation_seqno_, + f | ::xml_schema::flags::not_root, + this) + { + } + + custodySignalType:: + custodySignalType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_admin_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_admin_flags_ (f | ::xml_schema::flags::not_root, this), + _xsd_succeeded_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_frag_offset_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_frag_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_signal_seconds_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_signal_seqno_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_creation_seconds_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_creation_seqno_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void custodySignalType:: + 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 () == "admin_type" && a.namespace_ ().empty ()) + { + this->admin_type ( + admin_type::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "admin_flags" && a.namespace_ ().empty ()) + { + this->admin_flags ( + admin_flags::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "succeeded" && a.namespace_ ().empty ()) + { + this->succeeded ( + succeeded::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "reason" && a.namespace_ ().empty ()) + { + this->reason ( + reason::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_frag_offset" && a.namespace_ ().empty ()) + { + this->orig_frag_offset ( + orig_frag_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_frag_length" && a.namespace_ ().empty ()) + { + this->orig_frag_length ( + orig_frag_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "custody_signal_seconds" && a.namespace_ ().empty ()) + { + this->custody_signal_seconds ( + custody_signal_seconds::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "custody_signal_seqno" && a.namespace_ ().empty ()) + { + this->custody_signal_seqno ( + custody_signal_seqno::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_creation_seconds" && a.namespace_ ().empty ()) + { + this->orig_creation_seconds ( + orig_creation_seconds::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_creation_seqno" && a.namespace_ ().empty ()) + { + this->orig_creation_seqno ( + orig_creation_seqno::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_admin_type_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "admin_type", + ""); + } + + if (!_xsd_admin_flags_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "admin_flags", + ""); + } + + if (!_xsd_succeeded_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "succeeded", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + + if (!_xsd_orig_frag_offset_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "orig_frag_offset", + ""); + } + + if (!_xsd_orig_frag_length_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "orig_frag_length", + ""); + } + + if (!_xsd_custody_signal_seconds_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "custody_signal_seconds", + ""); + } + + if (!_xsd_custody_signal_seqno_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "custody_signal_seqno", + ""); + } + + if (!_xsd_orig_creation_seconds_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "orig_creation_seconds", + ""); + } + + if (!_xsd_orig_creation_seqno_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "orig_creation_seqno", + ""); + } + } + + custodySignalType* custodySignalType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new custodySignalType (*this, f, c); + } + + // registrationType_base + // + + registrationType_base:: + registrationType_base () + : ::xml_schema::type (), + _xsd_endpoint_ (::xml_schema::flags (), this), + _xsd_regid_ (::xml_schema::flags (), this), + _xsd_action_ (::xml_schema::flags (), this), + _xsd_script_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this) + { + } + + registrationType_base:: + registrationType_base (const endpoint::type& _xsd_endpoint, + const regid::type& _xsd_regid, + const action::type& _xsd_action, + const script::type& _xsd_script, + const expiration::type& _xsd_expiration) + : ::xml_schema::type (), + _xsd_endpoint_ (_xsd_endpoint, + ::xml_schema::flags (), + this), + _xsd_regid_ (_xsd_regid, + ::xml_schema::flags (), + this), + _xsd_action_ (_xsd_action, + ::xml_schema::flags (), + this), + _xsd_script_ (_xsd_script, + ::xml_schema::flags (), + this), + _xsd_expiration_ (_xsd_expiration, + ::xml_schema::flags (), + this) + { + } + + registrationType_base:: + registrationType_base (const registrationType_base& _xsd_registrationType_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_registrationType_base, f, c), + _xsd_endpoint_ (_xsd_registrationType_base._xsd_endpoint_, + f | ::xml_schema::flags::not_root, + this), + _xsd_regid_ (_xsd_registrationType_base._xsd_regid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_action_ (_xsd_registrationType_base._xsd_action_, + f | ::xml_schema::flags::not_root, + this), + _xsd_script_ (_xsd_registrationType_base._xsd_script_, + f | ::xml_schema::flags::not_root, + this), + _xsd_expiration_ (_xsd_registrationType_base._xsd_expiration_, + f | ::xml_schema::flags::not_root, + this) + { + } + + registrationType_base:: + registrationType_base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_endpoint_ (f | ::xml_schema::flags::not_root, this), + _xsd_regid_ (f | ::xml_schema::flags::not_root, this), + _xsd_action_ (f | ::xml_schema::flags::not_root, this), + _xsd_script_ (f | ::xml_schema::flags::not_root, this), + _xsd_expiration_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void registrationType_base:: + 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 ()); + + // endpoint + // + { + if (e.name () == "endpoint" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< endpoint::type > r ( + endpoint::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_endpoint_.present ()) + continue; + this->endpoint (r); + continue; + } + } + } + + if (!_xsd_endpoint_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "endpoint", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "regid" && a.namespace_ ().empty ()) + { + this->regid ( + regid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "action" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< action::type > r ( + action::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->action (r); + continue; + } + + if (a.name () == "script" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< script::type > r ( + script::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->script (r); + continue; + } + + if (a.name () == "expiration" && a.namespace_ ().empty ()) + { + this->expiration ( + expiration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_regid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "regid", + ""); + } + + if (!_xsd_action_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "action", + ""); + } + + if (!_xsd_script_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "script", + ""); + } + + if (!_xsd_expiration_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "expiration", + ""); + } + } + + registrationType_base* registrationType_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new registrationType_base (*this, f, c); + } + + // linkConfigType + // + + linkConfigType:: + linkConfigType () + : ::xml_schema::type (), + _xsd_cl_params_ (::xml_schema::flags (), this), + _xsd_is_usable_ (::xml_schema::flags (), this), + _xsd_reactive_frag_enabled_ (::xml_schema::flags (), this), + _xsd_nexthop_ (::xml_schema::flags (), this), + _xsd_min_retry_interval_ (::xml_schema::flags (), this), + _xsd_max_retry_interval_ (::xml_schema::flags (), this), + _xsd_idle_close_time_ (::xml_schema::flags (), this) + { + } + + linkConfigType:: + linkConfigType (const linkConfigType& _xsd_linkConfigType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_linkConfigType, f, c), + _xsd_cl_params_ (_xsd_linkConfigType._xsd_cl_params_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_usable_ (_xsd_linkConfigType._xsd_is_usable_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reactive_frag_enabled_ (_xsd_linkConfigType._xsd_reactive_frag_enabled_, + f | ::xml_schema::flags::not_root, + this), + _xsd_nexthop_ (_xsd_linkConfigType._xsd_nexthop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_min_retry_interval_ (_xsd_linkConfigType._xsd_min_retry_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_max_retry_interval_ (_xsd_linkConfigType._xsd_max_retry_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_idle_close_time_ (_xsd_linkConfigType._xsd_idle_close_time_, + f | ::xml_schema::flags::not_root, + this) + { + } + + linkConfigType:: + linkConfigType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_cl_params_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_usable_ (f | ::xml_schema::flags::not_root, this), + _xsd_reactive_frag_enabled_ (f | ::xml_schema::flags::not_root, this), + _xsd_nexthop_ (f | ::xml_schema::flags::not_root, this), + _xsd_min_retry_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_max_retry_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_idle_close_time_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void linkConfigType:: + 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 ()); + + // cl_params + // + { + if (e.name () == "cl_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< cl_params::type > r ( + cl_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->cl_params ().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_frag_enabled" && a.namespace_ ().empty ()) + { + this->reactive_frag_enabled ( + reactive_frag_enabled::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 () == "min_retry_interval" && a.namespace_ ().empty ()) + { + this->min_retry_interval ( + min_retry_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "max_retry_interval" && a.namespace_ ().empty ()) + { + this->max_retry_interval ( + max_retry_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "idle_close_time" && a.namespace_ ().empty ()) + { + this->idle_close_time ( + idle_close_time::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + } + + linkConfigType* linkConfigType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new linkConfigType (*this, f, c); + } + + // key_value_pair_base + // + + key_value_pair_base:: + key_value_pair_base () + : ::xml_schema::type (), + _xsd_name_ (::xml_schema::flags (), this), + _xsd_bool_value_ (::xml_schema::flags (), this), + _xsd_u_int_value_ (::xml_schema::flags (), this), + _xsd_int_value_ (::xml_schema::flags (), this), + _xsd_str_value_ (::xml_schema::flags (), this) + { + } + + key_value_pair_base:: + key_value_pair_base (const name::type& _xsd_name) + : ::xml_schema::type (), + _xsd_name_ (_xsd_name, + ::xml_schema::flags (), + this), + _xsd_bool_value_ (::xml_schema::flags (), this), + _xsd_u_int_value_ (::xml_schema::flags (), this), + _xsd_int_value_ (::xml_schema::flags (), this), + _xsd_str_value_ (::xml_schema::flags (), this) + { + } + + key_value_pair_base:: + key_value_pair_base (const key_value_pair_base& _xsd_key_value_pair_base, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_key_value_pair_base, f, c), + _xsd_name_ (_xsd_key_value_pair_base._xsd_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bool_value_ (_xsd_key_value_pair_base._xsd_bool_value_, + f | ::xml_schema::flags::not_root, + this), + _xsd_u_int_value_ (_xsd_key_value_pair_base._xsd_u_int_value_, + f | ::xml_schema::flags::not_root, + this), + _xsd_int_value_ (_xsd_key_value_pair_base._xsd_int_value_, + f | ::xml_schema::flags::not_root, + this), + _xsd_str_value_ (_xsd_key_value_pair_base._xsd_str_value_, + f | ::xml_schema::flags::not_root, + this) + { + } + + key_value_pair_base:: + key_value_pair_base (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_bool_value_ (f | ::xml_schema::flags::not_root, this), + _xsd_u_int_value_ (f | ::xml_schema::flags::not_root, this), + _xsd_int_value_ (f | ::xml_schema::flags::not_root, this), + _xsd_str_value_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void key_value_pair_base:: + 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 ()); + + // name + // + { + if (e.name () == "name" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< name::type > r ( + name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_name_.present ()) + continue; + this->name (r); + continue; + } + } + + // bool_value + // + { + if (e.name () == "bool_value" && e.namespace_ ().empty ()) + { + if (this->bool_value ()) + continue; + this->bool_value ( + bool_value::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + // u_int_value + // + { + if (e.name () == "u_int_value" && e.namespace_ ().empty ()) + { + if (this->u_int_value ()) + continue; + this->u_int_value ( + u_int_value::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + // int_value + // + { + if (e.name () == "int_value" && e.namespace_ ().empty ()) + { + if (this->int_value ()) + continue; + this->int_value ( + int_value::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + // str_value + // + { + if (e.name () == "str_value" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< str_value::type > r ( + str_value::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->str_value ()) + continue; + this->str_value (r); + continue; + } + } + } + + if (!_xsd_name_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "name", + ""); + } + } + + key_value_pair_base* key_value_pair_base:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new key_value_pair_base (*this, f, c); + } + + // bundleAttributesSimpleQueryType + // + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (e, f, c) + { + _xsd_bundleAttributesSimpleQueryType_convert (); + } + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::string (a, f, c) + { + _xsd_bundleAttributesSimpleQueryType_convert (); + } + + bundleAttributesSimpleQueryType:: + bundleAttributesSimpleQueryType (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_bundleAttributesSimpleQueryType_convert (); + } + + bundleAttributesSimpleQueryType* bundleAttributesSimpleQueryType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleAttributesSimpleQueryType (*this, f, c); + } + + bundleAttributesSimpleQueryType::_xsd_bundleAttributesSimpleQueryType bundleAttributesSimpleQueryType:: + _xsd_bundleAttributesSimpleQueryType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_bundleAttributesSimpleQueryType_literals_); + const _xsd_bundleAttributesSimpleQueryType* i (::std::lower_bound ( + _xsd_bundleAttributesSimpleQueryType_indexes_, + _xsd_bundleAttributesSimpleQueryType_indexes_ + 24, + *this, + c)); + + if (i == _xsd_bundleAttributesSimpleQueryType_indexes_ + 24 || _xsd_bundleAttributesSimpleQueryType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const bundleAttributesSimpleQueryType:: + _xsd_bundleAttributesSimpleQueryType_literals_[24] = + { + "bundleid", + "is_admin", + "do_not_fragment", + "priority", + "custody_requested", + "local_custody", + "singleton_dest", + "custody_rcpt", + "receive_rcpt", + "forward_rcpt", + "delivery_rcpt", + "deletion_rcpt", + "app_acked_rcpt", + "expiration", + "orig_length", + "owner", + "source", + "dest", + "custodian", + "replyto", + "prevhop", + "location", + "payload_file", + "meta_block_list" + }; + + const bundleAttributesSimpleQueryType::_xsd_bundleAttributesSimpleQueryType bundleAttributesSimpleQueryType:: + _xsd_bundleAttributesSimpleQueryType_indexes_[24] = + { + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::app_acked_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::bundleid, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::custodian, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::custody_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::custody_requested, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::deletion_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::delivery_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::dest, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::do_not_fragment, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::expiration, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::forward_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::is_admin, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::local_custody, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::location, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::meta_block_list, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::orig_length, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::owner, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::payload_file, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::prevhop, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::priority, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::receive_rcpt, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::replyto, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::singleton_dest, + ::dtn::rtrmessage::bundleAttributesSimpleQueryType::source + }; + + // bundleMetaBlockQueryType + // + + bundleMetaBlockQueryType:: + bundleMetaBlockQueryType () + : ::xml_schema::type (), + _xsd_type_ (::xml_schema::flags (), this), + _xsd_identifier_ (::xml_schema::flags (), this) + { + } + + bundleMetaBlockQueryType:: + bundleMetaBlockQueryType (const bundleMetaBlockQueryType& _xsd_bundleMetaBlockQueryType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundleMetaBlockQueryType, f, c), + _xsd_type_ (_xsd_bundleMetaBlockQueryType._xsd_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_identifier_ (_xsd_bundleMetaBlockQueryType._xsd_identifier_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundleMetaBlockQueryType:: + bundleMetaBlockQueryType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_identifier_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundleMetaBlockQueryType:: + 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 ()); + + // type + // + { + if (e.name () == "type" && e.namespace_ ().empty ()) + { + if (this->type ()) + continue; + this->type ( + type::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + // identifier + // + { + if (e.name () == "identifier" && e.namespace_ ().empty ()) + { + if (this->identifier ()) + continue; + this->identifier ( + identifier::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + } + } + + bundleMetaBlockQueryType* bundleMetaBlockQueryType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleMetaBlockQueryType (*this, f, c); + } + + // bundleAttributesQueryType + // + + bundleAttributesQueryType:: + bundleAttributesQueryType () + : ::xml_schema::type (), + _xsd_query_ (::xml_schema::flags (), this), + _xsd_meta_blocks_ (::xml_schema::flags (), this) + { + } + + bundleAttributesQueryType:: + bundleAttributesQueryType (const bundleAttributesQueryType& _xsd_bundleAttributesQueryType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundleAttributesQueryType, f, c), + _xsd_query_ (_xsd_bundleAttributesQueryType._xsd_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_meta_blocks_ (_xsd_bundleAttributesQueryType._xsd_meta_blocks_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundleAttributesQueryType:: + bundleAttributesQueryType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_meta_blocks_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundleAttributesQueryType:: + 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 ()); + + // query + // + { + if (e.name () == "query" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query::type > r ( + query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->query ()) + continue; + this->query (r); + continue; + } + } + + // meta_blocks + // + { + if (e.name () == "meta_blocks" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< meta_blocks::type > r ( + meta_blocks::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->meta_blocks ()) + continue; + this->meta_blocks (r); + continue; + } + } + } + } + + bundleAttributesQueryType* bundleAttributesQueryType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleAttributesQueryType (*this, f, c); + } + + // metadataBlockType + // + + metadataBlockType:: + metadataBlockType () + : ::xml_schema::type (), + _xsd_identifier_ (::xml_schema::flags (), this), + _xsd_generated_ (::xml_schema::flags (), this), + _xsd_type_ (::xml_schema::flags (), this), + _xsd_contents_ (::xml_schema::flags (), this) + { + } + + metadataBlockType:: + metadataBlockType (const identifier::type& _xsd_identifier, + const generated::type& _xsd_generated, + const type::type_& _xsd_type, + const contents::type& _xsd_contents) + : ::xml_schema::type (), + _xsd_identifier_ (_xsd_identifier, + ::xml_schema::flags (), + this), + _xsd_generated_ (_xsd_generated, + ::xml_schema::flags (), + this), + _xsd_type_ (_xsd_type, + ::xml_schema::flags (), + this), + _xsd_contents_ (_xsd_contents, + ::xml_schema::flags (), + this) + { + } + + metadataBlockType:: + metadataBlockType (const metadataBlockType& _xsd_metadataBlockType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_metadataBlockType, f, c), + _xsd_identifier_ (_xsd_metadataBlockType._xsd_identifier_, + f | ::xml_schema::flags::not_root, + this), + _xsd_generated_ (_xsd_metadataBlockType._xsd_generated_, + f | ::xml_schema::flags::not_root, + this), + _xsd_type_ (_xsd_metadataBlockType._xsd_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contents_ (_xsd_metadataBlockType._xsd_contents_, + f | ::xml_schema::flags::not_root, + this) + { + } + + metadataBlockType:: + metadataBlockType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_identifier_ (f | ::xml_schema::flags::not_root, this), + _xsd_generated_ (f | ::xml_schema::flags::not_root, this), + _xsd_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_contents_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void metadataBlockType:: + 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 () == "identifier" && a.namespace_ ().empty ()) + { + this->identifier ( + identifier::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "generated" && a.namespace_ ().empty ()) + { + this->generated ( + generated::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "type" && a.namespace_ ().empty ()) + { + this->type ( + type::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "contents" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< contents::type > r ( + contents::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->contents (r); + continue; + } + } + + if (!_xsd_identifier_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "identifier", + ""); + } + + if (!_xsd_generated_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "generated", + ""); + } + + if (!_xsd_type_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "type", + ""); + } + + if (!_xsd_contents_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "contents", + ""); + } + } + + metadataBlockType* metadataBlockType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new metadataBlockType (*this, f, c); + } + + // bundleAttributesReportType + // + + bundleAttributesReportType:: + bundleAttributesReportType () + : ::xml_schema::type (), + _xsd_dest_ (::xml_schema::flags (), this), + _xsd_custodian_ (::xml_schema::flags (), this), + _xsd_replyto_ (::xml_schema::flags (), this), + _xsd_prevhop_ (::xml_schema::flags (), this), + _xsd_meta_blocks_ (::xml_schema::flags (), this), + _xsd_bundleid_ (::xml_schema::flags (), this), + _xsd_is_admin_ (::xml_schema::flags (), this), + _xsd_do_not_fragment_ (::xml_schema::flags (), this), + _xsd_priority_ (::xml_schema::flags (), this), + _xsd_custody_requested_ (::xml_schema::flags (), this), + _xsd_local_custody_ (::xml_schema::flags (), this), + _xsd_singleton_dest_ (::xml_schema::flags (), this), + _xsd_custody_rcpt_ (::xml_schema::flags (), this), + _xsd_receive_rcpt_ (::xml_schema::flags (), this), + _xsd_forward_rcpt_ (::xml_schema::flags (), this), + _xsd_delivery_rcpt_ (::xml_schema::flags (), this), + _xsd_deletion_rcpt_ (::xml_schema::flags (), this), + _xsd_app_acked_rcpt_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this), + _xsd_orig_length_ (::xml_schema::flags (), this), + _xsd_owner_ (::xml_schema::flags (), this), + _xsd_location_ (::xml_schema::flags (), this), + _xsd_payload_file_ (::xml_schema::flags (), this) + { + } + + bundleAttributesReportType:: + bundleAttributesReportType (const bundleAttributesReportType& _xsd_bundleAttributesReportType, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundleAttributesReportType, f, c), + _xsd_dest_ (_xsd_bundleAttributesReportType._xsd_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custodian_ (_xsd_bundleAttributesReportType._xsd_custodian_, + f | ::xml_schema::flags::not_root, + this), + _xsd_replyto_ (_xsd_bundleAttributesReportType._xsd_replyto_, + f | ::xml_schema::flags::not_root, + this), + _xsd_prevhop_ (_xsd_bundleAttributesReportType._xsd_prevhop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_meta_blocks_ (_xsd_bundleAttributesReportType._xsd_meta_blocks_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundleid_ (_xsd_bundleAttributesReportType._xsd_bundleid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_is_admin_ (_xsd_bundleAttributesReportType._xsd_is_admin_, + f | ::xml_schema::flags::not_root, + this), + _xsd_do_not_fragment_ (_xsd_bundleAttributesReportType._xsd_do_not_fragment_, + f | ::xml_schema::flags::not_root, + this), + _xsd_priority_ (_xsd_bundleAttributesReportType._xsd_priority_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_requested_ (_xsd_bundleAttributesReportType._xsd_custody_requested_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_custody_ (_xsd_bundleAttributesReportType._xsd_local_custody_, + f | ::xml_schema::flags::not_root, + this), + _xsd_singleton_dest_ (_xsd_bundleAttributesReportType._xsd_singleton_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_rcpt_ (_xsd_bundleAttributesReportType._xsd_custody_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_receive_rcpt_ (_xsd_bundleAttributesReportType._xsd_receive_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_forward_rcpt_ (_xsd_bundleAttributesReportType._xsd_forward_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_delivery_rcpt_ (_xsd_bundleAttributesReportType._xsd_delivery_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_deletion_rcpt_ (_xsd_bundleAttributesReportType._xsd_deletion_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_app_acked_rcpt_ (_xsd_bundleAttributesReportType._xsd_app_acked_rcpt_, + f | ::xml_schema::flags::not_root, + this), + _xsd_expiration_ (_xsd_bundleAttributesReportType._xsd_expiration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_orig_length_ (_xsd_bundleAttributesReportType._xsd_orig_length_, + f | ::xml_schema::flags::not_root, + this), + _xsd_owner_ (_xsd_bundleAttributesReportType._xsd_owner_, + f | ::xml_schema::flags::not_root, + this), + _xsd_location_ (_xsd_bundleAttributesReportType._xsd_location_, + f | ::xml_schema::flags::not_root, + this), + _xsd_payload_file_ (_xsd_bundleAttributesReportType._xsd_payload_file_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundleAttributesReportType:: + bundleAttributesReportType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_custodian_ (f | ::xml_schema::flags::not_root, this), + _xsd_replyto_ (f | ::xml_schema::flags::not_root, this), + _xsd_prevhop_ (f | ::xml_schema::flags::not_root, this), + _xsd_meta_blocks_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundleid_ (f | ::xml_schema::flags::not_root, this), + _xsd_is_admin_ (f | ::xml_schema::flags::not_root, this), + _xsd_do_not_fragment_ (f | ::xml_schema::flags::not_root, this), + _xsd_priority_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_requested_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_custody_ (f | ::xml_schema::flags::not_root, this), + _xsd_singleton_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_receive_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_forward_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_delivery_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_deletion_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_app_acked_rcpt_ (f | ::xml_schema::flags::not_root, this), + _xsd_expiration_ (f | ::xml_schema::flags::not_root, this), + _xsd_orig_length_ (f | ::xml_schema::flags::not_root, this), + _xsd_owner_ (f | ::xml_schema::flags::not_root, this), + _xsd_location_ (f | ::xml_schema::flags::not_root, this), + _xsd_payload_file_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundleAttributesReportType:: + 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 ()); + + // dest + // + { + if (e.name () == "dest" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest::type > r ( + dest::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->dest ()) + continue; + this->dest (r); + continue; + } + } + + // custodian + // + { + if (e.name () == "custodian" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< custodian::type > r ( + custodian::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->custodian ()) + continue; + this->custodian (r); + continue; + } + } + + // replyto + // + { + if (e.name () == "replyto" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< replyto::type > r ( + replyto::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->replyto ()) + continue; + this->replyto (r); + continue; + } + } + + // prevhop + // + { + if (e.name () == "prevhop" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< prevhop::type > r ( + prevhop::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->prevhop ()) + continue; + this->prevhop (r); + continue; + } + } + + // meta_blocks + // + { + if (e.name () == "meta_blocks" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< meta_blocks::type > r ( + meta_blocks::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->meta_blocks ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "bundleid" && a.namespace_ ().empty ()) + { + this->bundleid ( + bundleid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "is_admin" && a.namespace_ ().empty ()) + { + this->is_admin ( + is_admin::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "do_not_fragment" && a.namespace_ ().empty ()) + { + this->do_not_fragment ( + do_not_fragment::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "priority" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< priority::type > r ( + priority::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->priority (r); + continue; + } + + if (a.name () == "custody_requested" && a.namespace_ ().empty ()) + { + this->custody_requested ( + custody_requested::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "local_custody" && a.namespace_ ().empty ()) + { + this->local_custody ( + local_custody::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "singleton_dest" && a.namespace_ ().empty ()) + { + this->singleton_dest ( + singleton_dest::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "custody_rcpt" && a.namespace_ ().empty ()) + { + this->custody_rcpt ( + custody_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "receive_rcpt" && a.namespace_ ().empty ()) + { + this->receive_rcpt ( + receive_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "forward_rcpt" && a.namespace_ ().empty ()) + { + this->forward_rcpt ( + forward_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "delivery_rcpt" && a.namespace_ ().empty ()) + { + this->delivery_rcpt ( + delivery_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "deletion_rcpt" && a.namespace_ ().empty ()) + { + this->deletion_rcpt ( + deletion_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "app_acked_rcpt" && a.namespace_ ().empty ()) + { + this->app_acked_rcpt ( + app_acked_rcpt::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "expiration" && a.namespace_ ().empty ()) + { + this->expiration ( + expiration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "orig_length" && a.namespace_ ().empty ()) + { + this->orig_length ( + orig_length::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "owner" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< owner::type > r ( + owner::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->owner (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 (a.name () == "payload_file" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< payload_file::type > r ( + payload_file::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->payload_file (r); + continue; + } + } + } + + bundleAttributesReportType* bundleAttributesReportType:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundleAttributesReportType (*this, f, c); + } + + // bundle_received_event + // + + bundle_received_event:: + bundle_received_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_dest_ (::xml_schema::flags (), this), + _xsd_custodian_ (::xml_schema::flags (), this), + _xsd_replyto_ (::xml_schema::flags (), this), + _xsd_prevhop_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this), + _xsd_bytes_received_ (::xml_schema::flags (), this), + _xsd_num_meta_blocks_ (::xml_schema::flags (), this) + { + } + + bundle_received_event:: + bundle_received_event (const gbof_id::type& _xsd_gbof_id, + const dest::type& _xsd_dest, + const custodian::type& _xsd_custodian, + const replyto::type& _xsd_replyto, + const local_id::type& _xsd_local_id, + const expiration::type& _xsd_expiration, + const bytes_received::type& _xsd_bytes_received) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_dest_ (_xsd_dest, + ::xml_schema::flags (), + this), + _xsd_custodian_ (_xsd_custodian, + ::xml_schema::flags (), + this), + _xsd_replyto_ (_xsd_replyto, + ::xml_schema::flags (), + this), + _xsd_prevhop_ (::xml_schema::flags (), this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this), + _xsd_expiration_ (_xsd_expiration, + ::xml_schema::flags (), + this), + _xsd_bytes_received_ (_xsd_bytes_received, + ::xml_schema::flags (), + this), + _xsd_num_meta_blocks_ (::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_gbof_id_ (_xsd_bundle_received_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_dest_ (_xsd_bundle_received_event._xsd_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custodian_ (_xsd_bundle_received_event._xsd_custodian_, + f | ::xml_schema::flags::not_root, + this), + _xsd_replyto_ (_xsd_bundle_received_event._xsd_replyto_, + f | ::xml_schema::flags::not_root, + this), + _xsd_prevhop_ (_xsd_bundle_received_event._xsd_prevhop_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_received_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_expiration_ (_xsd_bundle_received_event._xsd_expiration_, + 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_num_meta_blocks_ (_xsd_bundle_received_event._xsd_num_meta_blocks_, + 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_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_custodian_ (f | ::xml_schema::flags::not_root, this), + _xsd_replyto_ (f | ::xml_schema::flags::not_root, this), + _xsd_prevhop_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_expiration_ (f | ::xml_schema::flags::not_root, this), + _xsd_bytes_received_ (f | ::xml_schema::flags::not_root, this), + _xsd_num_meta_blocks_ (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_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // dest + // + { + if (e.name () == "dest" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest::type > r ( + dest::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_dest_.present ()) + continue; + this->dest (r); + continue; + } + } + + // custodian + // + { + if (e.name () == "custodian" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< custodian::type > r ( + custodian::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_custodian_.present ()) + continue; + this->custodian (r); + continue; + } + } + + // replyto + // + { + if (e.name () == "replyto" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< replyto::type > r ( + replyto::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_replyto_.present ()) + continue; + this->replyto (r); + continue; + } + } + + // prevhop + // + { + if (e.name () == "prevhop" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< prevhop::type > r ( + prevhop::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->prevhop ()) + continue; + this->prevhop (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + if (!_xsd_dest_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "dest", + ""); + } + + if (!_xsd_custodian_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "custodian", + ""); + } + + if (!_xsd_replyto_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "replyto", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "expiration" && a.namespace_ ().empty ()) + { + this->expiration ( + expiration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + 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 () == "num_meta_blocks" && a.namespace_ ().empty ()) + { + this->num_meta_blocks ( + num_meta_blocks::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + + if (!_xsd_expiration_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "expiration", + ""); + } + + 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); + } + + // data_transmitted_event + // + + data_transmitted_event:: + data_transmitted_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_bytes_sent_ (::xml_schema::flags (), this), + _xsd_reliably_sent_ (::xml_schema::flags (), this) + { + } + + data_transmitted_event:: + data_transmitted_event (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id, + const link_id::type& _xsd_link_id, + const bytes_sent::type& _xsd_bytes_sent, + const reliably_sent::type& _xsd_reliably_sent) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_bytes_sent_ (_xsd_bytes_sent, + ::xml_schema::flags (), + this), + _xsd_reliably_sent_ (_xsd_reliably_sent, + ::xml_schema::flags (), + this) + { + } + + data_transmitted_event:: + data_transmitted_event (const data_transmitted_event& _xsd_data_transmitted_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_data_transmitted_event, f, c), + _xsd_gbof_id_ (_xsd_data_transmitted_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_data_transmitted_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_data_transmitted_event._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bytes_sent_ (_xsd_data_transmitted_event._xsd_bytes_sent_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reliably_sent_ (_xsd_data_transmitted_event._xsd_reliably_sent_, + f | ::xml_schema::flags::not_root, + this) + { + } + + data_transmitted_event:: + data_transmitted_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (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 data_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + 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", + ""); + } + } + + data_transmitted_event* data_transmitted_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new data_transmitted_event (*this, f, c); + } + + // bundle_delivered_event + // + + bundle_delivered_event:: + bundle_delivered_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_delivered_event:: + bundle_delivered_event (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_delivered_event:: + bundle_delivered_event (const bundle_delivered_event& _xsd_bundle_delivered_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_delivered_event, f, c), + _xsd_gbof_id_ (_xsd_bundle_delivered_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_delivered_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_delivered_event:: + bundle_delivered_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_delivered_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_delivered_event* bundle_delivered_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_delivered_event (*this, f, c); + } + + // bundle_delivery_event + // + + bundle_delivery_event:: + bundle_delivery_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_bundle_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_delivery_event:: + bundle_delivery_event (const gbof_id::type& _xsd_gbof_id, + const bundle::type& _xsd_bundle, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_bundle_ (_xsd_bundle, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_delivery_event:: + bundle_delivery_event (const bundle_delivery_event& _xsd_bundle_delivery_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_delivery_event, f, c), + _xsd_gbof_id_ (_xsd_bundle_delivery_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_ (_xsd_bundle_delivery_event._xsd_bundle_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_delivery_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_delivery_event:: + bundle_delivery_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_delivery_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // bundle + // + { + if (e.name () == "bundle" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< bundle::type > r ( + bundle::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_bundle_.present ()) + continue; + this->bundle (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + if (!_xsd_bundle_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "bundle", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_delivery_event* bundle_delivery_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_delivery_event (*this, f, c); + } + + // bundle_send_cancelled_event + // + + bundle_send_cancelled_event:: + bundle_send_cancelled_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_send_cancelled_event:: + bundle_send_cancelled_event (const gbof_id::type& _xsd_gbof_id, + const link_id::type& _xsd_link_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_send_cancelled_event:: + bundle_send_cancelled_event (const bundle_send_cancelled_event& _xsd_bundle_send_cancelled_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_send_cancelled_event, f, c), + _xsd_gbof_id_ (_xsd_bundle_send_cancelled_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_bundle_send_cancelled_event._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_send_cancelled_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_send_cancelled_event:: + bundle_send_cancelled_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_send_cancelled_event:: + parse (const ::xercesc::DOMElement& e, ::xml_schema::flags f) + { + ::xsd::cxx::xml::dom::parser< char > p (e); + + while (p.more_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // link_id + // + { + if (e.name () == "link_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_id_.present ()) + continue; + this->link_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_send_cancelled_event* bundle_send_cancelled_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_send_cancelled_event (*this, f, c); + } + + // bundle_expired_event + // + + bundle_expired_event:: + bundle_expired_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_expired_event:: + bundle_expired_event (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_expired_event:: + bundle_expired_event (const bundle_expired_event& _xsd_bundle_expired_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_expired_event, f, c), + _xsd_gbof_id_ (_xsd_bundle_expired_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_expired_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_expired_event:: + bundle_expired_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_expired_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_expired_event* bundle_expired_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_expired_event (*this, f, c); + } + + // bundle_injected_event + // + + bundle_injected_event:: + bundle_injected_event () + : ::xml_schema::type (), + _xsd_request_id_ (::xml_schema::flags (), this), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_injected_event:: + bundle_injected_event (const request_id::type& _xsd_request_id, + const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_request_id_ (_xsd_request_id, + ::xml_schema::flags (), + this), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_injected_event:: + bundle_injected_event (const bundle_injected_event& _xsd_bundle_injected_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_injected_event, f, c), + _xsd_request_id_ (_xsd_bundle_injected_event._xsd_request_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_gbof_id_ (_xsd_bundle_injected_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_injected_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_injected_event:: + bundle_injected_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_request_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_injected_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 ()); + + // request_id + // + { + if (e.name () == "request_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< request_id::type > r ( + request_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_request_id_.present ()) + continue; + this->request_id (r); + continue; + } + } + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_request_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "request_id", + ""); + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_injected_event* bundle_injected_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_injected_event (*this, f, c); + } + + // link_opened_event + // + + link_opened_event:: + link_opened_event () + : ::xml_schema::type (), + _xsd_contact_attr_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + link_opened_event:: + link_opened_event (const contact_attr::type& _xsd_contact_attr, + const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_contact_attr_ (_xsd_contact_attr, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::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_attr_ (_xsd_link_opened_event._xsd_contact_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_link_opened_event._xsd_link_id_, + 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_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (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_attr + // + { + if (e.name () == "contact_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< contact_attr::type > r ( + contact_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attr_.present ()) + continue; + this->contact_attr (r); + continue; + } + } + } + + if (!_xsd_contact_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + 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_closed_event + // + + link_closed_event:: + link_closed_event () + : ::xml_schema::type (), + _xsd_contact_attr_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_closed_event:: + link_closed_event (const contact_attr::type& _xsd_contact_attr, + const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_contact_attr_ (_xsd_contact_attr, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::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_attr_ (_xsd_link_closed_event._xsd_contact_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_link_closed_event._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_closed_event._xsd_reason_, + 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_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (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_attr + // + { + if (e.name () == "contact_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< contact_attr::type > r ( + contact_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attr_.present ()) + continue; + this->contact_attr (r); + continue; + } + } + } + + if (!_xsd_contact_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + 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_created_event + // + + link_created_event:: + link_created_event () + : ::xml_schema::type (), + _xsd_link_attr_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_created_event:: + link_created_event (const link_attr::type& _xsd_link_attr, + const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_attr_ (_xsd_link_attr, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::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_attr_ (_xsd_link_created_event._xsd_link_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_link_created_event._xsd_link_id_, + 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_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (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_attr + // + { + if (e.name () == "link_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_attr::type > r ( + link_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_attr_.present ()) + continue; + this->link_attr (r); + continue; + } + } + } + + if (!_xsd_link_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + 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_deleted_event + // + + link_deleted_event:: + link_deleted_event () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_deleted_event:: + link_deleted_event (const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::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_id_ (_xsd_link_deleted_event._xsd_link_id_, + 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_id_ (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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + 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_available_event + // + + link_available_event:: + link_available_event () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_available_event:: + link_available_event (const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_available_event:: + link_available_event (const link_available_event& _xsd_link_available_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_available_event, f, c), + _xsd_link_id_ (_xsd_link_available_event._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_available_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_available_event:: + link_available_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_available_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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_available_event* link_available_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_available_event (*this, f, c); + } + + // link_unavailable_event + // + + link_unavailable_event:: + link_unavailable_event () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_unavailable_event:: + link_unavailable_event (const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_reason_ (_xsd_reason, + ::xml_schema::flags (), + this) + { + } + + link_unavailable_event:: + link_unavailable_event (const link_unavailable_event& _xsd_link_unavailable_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_unavailable_event, f, c), + _xsd_link_id_ (_xsd_link_unavailable_event._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reason_ (_xsd_link_unavailable_event._xsd_reason_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_unavailable_event:: + link_unavailable_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_reason_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_unavailable_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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_reason_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "reason", + ""); + } + } + + link_unavailable_event* link_unavailable_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_unavailable_event (*this, f, c); + } + + // link_attribute_changed_event + // + + link_attribute_changed_event:: + link_attribute_changed_event () + : ::xml_schema::type (), + _xsd_link_attr_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + link_attribute_changed_event:: + link_attribute_changed_event (const link_attr::type& _xsd_link_attr, + const link_id::type& _xsd_link_id, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_link_attr_ (_xsd_link_attr, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::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_attr_ (_xsd_link_attribute_changed_event._xsd_link_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_link_attribute_changed_event._xsd_link_id_, + 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_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (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_attr + // + { + if (e.name () == "link_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_attr::type > r ( + link_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_attr_.present ()) + continue; + this->link_attr (r); + continue; + } + } + } + + if (!_xsd_link_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (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_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + 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_eid_ (::xml_schema::flags (), this), + _xsd_contact_attr_ (::xml_schema::flags (), this), + _xsd_reason_ (::xml_schema::flags (), this) + { + } + + contact_attribute_changed_event:: + contact_attribute_changed_event (const contact_eid::type& _xsd_contact_eid, + const contact_attr::type& _xsd_contact_attr, + const reason::type& _xsd_reason) + : ::xml_schema::type (), + _xsd_contact_eid_ (_xsd_contact_eid, + ::xml_schema::flags (), + this), + _xsd_contact_attr_ (_xsd_contact_attr, + ::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_eid_ (_xsd_contact_attribute_changed_event._xsd_contact_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contact_attr_ (_xsd_contact_attribute_changed_event._xsd_contact_attr_, + 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_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_contact_attr_ (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_eid + // + { + if (e.name () == "contact_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< contact_eid::type > r ( + contact_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_eid_.present ()) + continue; + this->contact_eid (r); + continue; + } + } + + // contact_attr + // + { + if (e.name () == "contact_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< contact_attr::type > r ( + contact_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_contact_attr_.present ()) + continue; + this->contact_attr (r); + continue; + } + } + } + + if (!_xsd_contact_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_eid", + ""); + } + + if (!_xsd_contact_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "contact_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + 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_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_busy_event + // + + link_busy_event:: + link_busy_event () + : ::xml_schema::type (), + _xsd_link_ (::xml_schema::flags (), this) + { + } + + link_busy_event:: + link_busy_event (const link::type& _xsd_link) + : ::xml_schema::type (), + _xsd_link_ (_xsd_link, + ::xml_schema::flags (), + this) + { + } + + link_busy_event:: + link_busy_event (const link_busy_event& _xsd_link_busy_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_busy_event, f, c), + _xsd_link_ (_xsd_link_busy_event._xsd_link_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_busy_event:: + link_busy_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_busy_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 + // + { + if (e.name () == "link" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link::type > r ( + link::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_.present ()) + continue; + this->link (r); + continue; + } + } + } + + if (!_xsd_link_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link", + ""); + } + } + + link_busy_event* link_busy_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_busy_event (*this, f, c); + } + + // eid_reachable_event + // + + eid_reachable_event:: + eid_reachable_event () + : ::xml_schema::type (), + _xsd_peer_eid_ (::xml_schema::flags (), this), + _xsd_interface_name_ (::xml_schema::flags (), this) + { + } + + eid_reachable_event:: + eid_reachable_event (const peer_eid::type& _xsd_peer_eid, + const interface_name::type& _xsd_interface_name) + : ::xml_schema::type (), + _xsd_peer_eid_ (_xsd_peer_eid, + ::xml_schema::flags (), + this), + _xsd_interface_name_ (_xsd_interface_name, + ::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_peer_eid_ (_xsd_eid_reachable_event._xsd_peer_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_interface_name_ (_xsd_eid_reachable_event._xsd_interface_name_, + 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_peer_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_interface_name_ (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_elements ()) + { + const ::xsd::cxx::xml::dom::element< char > e (p.next_element ()); + + // peer_eid + // + { + if (e.name () == "peer_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< peer_eid::type > r ( + peer_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_peer_eid_.present ()) + continue; + this->peer_eid (r); + continue; + } + } + } + + if (!_xsd_peer_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "peer_eid", + ""); + } + + 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", + ""); + } + } + + eid_reachable_event* eid_reachable_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new eid_reachable_event (*this, f, c); + } + + // route_add_event + // + + route_add_event:: + route_add_event () + : ::xml_schema::type (), + _xsd_route_entry_ (::xml_schema::flags (), this) + { + } + + route_add_event:: + route_add_event (const route_entry::type& _xsd_route_entry) + : ::xml_schema::type (), + _xsd_route_entry_ (_xsd_route_entry, + ::xml_schema::flags (), + this) + { + } + + route_add_event:: + route_add_event (const route_add_event& _xsd_route_add_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_route_add_event, f, c), + _xsd_route_entry_ (_xsd_route_add_event._xsd_route_entry_, + f | ::xml_schema::flags::not_root, + this) + { + } + + route_add_event:: + route_add_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_route_entry_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void route_add_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 ()); + + // route_entry + // + { + if (e.name () == "route_entry" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< route_entry::type > r ( + route_entry::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_route_entry_.present ()) + continue; + this->route_entry (r); + continue; + } + } + } + + if (!_xsd_route_entry_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "route_entry", + ""); + } + } + + route_add_event* route_add_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new route_add_event (*this, f, c); + } + + // route_delete_event + // + + route_delete_event:: + route_delete_event () + : ::xml_schema::type (), + _xsd_dest_ (::xml_schema::flags (), this) + { + } + + route_delete_event:: + route_delete_event (const dest::type& _xsd_dest) + : ::xml_schema::type (), + _xsd_dest_ (_xsd_dest, + ::xml_schema::flags (), + this) + { + } + + route_delete_event:: + route_delete_event (const route_delete_event& _xsd_route_delete_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_route_delete_event, f, c), + _xsd_dest_ (_xsd_route_delete_event._xsd_dest_, + f | ::xml_schema::flags::not_root, + this) + { + } + + route_delete_event:: + route_delete_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_dest_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void route_delete_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 ()); + + // dest + // + { + if (e.name () == "dest" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest::type > r ( + dest::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_dest_.present ()) + continue; + this->dest (r); + continue; + } + } + } + + if (!_xsd_dest_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "dest", + ""); + } + } + + route_delete_event* route_delete_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new route_delete_event (*this, f, c); + } + + // custody_signal_event + // + + custody_signal_event:: + custody_signal_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_custody_signal_attr_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + custody_signal_event:: + custody_signal_event (const gbof_id::type& _xsd_gbof_id, + const custody_signal_attr::type& _xsd_custody_signal_attr, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_custody_signal_attr_ (_xsd_custody_signal_attr, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + custody_signal_event:: + custody_signal_event (const custody_signal_event& _xsd_custody_signal_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_custody_signal_event, f, c), + _xsd_gbof_id_ (_xsd_custody_signal_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_signal_attr_ (_xsd_custody_signal_event._xsd_custody_signal_attr_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_custody_signal_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + custody_signal_event:: + custody_signal_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_signal_attr_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void custody_signal_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // custody_signal_attr + // + { + if (e.name () == "custody_signal_attr" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< custody_signal_attr::type > r ( + custody_signal_attr::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_custody_signal_attr_.present ()) + continue; + this->custody_signal_attr (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + if (!_xsd_custody_signal_attr_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "custody_signal_attr", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + custody_signal_event* custody_signal_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new custody_signal_event (*this, f, c); + } + + // custody_timeout_event + // + + custody_timeout_event:: + custody_timeout_event () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + custody_timeout_event:: + custody_timeout_event (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + custody_timeout_event:: + custody_timeout_event (const custody_timeout_event& _xsd_custody_timeout_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_custody_timeout_event, f, c), + _xsd_gbof_id_ (_xsd_custody_timeout_event._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_custody_timeout_event._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + custody_timeout_event:: + custody_timeout_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void custody_timeout_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + custody_timeout_event* custody_timeout_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new custody_timeout_event (*this, f, c); + } + + // intentional_name_resolved_event + // + + intentional_name_resolved_event:: + intentional_name_resolved_event () + : ::xml_schema::type (), + _xsd_request_id_ (::xml_schema::flags (), this), + _xsd_response_id_ (::xml_schema::flags (), this), + _xsd_router_eid_ (::xml_schema::flags (), this), + _xsd_lb_dp_eid_ (::xml_schema::flags (), this), + _xsd_intentional_name_ (::xml_schema::flags (), this), + _xsd_grain_state_ (::xml_schema::flags (), this), + _xsd_canonical_eids_ (::xml_schema::flags (), this), + _xsd_app_eids_ (::xml_schema::flags (), this) + { + } + + intentional_name_resolved_event:: + intentional_name_resolved_event (const request_id::type& _xsd_request_id, + const response_id::type& _xsd_response_id, + const router_eid::type& _xsd_router_eid, + const intentional_name::type& _xsd_intentional_name, + const grain_state::type& _xsd_grain_state) + : ::xml_schema::type (), + _xsd_request_id_ (_xsd_request_id, + ::xml_schema::flags (), + this), + _xsd_response_id_ (_xsd_response_id, + ::xml_schema::flags (), + this), + _xsd_router_eid_ (_xsd_router_eid, + ::xml_schema::flags (), + this), + _xsd_lb_dp_eid_ (::xml_schema::flags (), this), + _xsd_intentional_name_ (_xsd_intentional_name, + ::xml_schema::flags (), + this), + _xsd_grain_state_ (_xsd_grain_state, + ::xml_schema::flags (), + this), + _xsd_canonical_eids_ (::xml_schema::flags (), this), + _xsd_app_eids_ (::xml_schema::flags (), this) + { + } + + intentional_name_resolved_event:: + intentional_name_resolved_event (const intentional_name_resolved_event& _xsd_intentional_name_resolved_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_intentional_name_resolved_event, f, c), + _xsd_request_id_ (_xsd_intentional_name_resolved_event._xsd_request_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_response_id_ (_xsd_intentional_name_resolved_event._xsd_response_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_router_eid_ (_xsd_intentional_name_resolved_event._xsd_router_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_lb_dp_eid_ (_xsd_intentional_name_resolved_event._xsd_lb_dp_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_intentional_name_ (_xsd_intentional_name_resolved_event._xsd_intentional_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_grain_state_ (_xsd_intentional_name_resolved_event._xsd_grain_state_, + f | ::xml_schema::flags::not_root, + this), + _xsd_canonical_eids_ (_xsd_intentional_name_resolved_event._xsd_canonical_eids_, + f | ::xml_schema::flags::not_root, + this), + _xsd_app_eids_ (_xsd_intentional_name_resolved_event._xsd_app_eids_, + f | ::xml_schema::flags::not_root, + this) + { + } + + intentional_name_resolved_event:: + intentional_name_resolved_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_request_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_response_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_router_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_lb_dp_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_intentional_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_grain_state_ (f | ::xml_schema::flags::not_root, this), + _xsd_canonical_eids_ (f | ::xml_schema::flags::not_root, this), + _xsd_app_eids_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void intentional_name_resolved_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 ()); + + // request_id + // + { + if (e.name () == "request_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< request_id::type > r ( + request_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_request_id_.present ()) + continue; + this->request_id (r); + continue; + } + } + + // response_id + // + { + if (e.name () == "response_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< response_id::type > r ( + response_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_response_id_.present ()) + continue; + this->response_id (r); + continue; + } + } + + // router_eid + // + { + if (e.name () == "router_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< router_eid::type > r ( + router_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_router_eid_.present ()) + continue; + this->router_eid (r); + continue; + } + } + + // lb_dp_eid + // + { + if (e.name () == "lb_dp_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< lb_dp_eid::type > r ( + lb_dp_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->lb_dp_eid ()) + continue; + this->lb_dp_eid (r); + continue; + } + } + + // intentional_name + // + { + if (e.name () == "intentional_name" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< intentional_name::type > r ( + intentional_name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_intentional_name_.present ()) + continue; + this->intentional_name (r); + continue; + } + } + + // grain_state + // + { + if (e.name () == "grain_state" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< grain_state::type > r ( + grain_state::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_grain_state_.present ()) + continue; + this->grain_state (r); + continue; + } + } + + // canonical_eids + // + { + if (e.name () == "canonical_eids" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< canonical_eids::type > r ( + canonical_eids::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->canonical_eids ().push_back (r); + continue; + } + } + + // app_eids + // + { + if (e.name () == "app_eids" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< app_eids::type > r ( + app_eids::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->app_eids ().push_back (r); + continue; + } + } + } + + if (!_xsd_request_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "request_id", + ""); + } + + if (!_xsd_response_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "response_id", + ""); + } + + if (!_xsd_router_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "router_eid", + ""); + } + + if (!_xsd_intentional_name_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "intentional_name", + ""); + } + + if (!_xsd_grain_state_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "grain_state", + ""); + } + } + + intentional_name_resolved_event* intentional_name_resolved_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new intentional_name_resolved_event (*this, f, c); + } + + // registration_added_event + // + + registration_added_event:: + registration_added_event () + : ::xml_schema::type (), + _xsd_registration_ (::xml_schema::flags (), this), + _xsd_source_ (::xml_schema::flags (), this) + { + } + + registration_added_event:: + registration_added_event (const registration::type& _xsd_registration, + const source::type& _xsd_source) + : ::xml_schema::type (), + _xsd_registration_ (_xsd_registration, + ::xml_schema::flags (), + this), + _xsd_source_ (_xsd_source, + ::xml_schema::flags (), + this) + { + } + + registration_added_event:: + registration_added_event (const registration_added_event& _xsd_registration_added_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_registration_added_event, f, c), + _xsd_registration_ (_xsd_registration_added_event._xsd_registration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_source_ (_xsd_registration_added_event._xsd_source_, + f | ::xml_schema::flags::not_root, + this) + { + } + + registration_added_event:: + registration_added_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_registration_ (f | ::xml_schema::flags::not_root, this), + _xsd_source_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void registration_added_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 ()); + + // registration + // + { + if (e.name () == "registration" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< registration::type > r ( + registration::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_registration_.present ()) + continue; + this->registration (r); + continue; + } + } + } + + if (!_xsd_registration_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "registration", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "source" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< source::type > r ( + source::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->source (r); + continue; + } + } + + if (!_xsd_source_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "source", + ""); + } + } + + registration_added_event* registration_added_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new registration_added_event (*this, f, c); + } + + // registration_removed_event + // + + registration_removed_event:: + registration_removed_event () + : ::xml_schema::type (), + _xsd_registration_ (::xml_schema::flags (), this) + { + } + + registration_removed_event:: + registration_removed_event (const registration::type& _xsd_registration) + : ::xml_schema::type (), + _xsd_registration_ (_xsd_registration, + ::xml_schema::flags (), + this) + { + } + + registration_removed_event:: + registration_removed_event (const registration_removed_event& _xsd_registration_removed_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_registration_removed_event, f, c), + _xsd_registration_ (_xsd_registration_removed_event._xsd_registration_, + f | ::xml_schema::flags::not_root, + this) + { + } + + registration_removed_event:: + registration_removed_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_registration_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void registration_removed_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 ()); + + // registration + // + { + if (e.name () == "registration" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< registration::type > r ( + registration::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_registration_.present ()) + continue; + this->registration (r); + continue; + } + } + } + + if (!_xsd_registration_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "registration", + ""); + } + } + + registration_removed_event* registration_removed_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new registration_removed_event (*this, f, c); + } + + // registration_expired_event + // + + registration_expired_event:: + registration_expired_event () + : ::xml_schema::type (), + _xsd_regid_ (::xml_schema::flags (), this) + { + } + + registration_expired_event:: + registration_expired_event (const regid::type& _xsd_regid) + : ::xml_schema::type (), + _xsd_regid_ (_xsd_regid, + ::xml_schema::flags (), + this) + { + } + + registration_expired_event:: + registration_expired_event (const registration_expired_event& _xsd_registration_expired_event, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_registration_expired_event, f, c), + _xsd_regid_ (_xsd_registration_expired_event._xsd_regid_, + f | ::xml_schema::flags::not_root, + this) + { + } + + registration_expired_event:: + registration_expired_event (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_regid_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void registration_expired_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 () == "regid" && a.namespace_ ().empty ()) + { + this->regid ( + regid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_regid_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "regid", + ""); + } + } + + registration_expired_event* registration_expired_event:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new registration_expired_event (*this, f, c); + } + + // open_link_request + // + + open_link_request:: + open_link_request () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + open_link_request:: + open_link_request (const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this) + { + } + + open_link_request:: + open_link_request (const open_link_request& _xsd_open_link_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_open_link_request, f, c), + _xsd_link_id_ (_xsd_open_link_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + open_link_request:: + open_link_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void open_link_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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + open_link_request* open_link_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new open_link_request (*this, f, c); + } + + // close_link_request + // + + close_link_request:: + close_link_request () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + close_link_request:: + close_link_request (const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this) + { + } + + close_link_request:: + close_link_request (const close_link_request& _xsd_close_link_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_close_link_request, f, c), + _xsd_link_id_ (_xsd_close_link_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + close_link_request:: + close_link_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void close_link_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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + close_link_request* close_link_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new close_link_request (*this, f, c); + } + + // add_link_request + // + + add_link_request:: + add_link_request () + : ::xml_schema::type (), + _xsd_link_config_params_ (::xml_schema::flags (), this), + _xsd_remote_eid_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_link_type_ (::xml_schema::flags (), this), + _xsd_clayer_ (::xml_schema::flags (), this) + { + } + + add_link_request:: + add_link_request (const remote_eid::type& _xsd_remote_eid, + const link_id::type& _xsd_link_id, + const link_type::type& _xsd_link_type, + const clayer::type& _xsd_clayer) + : ::xml_schema::type (), + _xsd_link_config_params_ (::xml_schema::flags (), this), + _xsd_remote_eid_ (_xsd_remote_eid, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_link_type_ (_xsd_link_type, + ::xml_schema::flags (), + this), + _xsd_clayer_ (_xsd_clayer, + ::xml_schema::flags (), + this) + { + } + + add_link_request:: + add_link_request (const add_link_request& _xsd_add_link_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_add_link_request, f, c), + _xsd_link_config_params_ (_xsd_add_link_request._xsd_link_config_params_, + f | ::xml_schema::flags::not_root, + this), + _xsd_remote_eid_ (_xsd_add_link_request._xsd_remote_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_add_link_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_type_ (_xsd_add_link_request._xsd_link_type_, + f | ::xml_schema::flags::not_root, + this), + _xsd_clayer_ (_xsd_add_link_request._xsd_clayer_, + f | ::xml_schema::flags::not_root, + this) + { + } + + add_link_request:: + add_link_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_params_ (f | ::xml_schema::flags::not_root, this), + _xsd_remote_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_type_ (f | ::xml_schema::flags::not_root, this), + _xsd_clayer_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void add_link_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_params + // + { + if (e.name () == "link_config_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_config_params::type > r ( + link_config_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_config_params ()) + continue; + this->link_config_params (r); + continue; + } + } + + // remote_eid + // + { + if (e.name () == "remote_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< remote_eid::type > r ( + remote_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_remote_eid_.present ()) + continue; + this->remote_eid (r); + continue; + } + } + } + + if (!_xsd_remote_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "remote_eid", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + + if (a.name () == "link_type" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_type::type > r ( + link_type::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_type (r); + continue; + } + + if (a.name () == "clayer" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< clayer::type > r ( + clayer::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->clayer (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_link_type_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_type", + ""); + } + + if (!_xsd_clayer_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "clayer", + ""); + } + } + + add_link_request* add_link_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new add_link_request (*this, f, c); + } + + // delete_link_request + // + + delete_link_request:: + delete_link_request () + : ::xml_schema::type (), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + delete_link_request:: + delete_link_request (const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this) + { + } + + delete_link_request:: + delete_link_request (const delete_link_request& _xsd_delete_link_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_delete_link_request, f, c), + _xsd_link_id_ (_xsd_delete_link_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + delete_link_request:: + delete_link_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void delete_link_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_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + delete_link_request* delete_link_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new delete_link_request (*this, f, c); + } + + // reconfigure_link_request + // + + reconfigure_link_request:: + reconfigure_link_request () + : ::xml_schema::type (), + _xsd_link_config_params_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + reconfigure_link_request:: + reconfigure_link_request (const link_config_params::type& _xsd_link_config_params, + const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_link_config_params_ (_xsd_link_config_params, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this) + { + } + + reconfigure_link_request:: + reconfigure_link_request (const reconfigure_link_request& _xsd_reconfigure_link_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_reconfigure_link_request, f, c), + _xsd_link_config_params_ (_xsd_reconfigure_link_request._xsd_link_config_params_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_reconfigure_link_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + reconfigure_link_request:: + reconfigure_link_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_config_params_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void reconfigure_link_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_params + // + { + if (e.name () == "link_config_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_config_params::type > r ( + link_config_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_config_params_.present ()) + continue; + this->link_config_params (r); + continue; + } + } + } + + if (!_xsd_link_config_params_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_config_params", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + reconfigure_link_request* reconfigure_link_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new reconfigure_link_request (*this, f, c); + } + + // send_bundle_request + // + + send_bundle_request:: + send_bundle_request () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_metadata_block_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_fwd_action_ (::xml_schema::flags (), this), + _xsd_frag_size_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this) + { + } + + send_bundle_request:: + send_bundle_request (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id, + const link_id::type& _xsd_link_id, + const fwd_action::type& _xsd_fwd_action) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_metadata_block_ (::xml_schema::flags (), this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_fwd_action_ (_xsd_fwd_action, + ::xml_schema::flags (), + this), + _xsd_frag_size_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this) + { + } + + send_bundle_request:: + send_bundle_request (const send_bundle_request& _xsd_send_bundle_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_send_bundle_request, f, c), + _xsd_gbof_id_ (_xsd_send_bundle_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_metadata_block_ (_xsd_send_bundle_request._xsd_metadata_block_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_send_bundle_request._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_send_bundle_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_fwd_action_ (_xsd_send_bundle_request._xsd_fwd_action_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_size_ (_xsd_send_bundle_request._xsd_frag_size_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_offset_ (_xsd_send_bundle_request._xsd_frag_offset_, + f | ::xml_schema::flags::not_root, + this) + { + } + + send_bundle_request:: + send_bundle_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_metadata_block_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_fwd_action_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_size_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_offset_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void send_bundle_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // metadata_block + // + { + if (e.name () == "metadata_block" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< metadata_block::type > r ( + metadata_block::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->metadata_block ().push_back (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + + if (a.name () == "fwd_action" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< fwd_action::type > r ( + fwd_action::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->fwd_action (r); + continue; + } + + if (a.name () == "frag_size" && a.namespace_ ().empty ()) + { + this->frag_size ( + frag_size::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "frag_offset" && a.namespace_ ().empty ()) + { + this->frag_offset ( + frag_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_fwd_action_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "fwd_action", + ""); + } + } + + send_bundle_request* send_bundle_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new send_bundle_request (*this, f, c); + } + + // send_bundle_broadcast_request + // + + send_bundle_broadcast_request:: + send_bundle_broadcast_request () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_metadata_block_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this), + _xsd_fwd_action_ (::xml_schema::flags (), this), + _xsd_frag_size_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this) + { + } + + send_bundle_broadcast_request:: + send_bundle_broadcast_request (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id, + const fwd_action::type& _xsd_fwd_action) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_metadata_block_ (::xml_schema::flags (), this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this), + _xsd_fwd_action_ (_xsd_fwd_action, + ::xml_schema::flags (), + this), + _xsd_frag_size_ (::xml_schema::flags (), this), + _xsd_frag_offset_ (::xml_schema::flags (), this) + { + } + + send_bundle_broadcast_request:: + send_bundle_broadcast_request (const send_bundle_broadcast_request& _xsd_send_bundle_broadcast_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_send_bundle_broadcast_request, f, c), + _xsd_gbof_id_ (_xsd_send_bundle_broadcast_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_metadata_block_ (_xsd_send_bundle_broadcast_request._xsd_metadata_block_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_send_bundle_broadcast_request._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_fwd_action_ (_xsd_send_bundle_broadcast_request._xsd_fwd_action_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_size_ (_xsd_send_bundle_broadcast_request._xsd_frag_size_, + f | ::xml_schema::flags::not_root, + this), + _xsd_frag_offset_ (_xsd_send_bundle_broadcast_request._xsd_frag_offset_, + f | ::xml_schema::flags::not_root, + this) + { + } + + send_bundle_broadcast_request:: + send_bundle_broadcast_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_metadata_block_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_fwd_action_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_size_ (f | ::xml_schema::flags::not_root, this), + _xsd_frag_offset_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void send_bundle_broadcast_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // metadata_block + // + { + if (e.name () == "metadata_block" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< metadata_block::type > r ( + metadata_block::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->metadata_block ().push_back (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "fwd_action" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< fwd_action::type > r ( + fwd_action::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->fwd_action (r); + continue; + } + + if (a.name () == "frag_size" && a.namespace_ ().empty ()) + { + this->frag_size ( + frag_size::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "frag_offset" && a.namespace_ ().empty ()) + { + this->frag_offset ( + frag_offset::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + + if (!_xsd_fwd_action_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "fwd_action", + ""); + } + } + + send_bundle_broadcast_request* send_bundle_broadcast_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new send_bundle_broadcast_request (*this, f, c); + } + + // cancel_bundle_request + // + + cancel_bundle_request:: + cancel_bundle_request () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this) + { + } + + cancel_bundle_request:: + cancel_bundle_request (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id, + const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this) + { + } + + cancel_bundle_request:: + cancel_bundle_request (const cancel_bundle_request& _xsd_cancel_bundle_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_cancel_bundle_request, f, c), + _xsd_gbof_id_ (_xsd_cancel_bundle_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_cancel_bundle_request._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_cancel_bundle_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + cancel_bundle_request:: + cancel_bundle_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void cancel_bundle_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + } + + cancel_bundle_request* cancel_bundle_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new cancel_bundle_request (*this, f, c); + } + + // inject_bundle_request + // + + inject_bundle_request:: + inject_bundle_request () + : ::xml_schema::type (), + _xsd_source_ (::xml_schema::flags (), this), + _xsd_dest_ (::xml_schema::flags (), this), + _xsd_replyto_ (::xml_schema::flags (), this), + _xsd_custodian_ (::xml_schema::flags (), this), + _xsd_request_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_fwd_action_ (::xml_schema::flags (), this), + _xsd_priority_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this), + _xsd_payload_file_ (::xml_schema::flags (), this) + { + } + + inject_bundle_request:: + inject_bundle_request (const source::type& _xsd_source, + const dest::type& _xsd_dest, + const request_id::type& _xsd_request_id, + const link_id::type& _xsd_link_id, + const payload_file::type& _xsd_payload_file) + : ::xml_schema::type (), + _xsd_source_ (_xsd_source, + ::xml_schema::flags (), + this), + _xsd_dest_ (_xsd_dest, + ::xml_schema::flags (), + this), + _xsd_replyto_ (::xml_schema::flags (), this), + _xsd_custodian_ (::xml_schema::flags (), this), + _xsd_request_id_ (_xsd_request_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_fwd_action_ (::xml_schema::flags (), this), + _xsd_priority_ (::xml_schema::flags (), this), + _xsd_expiration_ (::xml_schema::flags (), this), + _xsd_payload_file_ (_xsd_payload_file, + ::xml_schema::flags (), + this) + { + } + + inject_bundle_request:: + inject_bundle_request (const inject_bundle_request& _xsd_inject_bundle_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_inject_bundle_request, f, c), + _xsd_source_ (_xsd_inject_bundle_request._xsd_source_, + f | ::xml_schema::flags::not_root, + this), + _xsd_dest_ (_xsd_inject_bundle_request._xsd_dest_, + f | ::xml_schema::flags::not_root, + this), + _xsd_replyto_ (_xsd_inject_bundle_request._xsd_replyto_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custodian_ (_xsd_inject_bundle_request._xsd_custodian_, + f | ::xml_schema::flags::not_root, + this), + _xsd_request_id_ (_xsd_inject_bundle_request._xsd_request_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_inject_bundle_request._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_fwd_action_ (_xsd_inject_bundle_request._xsd_fwd_action_, + f | ::xml_schema::flags::not_root, + this), + _xsd_priority_ (_xsd_inject_bundle_request._xsd_priority_, + f | ::xml_schema::flags::not_root, + this), + _xsd_expiration_ (_xsd_inject_bundle_request._xsd_expiration_, + f | ::xml_schema::flags::not_root, + this), + _xsd_payload_file_ (_xsd_inject_bundle_request._xsd_payload_file_, + f | ::xml_schema::flags::not_root, + this) + { + } + + inject_bundle_request:: + inject_bundle_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_source_ (f | ::xml_schema::flags::not_root, this), + _xsd_dest_ (f | ::xml_schema::flags::not_root, this), + _xsd_replyto_ (f | ::xml_schema::flags::not_root, this), + _xsd_custodian_ (f | ::xml_schema::flags::not_root, this), + _xsd_request_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_fwd_action_ (f | ::xml_schema::flags::not_root, this), + _xsd_priority_ (f | ::xml_schema::flags::not_root, this), + _xsd_expiration_ (f | ::xml_schema::flags::not_root, this), + _xsd_payload_file_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void inject_bundle_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 ()); + + // source + // + { + if (e.name () == "source" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< source::type > r ( + source::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_source_.present ()) + continue; + this->source (r); + continue; + } + } + + // dest + // + { + if (e.name () == "dest" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< dest::type > r ( + dest::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_dest_.present ()) + continue; + this->dest (r); + continue; + } + } + + // replyto + // + { + if (e.name () == "replyto" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< replyto::type > r ( + replyto::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->replyto ()) + continue; + this->replyto (r); + continue; + } + } + + // custodian + // + { + if (e.name () == "custodian" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< custodian::type > r ( + custodian::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->custodian ()) + continue; + this->custodian (r); + continue; + } + } + } + + if (!_xsd_source_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "source", + ""); + } + + if (!_xsd_dest_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "dest", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "request_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< request_id::type > r ( + request_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->request_id (r); + continue; + } + + if (a.name () == "link_id" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->link_id (r); + continue; + } + + if (a.name () == "fwd_action" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< fwd_action::type > r ( + fwd_action::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->fwd_action (r); + continue; + } + + if (a.name () == "priority" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< priority::type > r ( + priority::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->priority (r); + continue; + } + + if (a.name () == "expiration" && a.namespace_ ().empty ()) + { + this->expiration ( + expiration::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "payload_file" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< payload_file::type > r ( + payload_file::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->payload_file (r); + continue; + } + } + + if (!_xsd_request_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "request_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "link_id", + ""); + } + + if (!_xsd_payload_file_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "payload_file", + ""); + } + } + + inject_bundle_request* inject_bundle_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new inject_bundle_request (*this, f, c); + } + + // delete_bundle_request + // + + delete_bundle_request:: + delete_bundle_request () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + delete_bundle_request:: + delete_bundle_request (const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + delete_bundle_request:: + delete_bundle_request (const delete_bundle_request& _xsd_delete_bundle_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_delete_bundle_request, f, c), + _xsd_gbof_id_ (_xsd_delete_bundle_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_delete_bundle_request._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + delete_bundle_request:: + delete_bundle_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void delete_bundle_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + delete_bundle_request* delete_bundle_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new delete_bundle_request (*this, f, c); + } + + // set_cl_params_request + // + + set_cl_params_request:: + set_cl_params_request () + : ::xml_schema::type (), + _xsd_cl_params_ (::xml_schema::flags (), this), + _xsd_clayer_ (::xml_schema::flags (), this) + { + } + + set_cl_params_request:: + set_cl_params_request (const clayer::type& _xsd_clayer) + : ::xml_schema::type (), + _xsd_cl_params_ (::xml_schema::flags (), this), + _xsd_clayer_ (_xsd_clayer, + ::xml_schema::flags (), + this) + { + } + + set_cl_params_request:: + set_cl_params_request (const set_cl_params_request& _xsd_set_cl_params_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_set_cl_params_request, f, c), + _xsd_cl_params_ (_xsd_set_cl_params_request._xsd_cl_params_, + f | ::xml_schema::flags::not_root, + this), + _xsd_clayer_ (_xsd_set_cl_params_request._xsd_clayer_, + f | ::xml_schema::flags::not_root, + this) + { + } + + set_cl_params_request:: + set_cl_params_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_cl_params_ (f | ::xml_schema::flags::not_root, this), + _xsd_clayer_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void set_cl_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 ()); + + // cl_params + // + { + if (e.name () == "cl_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< cl_params::type > r ( + cl_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->cl_params ().push_back (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "clayer" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< clayer::type > r ( + clayer::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->clayer (r); + continue; + } + } + + if (!_xsd_clayer_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "clayer", + ""); + } + } + + set_cl_params_request* set_cl_params_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new set_cl_params_request (*this, f, c); + } + + // intentional_name_resolution_request + // + + intentional_name_resolution_request:: + intentional_name_resolution_request () + : ::xml_schema::type (), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_request_id_ (::xml_schema::flags (), this), + _xsd_router_eid_ (::xml_schema::flags (), this), + _xsd_intentional_name_ (::xml_schema::flags (), this), + _xsd_grain_state_ (::xml_schema::flags (), this) + { + } + + intentional_name_resolution_request:: + intentional_name_resolution_request (const gbof_id::type& _xsd_gbof_id, + const request_id::type& _xsd_request_id, + const router_eid::type& _xsd_router_eid, + const intentional_name::type& _xsd_intentional_name, + const grain_state::type& _xsd_grain_state) + : ::xml_schema::type (), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_request_id_ (_xsd_request_id, + ::xml_schema::flags (), + this), + _xsd_router_eid_ (_xsd_router_eid, + ::xml_schema::flags (), + this), + _xsd_intentional_name_ (_xsd_intentional_name, + ::xml_schema::flags (), + this), + _xsd_grain_state_ (_xsd_grain_state, + ::xml_schema::flags (), + this) + { + } + + intentional_name_resolution_request:: + intentional_name_resolution_request (const intentional_name_resolution_request& _xsd_intentional_name_resolution_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_intentional_name_resolution_request, f, c), + _xsd_gbof_id_ (_xsd_intentional_name_resolution_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_request_id_ (_xsd_intentional_name_resolution_request._xsd_request_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_router_eid_ (_xsd_intentional_name_resolution_request._xsd_router_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_intentional_name_ (_xsd_intentional_name_resolution_request._xsd_intentional_name_, + f | ::xml_schema::flags::not_root, + this), + _xsd_grain_state_ (_xsd_intentional_name_resolution_request._xsd_grain_state_, + f | ::xml_schema::flags::not_root, + this) + { + } + + intentional_name_resolution_request:: + intentional_name_resolution_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_request_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_router_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_intentional_name_ (f | ::xml_schema::flags::not_root, this), + _xsd_grain_state_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void intentional_name_resolution_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 ()); + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // request_id + // + { + if (e.name () == "request_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< request_id::type > r ( + request_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_request_id_.present ()) + continue; + this->request_id (r); + continue; + } + } + + // router_eid + // + { + if (e.name () == "router_eid" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< router_eid::type > r ( + router_eid::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_router_eid_.present ()) + continue; + this->router_eid (r); + continue; + } + } + + // intentional_name + // + { + if (e.name () == "intentional_name" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< intentional_name::type > r ( + intentional_name::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_intentional_name_.present ()) + continue; + this->intentional_name (r); + continue; + } + } + + // grain_state + // + { + if (e.name () == "grain_state" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< grain_state::type > r ( + grain_state::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_grain_state_.present ()) + continue; + this->grain_state (r); + continue; + } + } + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + if (!_xsd_request_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "request_id", + ""); + } + + if (!_xsd_router_eid_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "router_eid", + ""); + } + + if (!_xsd_intentional_name_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "intentional_name", + ""); + } + + if (!_xsd_grain_state_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "grain_state", + ""); + } + } + + intentional_name_resolution_request* intentional_name_resolution_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new intentional_name_resolution_request (*this, f, c); + } + + // deliver_bundle_to_app_request + // + + deliver_bundle_to_app_request:: + deliver_bundle_to_app_request () + : ::xml_schema::type (), + _xsd_endpoint_ (::xml_schema::flags (), this), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + deliver_bundle_to_app_request:: + deliver_bundle_to_app_request (const endpoint::type& _xsd_endpoint, + const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_endpoint_ (_xsd_endpoint, + ::xml_schema::flags (), + this), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + deliver_bundle_to_app_request:: + deliver_bundle_to_app_request (const deliver_bundle_to_app_request& _xsd_deliver_bundle_to_app_request, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_deliver_bundle_to_app_request, f, c), + _xsd_endpoint_ (_xsd_deliver_bundle_to_app_request._xsd_endpoint_, + f | ::xml_schema::flags::not_root, + this), + _xsd_gbof_id_ (_xsd_deliver_bundle_to_app_request._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_deliver_bundle_to_app_request._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + deliver_bundle_to_app_request:: + deliver_bundle_to_app_request (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_endpoint_ (f | ::xml_schema::flags::not_root, this), + _xsd_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void deliver_bundle_to_app_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 ()); + + // endpoint + // + { + if (e.name () == "endpoint" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< endpoint::type > r ( + endpoint::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_endpoint_.present ()) + continue; + this->endpoint (r); + continue; + } + } + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + } + + if (!_xsd_endpoint_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "endpoint", + ""); + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + deliver_bundle_to_app_request* deliver_bundle_to_app_request:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new deliver_bundle_to_app_request (*this, f, c); + } + + // link_report + // + + link_report:: + link_report () + : ::xml_schema::type (), + _xsd_link_ (::xml_schema::flags (), this) + { + } + + link_report:: + link_report (const link_report& _xsd_link_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_report, f, c), + _xsd_link_ (_xsd_link_report._xsd_link_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_report:: + link_report (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_link_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_report:: + 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 + // + { + if (e.name () == "link" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link::type > r ( + link::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->link ().push_back (r); + continue; + } + } + } + } + + link_report* link_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_report (*this, f, c); + } + + // link_attributes_query + // + + link_attributes_query:: + link_attributes_query () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_link_id_ (::xml_schema::flags (), this), + _xsd_query_params_ (::xml_schema::flags (), this) + { + } + + link_attributes_query:: + link_attributes_query (const query_id::type& _xsd_query_id, + const link_id::type& _xsd_link_id) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_link_id_ (_xsd_link_id, + ::xml_schema::flags (), + this), + _xsd_query_params_ (::xml_schema::flags (), this) + { + } + + link_attributes_query:: + link_attributes_query (const link_attributes_query& _xsd_link_attributes_query, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_attributes_query, f, c), + _xsd_query_id_ (_xsd_link_attributes_query._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_id_ (_xsd_link_attributes_query._xsd_link_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_params_ (_xsd_link_attributes_query._xsd_query_params_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_attributes_query:: + link_attributes_query (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_link_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_params_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_attributes_query:: + 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 ()); + + // query_id + // + { + if (e.name () == "query_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_query_id_.present ()) + continue; + this->query_id (r); + continue; + } + } + + // link_id + // + { + if (e.name () == "link_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< link_id::type > r ( + link_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_link_id_.present ()) + continue; + this->link_id (r); + continue; + } + } + + // query_params + // + { + if (e.name () == "query_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_params::type > r ( + query_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_params ().push_back (r); + continue; + } + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "query_id", + ""); + } + + if (!_xsd_link_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "link_id", + ""); + } + } + + link_attributes_query* link_attributes_query:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_attributes_query (*this, f, c); + } + + // link_attributes_report + // + + link_attributes_report:: + link_attributes_report () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_report_params_ (::xml_schema::flags (), this) + { + } + + link_attributes_report:: + link_attributes_report (const query_id::type& _xsd_query_id) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_report_params_ (::xml_schema::flags (), this) + { + } + + link_attributes_report:: + link_attributes_report (const link_attributes_report& _xsd_link_attributes_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_link_attributes_report, f, c), + _xsd_query_id_ (_xsd_link_attributes_report._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_params_ (_xsd_link_attributes_report._xsd_report_params_, + f | ::xml_schema::flags::not_root, + this) + { + } + + link_attributes_report:: + link_attributes_report (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_report_params_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void link_attributes_report:: + 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 ()); + + // query_id + // + { + if (e.name () == "query_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_query_id_.present ()) + continue; + this->query_id (r); + continue; + } + } + + // report_params + // + { + if (e.name () == "report_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< report_params::type > r ( + report_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->report_params ().push_back (r); + continue; + } + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "query_id", + ""); + } + } + + link_attributes_report* link_attributes_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new link_attributes_report (*this, f, c); + } + + // contact_report + // + + contact_report:: + contact_report () + : ::xml_schema::type (), + _xsd_contact_ (::xml_schema::flags (), this) + { + } + + contact_report:: + contact_report (const contact_report& _xsd_contact_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_contact_report, f, c), + _xsd_contact_ (_xsd_contact_report._xsd_contact_, + f | ::xml_schema::flags::not_root, + this) + { + } + + contact_report:: + contact_report (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_contact_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void contact_report:: + 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 + // + { + if (e.name () == "contact" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< contact::type > r ( + contact::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->contact ().push_back (r); + continue; + } + } + } + } + + contact_report* contact_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new contact_report (*this, f, c); + } + + // route_report + // + + route_report:: + route_report () + : ::xml_schema::type (), + _xsd_route_entry_ (::xml_schema::flags (), this) + { + } + + route_report:: + route_report (const route_report& _xsd_route_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_route_report, f, c), + _xsd_route_entry_ (_xsd_route_report._xsd_route_entry_, + f | ::xml_schema::flags::not_root, + this) + { + } + + route_report:: + route_report (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_route_entry_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void route_report:: + 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 ()); + + // route_entry + // + { + if (e.name () == "route_entry" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< route_entry::type > r ( + route_entry::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->route_entry ().push_back (r); + continue; + } + } + } + } + + route_report* route_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new route_report (*this, f, c); + } + + // bundle_report + // + + bundle_report:: + bundle_report () + : ::xml_schema::type (), + _xsd_bundle_ (::xml_schema::flags (), this) + { + } + + bundle_report:: + bundle_report (const bundle_report& _xsd_bundle_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_report, f, c), + _xsd_bundle_ (_xsd_bundle_report._xsd_bundle_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_report:: + bundle_report (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_report:: + 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 + // + { + if (e.name () == "bundle" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< bundle::type > r ( + bundle::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->bundle ().push_back (r); + continue; + } + } + } + } + + bundle_report* bundle_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_report (*this, f, c); + } + + // bundle_attributes_query + // + + bundle_attributes_query:: + bundle_attributes_query () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_gbof_id_ (::xml_schema::flags (), this), + _xsd_query_params_ (::xml_schema::flags (), this), + _xsd_local_id_ (::xml_schema::flags (), this) + { + } + + bundle_attributes_query:: + bundle_attributes_query (const query_id::type& _xsd_query_id, + const gbof_id::type& _xsd_gbof_id, + const local_id::type& _xsd_local_id) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_gbof_id_ (_xsd_gbof_id, + ::xml_schema::flags (), + this), + _xsd_query_params_ (::xml_schema::flags (), this), + _xsd_local_id_ (_xsd_local_id, + ::xml_schema::flags (), + this) + { + } + + bundle_attributes_query:: + bundle_attributes_query (const bundle_attributes_query& _xsd_bundle_attributes_query, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_attributes_query, f, c), + _xsd_query_id_ (_xsd_bundle_attributes_query._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_gbof_id_ (_xsd_bundle_attributes_query._xsd_gbof_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_query_params_ (_xsd_bundle_attributes_query._xsd_query_params_, + f | ::xml_schema::flags::not_root, + this), + _xsd_local_id_ (_xsd_bundle_attributes_query._xsd_local_id_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_attributes_query:: + bundle_attributes_query (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_gbof_id_ (f | ::xml_schema::flags::not_root, this), + _xsd_query_params_ (f | ::xml_schema::flags::not_root, this), + _xsd_local_id_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_attributes_query:: + 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 ()); + + // query_id + // + { + if (e.name () == "query_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_query_id_.present ()) + continue; + this->query_id (r); + continue; + } + } + + // gbof_id + // + { + if (e.name () == "gbof_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< gbof_id::type > r ( + gbof_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_gbof_id_.present ()) + continue; + this->gbof_id (r); + continue; + } + } + + // query_params + // + { + if (e.name () == "query_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_params::type > r ( + query_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + this->query_params ().push_back (r); + continue; + } + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "query_id", + ""); + } + + if (!_xsd_gbof_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "gbof_id", + ""); + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "local_id" && a.namespace_ ().empty ()) + { + this->local_id ( + local_id::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + } + + if (!_xsd_local_id_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "local_id", + ""); + } + } + + bundle_attributes_query* bundle_attributes_query:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_attributes_query (*this, f, c); + } + + // bundle_attributes_report + // + + bundle_attributes_report:: + bundle_attributes_report () + : ::xml_schema::type (), + _xsd_query_id_ (::xml_schema::flags (), this), + _xsd_report_params_ (::xml_schema::flags (), this) + { + } + + bundle_attributes_report:: + bundle_attributes_report (const query_id::type& _xsd_query_id, + const report_params::type& _xsd_report_params) + : ::xml_schema::type (), + _xsd_query_id_ (_xsd_query_id, + ::xml_schema::flags (), + this), + _xsd_report_params_ (_xsd_report_params, + ::xml_schema::flags (), + this) + { + } + + bundle_attributes_report:: + bundle_attributes_report (const bundle_attributes_report& _xsd_bundle_attributes_report, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bundle_attributes_report, f, c), + _xsd_query_id_ (_xsd_bundle_attributes_report._xsd_query_id_, + f | ::xml_schema::flags::not_root, + this), + _xsd_report_params_ (_xsd_bundle_attributes_report._xsd_report_params_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bundle_attributes_report:: + bundle_attributes_report (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_report_params_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bundle_attributes_report:: + 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 ()); + + // query_id + // + { + if (e.name () == "query_id" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< query_id::type > r ( + query_id::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_query_id_.present ()) + continue; + this->query_id (r); + continue; + } + } + + // report_params + // + { + if (e.name () == "report_params" && e.namespace_ ().empty ()) + { + ::std::auto_ptr< report_params::type > r ( + report_params::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (_xsd_report_params_.present ()) + continue; + this->report_params (r); + continue; + } + } + } + + if (!_xsd_query_id_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "query_id", + ""); + } + + if (!_xsd_report_params_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "report_params", + ""); + } + } + + bundle_attributes_report* bundle_attributes_report:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bundle_attributes_report (*this, f, c); + } + + // bpa + // + + bpa:: + bpa () + : ::xml_schema::type (), + _xsd_bundle_received_event_ (::xml_schema::flags (), this), + _xsd_data_transmitted_event_ (::xml_schema::flags (), this), + _xsd_bundle_delivered_event_ (::xml_schema::flags (), this), + _xsd_bundle_delivery_event_ (::xml_schema::flags (), this), + _xsd_bundle_expired_event_ (::xml_schema::flags (), this), + _xsd_bundle_send_cancelled_event_ (::xml_schema::flags (), this), + _xsd_bundle_injected_event_ (::xml_schema::flags (), this), + _xsd_link_opened_event_ (::xml_schema::flags (), this), + _xsd_link_closed_event_ (::xml_schema::flags (), this), + _xsd_link_created_event_ (::xml_schema::flags (), this), + _xsd_link_deleted_event_ (::xml_schema::flags (), this), + _xsd_link_available_event_ (::xml_schema::flags (), this), + _xsd_link_unavailable_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_busy_event_ (::xml_schema::flags (), this), + _xsd_eid_reachable_event_ (::xml_schema::flags (), this), + _xsd_route_add_event_ (::xml_schema::flags (), this), + _xsd_route_delete_event_ (::xml_schema::flags (), this), + _xsd_custody_signal_event_ (::xml_schema::flags (), this), + _xsd_custody_timeout_event_ (::xml_schema::flags (), this), + _xsd_intentional_name_resolved_event_ (::xml_schema::flags (), this), + _xsd_registration_added_event_ (::xml_schema::flags (), this), + _xsd_registration_removed_event_ (::xml_schema::flags (), this), + _xsd_registration_expired_event_ (::xml_schema::flags (), this), + _xsd_open_link_request_ (::xml_schema::flags (), this), + _xsd_close_link_request_ (::xml_schema::flags (), this), + _xsd_add_link_request_ (::xml_schema::flags (), this), + _xsd_delete_link_request_ (::xml_schema::flags (), this), + _xsd_reconfigure_link_request_ (::xml_schema::flags (), this), + _xsd_send_bundle_request_ (::xml_schema::flags (), this), + _xsd_send_bundle_broadcast_request_ (::xml_schema::flags (), this), + _xsd_cancel_bundle_request_ (::xml_schema::flags (), this), + _xsd_inject_bundle_request_ (::xml_schema::flags (), this), + _xsd_delete_bundle_request_ (::xml_schema::flags (), this), + _xsd_set_cl_params_request_ (::xml_schema::flags (), this), + _xsd_intentional_name_resolution_request_ (::xml_schema::flags (), this), + _xsd_deliver_bundle_to_app_request_ (::xml_schema::flags (), this), + _xsd_link_query_ (::xml_schema::flags (), this), + _xsd_link_report_ (::xml_schema::flags (), this), + _xsd_link_attributes_query_ (::xml_schema::flags (), this), + _xsd_link_attributes_report_ (::xml_schema::flags (), this), + _xsd_contact_query_ (::xml_schema::flags (), this), + _xsd_contact_report_ (::xml_schema::flags (), this), + _xsd_route_query_ (::xml_schema::flags (), this), + _xsd_route_report_ (::xml_schema::flags (), this), + _xsd_bundle_query_ (::xml_schema::flags (), this), + _xsd_bundle_report_ (::xml_schema::flags (), this), + _xsd_bundle_attributes_query_ (::xml_schema::flags (), this), + _xsd_bundle_attributes_report_ (::xml_schema::flags (), this), + _xsd_eid_ (::xml_schema::flags (), this), + _xsd_hello_interval_ (::xml_schema::flags (), this), + _xsd_alert_ (::xml_schema::flags (), this) + { + } + + bpa:: + bpa (const bpa& _xsd_bpa, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (_xsd_bpa, f, c), + _xsd_bundle_received_event_ (_xsd_bpa._xsd_bundle_received_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_data_transmitted_event_ (_xsd_bpa._xsd_data_transmitted_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_delivered_event_ (_xsd_bpa._xsd_bundle_delivered_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_delivery_event_ (_xsd_bpa._xsd_bundle_delivery_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_expired_event_ (_xsd_bpa._xsd_bundle_expired_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_send_cancelled_event_ (_xsd_bpa._xsd_bundle_send_cancelled_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_injected_event_ (_xsd_bpa._xsd_bundle_injected_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_opened_event_ (_xsd_bpa._xsd_link_opened_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_closed_event_ (_xsd_bpa._xsd_link_closed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_created_event_ (_xsd_bpa._xsd_link_created_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_deleted_event_ (_xsd_bpa._xsd_link_deleted_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_available_event_ (_xsd_bpa._xsd_link_available_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_unavailable_event_ (_xsd_bpa._xsd_link_unavailable_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_attribute_changed_event_ (_xsd_bpa._xsd_link_attribute_changed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contact_attribute_changed_event_ (_xsd_bpa._xsd_contact_attribute_changed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_busy_event_ (_xsd_bpa._xsd_link_busy_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_eid_reachable_event_ (_xsd_bpa._xsd_eid_reachable_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_route_add_event_ (_xsd_bpa._xsd_route_add_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_route_delete_event_ (_xsd_bpa._xsd_route_delete_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_signal_event_ (_xsd_bpa._xsd_custody_signal_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_custody_timeout_event_ (_xsd_bpa._xsd_custody_timeout_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_intentional_name_resolved_event_ (_xsd_bpa._xsd_intentional_name_resolved_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_registration_added_event_ (_xsd_bpa._xsd_registration_added_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_registration_removed_event_ (_xsd_bpa._xsd_registration_removed_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_registration_expired_event_ (_xsd_bpa._xsd_registration_expired_event_, + f | ::xml_schema::flags::not_root, + this), + _xsd_open_link_request_ (_xsd_bpa._xsd_open_link_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_close_link_request_ (_xsd_bpa._xsd_close_link_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_add_link_request_ (_xsd_bpa._xsd_add_link_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_delete_link_request_ (_xsd_bpa._xsd_delete_link_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_reconfigure_link_request_ (_xsd_bpa._xsd_reconfigure_link_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_send_bundle_request_ (_xsd_bpa._xsd_send_bundle_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_send_bundle_broadcast_request_ (_xsd_bpa._xsd_send_bundle_broadcast_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_cancel_bundle_request_ (_xsd_bpa._xsd_cancel_bundle_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_inject_bundle_request_ (_xsd_bpa._xsd_inject_bundle_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_delete_bundle_request_ (_xsd_bpa._xsd_delete_bundle_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_set_cl_params_request_ (_xsd_bpa._xsd_set_cl_params_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_intentional_name_resolution_request_ (_xsd_bpa._xsd_intentional_name_resolution_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_deliver_bundle_to_app_request_ (_xsd_bpa._xsd_deliver_bundle_to_app_request_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_query_ (_xsd_bpa._xsd_link_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_report_ (_xsd_bpa._xsd_link_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_attributes_query_ (_xsd_bpa._xsd_link_attributes_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_link_attributes_report_ (_xsd_bpa._xsd_link_attributes_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contact_query_ (_xsd_bpa._xsd_contact_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_contact_report_ (_xsd_bpa._xsd_contact_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_route_query_ (_xsd_bpa._xsd_route_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_route_report_ (_xsd_bpa._xsd_route_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_query_ (_xsd_bpa._xsd_bundle_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_report_ (_xsd_bpa._xsd_bundle_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_attributes_query_ (_xsd_bpa._xsd_bundle_attributes_query_, + f | ::xml_schema::flags::not_root, + this), + _xsd_bundle_attributes_report_ (_xsd_bpa._xsd_bundle_attributes_report_, + f | ::xml_schema::flags::not_root, + this), + _xsd_eid_ (_xsd_bpa._xsd_eid_, + f | ::xml_schema::flags::not_root, + this), + _xsd_hello_interval_ (_xsd_bpa._xsd_hello_interval_, + f | ::xml_schema::flags::not_root, + this), + _xsd_alert_ (_xsd_bpa._xsd_alert_, + f | ::xml_schema::flags::not_root, + this) + { + } + + bpa:: + bpa (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::type* c) + : ::xml_schema::type (e, f, c), + _xsd_bundle_received_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_data_transmitted_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_delivered_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_delivery_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_expired_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_send_cancelled_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_injected_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_opened_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_closed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_created_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_deleted_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_available_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_unavailable_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_busy_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_eid_reachable_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_route_add_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_route_delete_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_signal_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_custody_timeout_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_intentional_name_resolved_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_registration_added_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_registration_removed_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_registration_expired_event_ (f | ::xml_schema::flags::not_root, this), + _xsd_open_link_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_close_link_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_add_link_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_delete_link_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_reconfigure_link_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_send_bundle_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_send_bundle_broadcast_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_cancel_bundle_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_inject_bundle_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_delete_bundle_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_set_cl_params_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_intentional_name_resolution_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_deliver_bundle_to_app_request_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_attributes_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_link_attributes_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_contact_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_contact_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_route_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_route_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_attributes_query_ (f | ::xml_schema::flags::not_root, this), + _xsd_bundle_attributes_report_ (f | ::xml_schema::flags::not_root, this), + _xsd_eid_ (f | ::xml_schema::flags::not_root, this), + _xsd_hello_interval_ (f | ::xml_schema::flags::not_root, this), + _xsd_alert_ (f | ::xml_schema::flags::not_root, this) + { + parse (e, f); + } + + void bpa:: + 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_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; + } + } + + // data_transmitted_event + // + { + if (e.name () == "data_transmitted_event" && e.namespace_ () == "") + { + ::std::auto_ptr< data_transmitted_event::type > r ( + data_transmitted_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->data_transmitted_event ()) + continue; + this->data_transmitted_event (r); + continue; + } + } + + // bundle_delivered_event + // + { + if (e.name () == "bundle_delivered_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_delivered_event::type > r ( + bundle_delivered_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_delivered_event ()) + continue; + this->bundle_delivered_event (r); + continue; + } + } + + // bundle_delivery_event + // + { + if (e.name () == "bundle_delivery_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_delivery_event::type > r ( + bundle_delivery_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_delivery_event ()) + continue; + this->bundle_delivery_event (r); + continue; + } + } + + // bundle_expired_event + // + { + if (e.name () == "bundle_expired_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_expired_event::type > r ( + bundle_expired_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_expired_event ()) + continue; + this->bundle_expired_event (r); + continue; + } + } + + // bundle_send_cancelled_event + // + { + if (e.name () == "bundle_send_cancelled_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_send_cancelled_event::type > r ( + bundle_send_cancelled_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_send_cancelled_event ()) + continue; + this->bundle_send_cancelled_event (r); + continue; + } + } + + // bundle_injected_event + // + { + if (e.name () == "bundle_injected_event" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_injected_event::type > r ( + bundle_injected_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_injected_event ()) + continue; + this->bundle_injected_event (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_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_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_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_available_event + // + { + if (e.name () == "link_available_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_available_event::type > r ( + link_available_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_available_event ()) + continue; + this->link_available_event (r); + continue; + } + } + + // link_unavailable_event + // + { + if (e.name () == "link_unavailable_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_unavailable_event::type > r ( + link_unavailable_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_unavailable_event ()) + continue; + this->link_unavailable_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_busy_event + // + { + if (e.name () == "link_busy_event" && e.namespace_ () == "") + { + ::std::auto_ptr< link_busy_event::type > r ( + link_busy_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_busy_event ()) + continue; + this->link_busy_event (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; + } + } + + // route_add_event + // + { + if (e.name () == "route_add_event" && e.namespace_ () == "") + { + ::std::auto_ptr< route_add_event::type > r ( + route_add_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->route_add_event ()) + continue; + this->route_add_event (r); + continue; + } + } + + // route_delete_event + // + { + if (e.name () == "route_delete_event" && e.namespace_ () == "") + { + ::std::auto_ptr< route_delete_event::type > r ( + route_delete_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->route_delete_event ()) + continue; + this->route_delete_event (r); + continue; + } + } + + // custody_signal_event + // + { + if (e.name () == "custody_signal_event" && e.namespace_ () == "") + { + ::std::auto_ptr< custody_signal_event::type > r ( + custody_signal_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->custody_signal_event ()) + continue; + this->custody_signal_event (r); + continue; + } + } + + // custody_timeout_event + // + { + if (e.name () == "custody_timeout_event" && e.namespace_ () == "") + { + ::std::auto_ptr< custody_timeout_event::type > r ( + custody_timeout_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->custody_timeout_event ()) + continue; + this->custody_timeout_event (r); + continue; + } + } + + // intentional_name_resolved_event + // + { + if (e.name () == "intentional_name_resolved_event" && e.namespace_ () == "") + { + ::std::auto_ptr< intentional_name_resolved_event::type > r ( + intentional_name_resolved_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->intentional_name_resolved_event ()) + continue; + this->intentional_name_resolved_event (r); + continue; + } + } + + // registration_added_event + // + { + if (e.name () == "registration_added_event" && e.namespace_ () == "") + { + ::std::auto_ptr< registration_added_event::type > r ( + registration_added_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->registration_added_event ()) + continue; + this->registration_added_event (r); + continue; + } + } + + // registration_removed_event + // + { + if (e.name () == "registration_removed_event" && e.namespace_ () == "") + { + ::std::auto_ptr< registration_removed_event::type > r ( + registration_removed_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->registration_removed_event ()) + continue; + this->registration_removed_event (r); + continue; + } + } + + // registration_expired_event + // + { + if (e.name () == "registration_expired_event" && e.namespace_ () == "") + { + ::std::auto_ptr< registration_expired_event::type > r ( + registration_expired_event::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->registration_expired_event ()) + continue; + this->registration_expired_event (r); + continue; + } + } + + // open_link_request + // + { + if (e.name () == "open_link_request" && e.namespace_ () == "") + { + ::std::auto_ptr< open_link_request::type > r ( + open_link_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->open_link_request ()) + continue; + this->open_link_request (r); + continue; + } + } + + // close_link_request + // + { + if (e.name () == "close_link_request" && e.namespace_ () == "") + { + ::std::auto_ptr< close_link_request::type > r ( + close_link_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->close_link_request ()) + continue; + this->close_link_request (r); + continue; + } + } + + // add_link_request + // + { + if (e.name () == "add_link_request" && e.namespace_ () == "") + { + ::std::auto_ptr< add_link_request::type > r ( + add_link_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->add_link_request ()) + continue; + this->add_link_request (r); + continue; + } + } + + // delete_link_request + // + { + if (e.name () == "delete_link_request" && e.namespace_ () == "") + { + ::std::auto_ptr< delete_link_request::type > r ( + delete_link_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->delete_link_request ()) + continue; + this->delete_link_request (r); + continue; + } + } + + // reconfigure_link_request + // + { + if (e.name () == "reconfigure_link_request" && e.namespace_ () == "") + { + ::std::auto_ptr< reconfigure_link_request::type > r ( + reconfigure_link_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->reconfigure_link_request ()) + continue; + this->reconfigure_link_request (r); + continue; + } + } + + // send_bundle_request + // + { + if (e.name () == "send_bundle_request" && e.namespace_ () == "") + { + ::std::auto_ptr< send_bundle_request::type > r ( + send_bundle_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->send_bundle_request ()) + continue; + this->send_bundle_request (r); + continue; + } + } + + // send_bundle_broadcast_request + // + { + if (e.name () == "send_bundle_broadcast_request" && e.namespace_ () == "") + { + ::std::auto_ptr< send_bundle_broadcast_request::type > r ( + send_bundle_broadcast_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->send_bundle_broadcast_request ()) + continue; + this->send_bundle_broadcast_request (r); + continue; + } + } + + // cancel_bundle_request + // + { + if (e.name () == "cancel_bundle_request" && e.namespace_ () == "") + { + ::std::auto_ptr< cancel_bundle_request::type > r ( + cancel_bundle_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->cancel_bundle_request ()) + continue; + this->cancel_bundle_request (r); + continue; + } + } + + // inject_bundle_request + // + { + if (e.name () == "inject_bundle_request" && e.namespace_ () == "") + { + ::std::auto_ptr< inject_bundle_request::type > r ( + inject_bundle_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->inject_bundle_request ()) + continue; + this->inject_bundle_request (r); + continue; + } + } + + // delete_bundle_request + // + { + if (e.name () == "delete_bundle_request" && e.namespace_ () == "") + { + ::std::auto_ptr< delete_bundle_request::type > r ( + delete_bundle_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->delete_bundle_request ()) + continue; + this->delete_bundle_request (r); + continue; + } + } + + // set_cl_params_request + // + { + if (e.name () == "set_cl_params_request" && e.namespace_ () == "") + { + ::std::auto_ptr< set_cl_params_request::type > r ( + set_cl_params_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->set_cl_params_request ()) + continue; + this->set_cl_params_request (r); + continue; + } + } + + // intentional_name_resolution_request + // + { + if (e.name () == "intentional_name_resolution_request" && e.namespace_ () == "") + { + ::std::auto_ptr< intentional_name_resolution_request::type > r ( + intentional_name_resolution_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->intentional_name_resolution_request ()) + continue; + this->intentional_name_resolution_request (r); + continue; + } + } + + // deliver_bundle_to_app_request + // + { + if (e.name () == "deliver_bundle_to_app_request" && e.namespace_ () == "") + { + ::std::auto_ptr< deliver_bundle_to_app_request::type > r ( + deliver_bundle_to_app_request::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->deliver_bundle_to_app_request ()) + continue; + this->deliver_bundle_to_app_request (r); + continue; + } + } + + // link_query + // + { + if (e.name () == "link_query" && e.namespace_ () == "") + { + ::std::auto_ptr< link_query::type > r ( + link_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_query ()) + continue; + this->link_query (r); + continue; + } + } + + // link_report + // + { + if (e.name () == "link_report" && e.namespace_ () == "") + { + ::std::auto_ptr< link_report::type > r ( + link_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_report ()) + continue; + this->link_report (r); + continue; + } + } + + // link_attributes_query + // + { + if (e.name () == "link_attributes_query" && e.namespace_ () == "") + { + ::std::auto_ptr< link_attributes_query::type > r ( + link_attributes_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_attributes_query ()) + continue; + this->link_attributes_query (r); + continue; + } + } + + // link_attributes_report + // + { + if (e.name () == "link_attributes_report" && e.namespace_ () == "") + { + ::std::auto_ptr< link_attributes_report::type > r ( + link_attributes_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->link_attributes_report ()) + continue; + this->link_attributes_report (r); + continue; + } + } + + // contact_query + // + { + if (e.name () == "contact_query" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_query::type > r ( + contact_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->contact_query ()) + continue; + this->contact_query (r); + continue; + } + } + + // contact_report + // + { + if (e.name () == "contact_report" && e.namespace_ () == "") + { + ::std::auto_ptr< contact_report::type > r ( + contact_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->contact_report ()) + continue; + this->contact_report (r); + continue; + } + } + + // route_query + // + { + if (e.name () == "route_query" && e.namespace_ () == "") + { + ::std::auto_ptr< route_query::type > r ( + route_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->route_query ()) + continue; + this->route_query (r); + continue; + } + } + + // route_report + // + { + if (e.name () == "route_report" && e.namespace_ () == "") + { + ::std::auto_ptr< route_report::type > r ( + route_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->route_report ()) + continue; + this->route_report (r); + continue; + } + } + + // bundle_query + // + { + if (e.name () == "bundle_query" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_query::type > r ( + bundle_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_query ()) + continue; + this->bundle_query (r); + continue; + } + } + + // bundle_report + // + { + if (e.name () == "bundle_report" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_report::type > r ( + bundle_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_report ()) + continue; + this->bundle_report (r); + continue; + } + } + + // bundle_attributes_query + // + { + if (e.name () == "bundle_attributes_query" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes_query::type > r ( + bundle_attributes_query::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_attributes_query ()) + continue; + this->bundle_attributes_query (r); + continue; + } + } + + // bundle_attributes_report + // + { + if (e.name () == "bundle_attributes_report" && e.namespace_ () == "") + { + ::std::auto_ptr< bundle_attributes_report::type > r ( + bundle_attributes_report::traits::create ( + e.dom_element (), + f | ::xml_schema::flags::not_root, + this)); + + if (this->bundle_attributes_report ()) + continue; + this->bundle_attributes_report (r); + continue; + } + } + } + + while (p.more_attributes ()) + { + const ::xsd::cxx::xml::dom::attribute< char > a (p.next_attribute ()); + + if (a.name () == "eid" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< eid::type > r ( + eid::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->eid (r); + continue; + } + + if (a.name () == "hello_interval" && a.namespace_ ().empty ()) + { + this->hello_interval ( + hello_interval::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + continue; + } + + if (a.name () == "alert" && a.namespace_ ().empty ()) + { + ::std::auto_ptr< alert::type > r ( + alert::traits::create ( + a.dom_attribute (), + f | ::xml_schema::flags::not_root, + this)); + + this->alert (r); + continue; + } + } + } + + bpa* bpa:: + _clone (::xml_schema::flags f, + ::xml_schema::type* c) const + { + return new bpa (*this, f, c); + } + } +} + +#include +#include +#include +#include + +namespace dtn +{ + namespace rtrmessage + { + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, h, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, h, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, h, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (::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::rtrmessage::bpa_ (wrap, h, f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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::rtrmessage::bpa_ ( + static_cast< const ::xercesc::DOMDocument& > (*d), f, p); + } + + ::std::auto_ptr< ::dtn::rtrmessage::bpa > + bpa_ (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 () == "bpa" && + e.namespace_ () == "") + { + ::std::auto_ptr< ::dtn::rtrmessage::bpa > r ( + ::xsd::cxx::tree::traits< ::dtn::rtrmessage::bpa, 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_ (), + "bpa", + ""); + } + } +} + +#include +#include +#include +#include + +namespace dtn +{ + namespace rtrmessage + { + void + operator<< (::xercesc::DOMElement& e, + dtnStatusType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + dtnStatusType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + dtnStatusType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + bundlePriorityType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + bundlePriorityType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + bundlePriorityType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + eventSourceType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + eventSourceType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + eventSourceType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + bundleForwardActionType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + bundleForwardActionType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + bundleForwardActionType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + contactReasonType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + contactReasonType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + contactReasonType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + 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, + const eidTypeType& v) + { + e << static_cast< const ::xml_schema::string& > (v); + } + + void + operator<< (::xercesc::DOMAttr& a, + const eidTypeType& v) + { + a << static_cast< const ::xml_schema::string& > (v); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + const eidTypeType& v) + { + l << static_cast< const ::xml_schema::string& > (v); + } + + 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 + operator<< (::xercesc::DOMElement& e, + failureActionType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + failureActionType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + failureActionType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + bundleLocationType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + bundleLocationType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + bundleLocationType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + const eidType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "uri", + e); + + a.dom_attribute () << i.uri (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const gbofIdType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "source", + e); + s.dom_element () << i.source (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "creation_ts", + e); + + a.dom_attribute () << i.creation_ts (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_fragment", + e); + + a.dom_attribute () << i.is_fragment (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_length", + e); + + a.dom_attribute () << i.frag_length (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_offset", + e); + + a.dom_attribute () << i.frag_offset (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundleType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "source", + e); + s.dom_element () << i.source (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest", + e); + s.dom_element () << i.dest (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "custodian", + e); + s.dom_element () << i.custodian (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "replyto", + e); + s.dom_element () << i.replyto (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "prevhop", + e); + s.dom_element () << i.prevhop (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "length", + e); + s.dom_element () << i.length (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "location", + e); + s.dom_element () << i.location (); + } + + { + if (i.payload_file ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "payload_file", + e); + s.dom_element () << *i.payload_file (); + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bundleid", + e); + + a.dom_attribute () << i.bundleid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_fragment", + e); + + a.dom_attribute () << i.is_fragment (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_admin", + e); + + a.dom_attribute () << i.is_admin (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "do_not_fragment", + e); + + a.dom_attribute () << i.do_not_fragment (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "priority", + e); + + a.dom_attribute () << i.priority (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_requested", + e); + + a.dom_attribute () << i.custody_requested (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_custody", + e); + + a.dom_attribute () << i.local_custody (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "singleton_dest", + e); + + a.dom_attribute () << i.singleton_dest (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_rcpt", + e); + + a.dom_attribute () << i.custody_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "receive_rcpt", + e); + + a.dom_attribute () << i.receive_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "forward_rcpt", + e); + + a.dom_attribute () << i.forward_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "delivery_rcpt", + e); + + a.dom_attribute () << i.delivery_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "deletion_rcpt", + e); + + a.dom_attribute () << i.deletion_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "app_acked_rcpt", + e); + + a.dom_attribute () << i.app_acked_rcpt (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "creation_ts_seconds", + e); + + a.dom_attribute () << i.creation_ts_seconds (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "creation_ts_seqno", + e); + + a.dom_attribute () << i.creation_ts_seqno (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "expiration", + e); + + a.dom_attribute () << i.expiration (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_length", + e); + + a.dom_attribute () << i.orig_length (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_offset", + e); + + a.dom_attribute () << i.frag_offset (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "owner", + e); + + a.dom_attribute () << i.owner (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const contactType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attr", + e); + s.dom_element () << i.link_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "start_time_sec", + e); + + a.dom_attribute () << i.start_time_sec (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "start_time_usec", + e); + + a.dom_attribute () << i.start_time_usec (); + } + + { + ::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 ( + "pkt_loss_prob", + e); + + a.dom_attribute () << i.pkt_loss_prob (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const clInfoType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + if (i.local_addr ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_addr", + e); + + a.dom_attribute () << *i.local_addr (); + } + + if (i.remote_addr ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "remote_addr", + e); + + a.dom_attribute () << *i.remote_addr (); + } + + if (i.local_port ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_port", + e); + + a.dom_attribute () << *i.local_port (); + } + + if (i.remote_port ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "remote_port", + e); + + a.dom_attribute () << *i.remote_port (); + } + + if (i.segment_ack_enabled ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "segment_ack_enabled", + e); + + a.dom_attribute () << *i.segment_ack_enabled (); + } + + if (i.negative_ack_enabled ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "negative_ack_enabled", + e); + + a.dom_attribute () << *i.negative_ack_enabled (); + } + + if (i.keepalive_interval ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "keepalive_interval", + e); + + a.dom_attribute () << *i.keepalive_interval (); + } + + if (i.segment_length ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "segment_length", + e); + + a.dom_attribute () << *i.segment_length (); + } + + if (i.busy_queue_depth ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "busy_queue_depth", + e); + + a.dom_attribute () << *i.busy_queue_depth (); + } + + if (i.reactive_frag_enabled ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reactive_frag_enabled", + e); + + a.dom_attribute () << *i.reactive_frag_enabled (); + } + + if (i.sendbuf_length ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "sendbuf_length", + e); + + a.dom_attribute () << *i.sendbuf_length (); + } + + if (i.recvbuf_length ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "recvbuf_length", + e); + + a.dom_attribute () << *i.recvbuf_length (); + } + + if (i.data_timeout ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "data_timeout", + e); + + a.dom_attribute () << *i.data_timeout (); + } + + if (i.rate ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "rate", + e); + + a.dom_attribute () << *i.rate (); + } + + if (i.bucket_depth ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bucket_depth", + e); + + a.dom_attribute () << *i.bucket_depth (); + } + + if (i.channel ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "channel", + e); + + a.dom_attribute () << *i.channel (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const linkType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.clinfo ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "clinfo", + e); + s.dom_element () << *i.clinfo (); + } + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "remote_eid", + e); + s.dom_element () << i.remote_eid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "type", + e); + + a.dom_attribute () << i.type (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "nexthop", + e); + + a.dom_attribute () << i.nexthop (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "state", + e); + + a.dom_attribute () << i.state (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_reachable", + e); + + a.dom_attribute () << i.is_reachable (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_usable", + e); + + a.dom_attribute () << i.is_usable (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "how_reliable", + e); + + a.dom_attribute () << i.how_reliable (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "how_available", + e); + + a.dom_attribute () << i.how_available (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "clayer", + e); + + a.dom_attribute () << i.clayer (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "min_retry_interval", + e); + + a.dom_attribute () << i.min_retry_interval (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "max_retry_interval", + e); + + a.dom_attribute () << i.max_retry_interval (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "idle_close_time", + e); + + a.dom_attribute () << i.idle_close_time (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const routeEntryType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest_pattern", + e); + s.dom_element () << i.dest_pattern (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "source_pattern", + e); + s.dom_element () << i.source_pattern (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "route_priority", + e); + + a.dom_attribute () << i.route_priority (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "action", + e); + + a.dom_attribute () << i.action (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link", + e); + + a.dom_attribute () << i.link (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const custodySignalType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "admin_type", + e); + + a.dom_attribute () << i.admin_type (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "admin_flags", + e); + + a.dom_attribute () << i.admin_flags (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "succeeded", + e); + + a.dom_attribute () << i.succeeded (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_frag_offset", + e); + + a.dom_attribute () << i.orig_frag_offset (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_frag_length", + e); + + a.dom_attribute () << i.orig_frag_length (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_signal_seconds", + e); + + a.dom_attribute () << i.custody_signal_seconds (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_signal_seqno", + e); + + a.dom_attribute () << i.custody_signal_seqno (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_creation_seconds", + e); + + a.dom_attribute () << i.orig_creation_seconds (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_creation_seqno", + e); + + a.dom_attribute () << i.orig_creation_seqno (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const registrationType_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "endpoint", + e); + s.dom_element () << i.endpoint (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "regid", + e); + + a.dom_attribute () << i.regid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "action", + e); + + a.dom_attribute () << i.action (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "script", + e); + + a.dom_attribute () << i.script (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "expiration", + e); + + a.dom_attribute () << i.expiration (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const linkConfigType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (linkConfigType::cl_params::const_iterator + b (i.cl_params ().begin ()), n (i.cl_params ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cl_params", + 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_frag_enabled ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reactive_frag_enabled", + e); + + a.dom_attribute () << *i.reactive_frag_enabled (); + } + + if (i.nexthop ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "nexthop", + e); + + a.dom_attribute () << *i.nexthop (); + } + + if (i.min_retry_interval ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "min_retry_interval", + e); + + a.dom_attribute () << *i.min_retry_interval (); + } + + if (i.max_retry_interval ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "max_retry_interval", + e); + + a.dom_attribute () << *i.max_retry_interval (); + } + + if (i.idle_close_time ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "idle_close_time", + e); + + a.dom_attribute () << *i.idle_close_time (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const key_value_pair_base& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "name", + e); + s.dom_element () << i.name (); + } + + { + if (i.bool_value ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bool_value", + e); + s.dom_element () << *i.bool_value (); + } + } + + { + if (i.u_int_value ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "u_int_value", + e); + s.dom_element () << *i.u_int_value (); + } + } + + { + if (i.int_value ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "int_value", + e); + s.dom_element () << *i.int_value (); + } + } + + { + if (i.str_value ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "str_value", + e); + s.dom_element () << *i.str_value (); + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + bundleAttributesSimpleQueryType i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, + bundleAttributesSimpleQueryType i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xsd::cxx::tree::list_stream< char >& l, + bundleAttributesSimpleQueryType i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, + const bundleMetaBlockQueryType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.type ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "type", + e); + s.dom_element () << *i.type (); + } + } + + { + if (i.identifier ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "identifier", + e); + s.dom_element () << *i.identifier (); + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundleAttributesQueryType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query", + e); + s.dom_element () << *i.query (); + } + } + + { + if (i.meta_blocks ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "meta_blocks", + e); + s.dom_element () << *i.meta_blocks (); + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const metadataBlockType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "identifier", + e); + + a.dom_attribute () << i.identifier (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "generated", + e); + + a.dom_attribute () << i.generated (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "type", + e); + + a.dom_attribute () << i.type (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "contents", + e); + + a.dom_attribute () << i.contents (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundleAttributesReportType& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.dest ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest", + e); + s.dom_element () << *i.dest (); + } + } + + { + if (i.custodian ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "custodian", + e); + s.dom_element () << *i.custodian (); + } + } + + { + if (i.replyto ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "replyto", + e); + s.dom_element () << *i.replyto (); + } + } + + { + if (i.prevhop ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "prevhop", + e); + s.dom_element () << *i.prevhop (); + } + } + + { + for (bundleAttributesReportType::meta_blocks::const_iterator + b (i.meta_blocks ().begin ()), n (i.meta_blocks ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "meta_blocks", + e); + s.dom_element () << *b; + } + } + + if (i.bundleid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bundleid", + e); + + a.dom_attribute () << *i.bundleid (); + } + + if (i.is_admin ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "is_admin", + e); + + a.dom_attribute () << *i.is_admin (); + } + + if (i.do_not_fragment ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "do_not_fragment", + e); + + a.dom_attribute () << *i.do_not_fragment (); + } + + if (i.priority ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "priority", + e); + + a.dom_attribute () << *i.priority (); + } + + if (i.custody_requested ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_requested", + e); + + a.dom_attribute () << *i.custody_requested (); + } + + if (i.local_custody ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_custody", + e); + + a.dom_attribute () << *i.local_custody (); + } + + if (i.singleton_dest ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "singleton_dest", + e); + + a.dom_attribute () << *i.singleton_dest (); + } + + if (i.custody_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "custody_rcpt", + e); + + a.dom_attribute () << *i.custody_rcpt (); + } + + if (i.receive_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "receive_rcpt", + e); + + a.dom_attribute () << *i.receive_rcpt (); + } + + if (i.forward_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "forward_rcpt", + e); + + a.dom_attribute () << *i.forward_rcpt (); + } + + if (i.delivery_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "delivery_rcpt", + e); + + a.dom_attribute () << *i.delivery_rcpt (); + } + + if (i.deletion_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "deletion_rcpt", + e); + + a.dom_attribute () << *i.deletion_rcpt (); + } + + if (i.app_acked_rcpt ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "app_acked_rcpt", + e); + + a.dom_attribute () << *i.app_acked_rcpt (); + } + + if (i.expiration ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "expiration", + e); + + a.dom_attribute () << *i.expiration (); + } + + if (i.orig_length ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "orig_length", + e); + + a.dom_attribute () << *i.orig_length (); + } + + if (i.owner ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "owner", + e); + + a.dom_attribute () << *i.owner (); + } + + if (i.location ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "location", + e); + + a.dom_attribute () << *i.location (); + } + + if (i.payload_file ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "payload_file", + e); + + a.dom_attribute () << *i.payload_file (); + } + } + + void + bpa_ (::xercesc::DOMDocument& d, + const ::dtn::rtrmessage::bpa& s, + ::xml_schema::flags) + { + ::xsd::cxx::xml::dom::element< char > e (*d.getDocumentElement ()); + + if (e.name () == "bpa" && + e.namespace_ () == "") + { + e.dom_element () << s; + } + else + { + throw ::xsd::cxx::tree::unexpected_element < char > ( + e.name (), + e.namespace_ (), + "bpa", + ""); + } + } + + ::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument > + bpa_ (const ::dtn::rtrmessage::bpa& 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 > ( + "bpa", + "", + m, + f)); + ::dtn::rtrmessage::bpa_ (*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 + bpa_ (::xercesc::XMLFormatTarget& t, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (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 + bpa_ (::xercesc::XMLFormatTarget& t, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + bpa_ (::xercesc::XMLFormatTarget& t, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + bpa_ (::std::ostream& o, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (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 + bpa_ (::std::ostream& o, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (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 + bpa_ (::std::ostream& o, + const ::dtn::rtrmessage::bpa& 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::rtrmessage::bpa_ (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 bundle_received_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest", + e); + s.dom_element () << i.dest (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "custodian", + e); + s.dom_element () << i.custodian (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "replyto", + e); + s.dom_element () << i.replyto (); + } + + { + if (i.prevhop ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "prevhop", + e); + s.dom_element () << *i.prevhop (); + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "expiration", + e); + + a.dom_attribute () << i.expiration (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "bytes_received", + e); + + a.dom_attribute () << i.bytes_received (); + } + + if (i.num_meta_blocks ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "num_meta_blocks", + e); + + a.dom_attribute () << *i.num_meta_blocks (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const data_transmitted_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::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_delivered_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_delivery_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle", + e); + s.dom_element () << i.bundle (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_send_cancelled_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_id", + e); + s.dom_element () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_expired_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_injected_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "request_id", + e); + s.dom_element () << i.request_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + 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_attr", + e); + s.dom_element () << i.contact_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + 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_attr", + e); + s.dom_element () << i.contact_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + 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_attr", + e); + s.dom_element () << i.link_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + 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_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_available_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_unavailable_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::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_attr", + e); + s.dom_element () << i.link_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::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_eid", + e); + s.dom_element () << i.contact_eid (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_attr", + e); + s.dom_element () << i.contact_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "reason", + e); + + a.dom_attribute () << i.reason (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_busy_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link", + e); + s.dom_element () << i.link (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const eid_reachable_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "peer_eid", + e); + s.dom_element () << i.peer_eid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "interface_name", + e); + + a.dom_attribute () << i.interface_name (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const route_add_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_entry", + e); + s.dom_element () << i.route_entry (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const route_delete_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest", + e); + s.dom_element () << i.dest (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const custody_signal_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "custody_signal_attr", + e); + s.dom_element () << i.custody_signal_attr (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const custody_timeout_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const intentional_name_resolved_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "request_id", + e); + s.dom_element () << i.request_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "response_id", + e); + s.dom_element () << i.response_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "router_eid", + e); + s.dom_element () << i.router_eid (); + } + + { + if (i.lb_dp_eid ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "lb_dp_eid", + e); + s.dom_element () << *i.lb_dp_eid (); + } + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "intentional_name", + e); + s.dom_element () << i.intentional_name (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "grain_state", + e); + s.dom_element () << i.grain_state (); + } + + { + for (intentional_name_resolved_event::canonical_eids::const_iterator + b (i.canonical_eids ().begin ()), n (i.canonical_eids ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "canonical_eids", + e); + s.dom_element () << *b; + } + } + + { + for (intentional_name_resolved_event::app_eids::const_iterator + b (i.app_eids ().begin ()), n (i.app_eids ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "app_eids", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const registration_added_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "registration", + e); + s.dom_element () << i.registration (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "source", + e); + + a.dom_attribute () << i.source (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const registration_removed_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "registration", + e); + s.dom_element () << i.registration (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const registration_expired_event& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "regid", + e); + + a.dom_attribute () << i.regid (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const open_link_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const close_link_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const add_link_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + if (i.link_config_params ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_params", + e); + s.dom_element () << *i.link_config_params (); + } + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "remote_eid", + e); + s.dom_element () << i.remote_eid (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_type", + e); + + a.dom_attribute () << i.link_type (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "clayer", + e); + + a.dom_attribute () << i.clayer (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const delete_link_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const reconfigure_link_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_config_params", + e); + s.dom_element () << i.link_config_params (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const send_bundle_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + for (send_bundle_request::metadata_block::const_iterator + b (i.metadata_block ().begin ()), n (i.metadata_block ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "metadata_block", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "fwd_action", + e); + + a.dom_attribute () << i.fwd_action (); + } + + if (i.frag_size ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_size", + e); + + a.dom_attribute () << *i.frag_size (); + } + + if (i.frag_offset ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_offset", + e); + + a.dom_attribute () << *i.frag_offset (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const send_bundle_broadcast_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + for (send_bundle_broadcast_request::metadata_block::const_iterator + b (i.metadata_block ().begin ()), n (i.metadata_block ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "metadata_block", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "fwd_action", + e); + + a.dom_attribute () << i.fwd_action (); + } + + if (i.frag_size ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_size", + e); + + a.dom_attribute () << *i.frag_size (); + } + + if (i.frag_offset ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "frag_offset", + e); + + a.dom_attribute () << *i.frag_offset (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const cancel_bundle_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const inject_bundle_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "source", + e); + s.dom_element () << i.source (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "dest", + e); + s.dom_element () << i.dest (); + } + + { + if (i.replyto ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "replyto", + e); + s.dom_element () << *i.replyto (); + } + } + + { + if (i.custodian ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "custodian", + e); + s.dom_element () << *i.custodian (); + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "request_id", + e); + + a.dom_attribute () << i.request_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "link_id", + e); + + a.dom_attribute () << i.link_id (); + } + + if (i.fwd_action ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "fwd_action", + e); + + a.dom_attribute () << *i.fwd_action (); + } + + if (i.priority ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "priority", + e); + + a.dom_attribute () << *i.priority (); + } + + if (i.expiration ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "expiration", + e); + + a.dom_attribute () << *i.expiration (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "payload_file", + e); + + a.dom_attribute () << i.payload_file (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const delete_bundle_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const set_cl_params_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (set_cl_params_request::cl_params::const_iterator + b (i.cl_params ().begin ()), n (i.cl_params ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cl_params", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "clayer", + e); + + a.dom_attribute () << i.clayer (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const intentional_name_resolution_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "request_id", + e); + s.dom_element () << i.request_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "router_eid", + e); + s.dom_element () << i.router_eid (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "intentional_name", + e); + s.dom_element () << i.intentional_name (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "grain_state", + e); + s.dom_element () << i.grain_state (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const deliver_bundle_to_app_request& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "endpoint", + e); + s.dom_element () << i.endpoint (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (link_report::link::const_iterator + b (i.link ().begin ()), n (i.link ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_attributes_query& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_id", + e); + s.dom_element () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_id", + e); + s.dom_element () << i.link_id (); + } + + { + for (link_attributes_query::query_params::const_iterator + b (i.query_params ().begin ()), n (i.query_params ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_params", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const link_attributes_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_id", + e); + s.dom_element () << i.query_id (); + } + + { + for (link_attributes_report::report_params::const_iterator + b (i.report_params ().begin ()), n (i.report_params ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_params", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const contact_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (contact_report::contact::const_iterator + b (i.contact ().begin ()), n (i.contact ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const route_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (route_report::route_entry::const_iterator + b (i.route_entry ().begin ()), n (i.route_entry ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_entry", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + for (bundle_report::bundle::const_iterator + b (i.bundle ().begin ()), n (i.bundle ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle", + e); + s.dom_element () << *b; + } + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_attributes_query& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_id", + e); + s.dom_element () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "gbof_id", + e); + s.dom_element () << i.gbof_id (); + } + + { + for (bundle_attributes_query::query_params::const_iterator + b (i.query_params ().begin ()), n (i.query_params ().end ()); + b != n; ++b) + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_params", + e); + s.dom_element () << *b; + } + } + + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "local_id", + e); + + a.dom_attribute () << i.local_id (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bundle_attributes_report& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + ::xsd::cxx::xml::dom::element< char > s ( + "query_id", + e); + s.dom_element () << i.query_id (); + } + + { + ::xsd::cxx::xml::dom::element< char > s ( + "report_params", + e); + s.dom_element () << i.report_params (); + } + } + + void + operator<< (::xercesc::DOMElement& e, + const bpa& i) + { + while (::xercesc::DOMNode* n = e.getFirstChild ()) + e.removeChild (n); + + { + 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.data_transmitted_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "data_transmitted_event", + e); + s.dom_element () << *i.data_transmitted_event (); + } + } + + { + if (i.bundle_delivered_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_delivered_event", + e); + s.dom_element () << *i.bundle_delivered_event (); + } + } + + { + if (i.bundle_delivery_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_delivery_event", + e); + s.dom_element () << *i.bundle_delivery_event (); + } + } + + { + if (i.bundle_expired_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_expired_event", + e); + s.dom_element () << *i.bundle_expired_event (); + } + } + + { + if (i.bundle_send_cancelled_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_send_cancelled_event", + e); + s.dom_element () << *i.bundle_send_cancelled_event (); + } + } + + { + if (i.bundle_injected_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_injected_event", + e); + s.dom_element () << *i.bundle_injected_event (); + } + } + + { + 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_closed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_closed_event", + e); + s.dom_element () << *i.link_closed_event (); + } + } + + { + 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_deleted_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_deleted_event", + e); + s.dom_element () << *i.link_deleted_event (); + } + } + + { + if (i.link_available_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_available_event", + e); + s.dom_element () << *i.link_available_event (); + } + } + + { + if (i.link_unavailable_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_unavailable_event", + e); + s.dom_element () << *i.link_unavailable_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_busy_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_busy_event", + e); + s.dom_element () << *i.link_busy_event (); + } + } + + { + 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.route_add_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_add_event", + e); + s.dom_element () << *i.route_add_event (); + } + } + + { + if (i.route_delete_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_delete_event", + e); + s.dom_element () << *i.route_delete_event (); + } + } + + { + if (i.custody_signal_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "custody_signal_event", + e); + s.dom_element () << *i.custody_signal_event (); + } + } + + { + if (i.custody_timeout_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "custody_timeout_event", + e); + s.dom_element () << *i.custody_timeout_event (); + } + } + + { + if (i.intentional_name_resolved_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "intentional_name_resolved_event", + e); + s.dom_element () << *i.intentional_name_resolved_event (); + } + } + + { + if (i.registration_added_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "registration_added_event", + e); + s.dom_element () << *i.registration_added_event (); + } + } + + { + if (i.registration_removed_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "registration_removed_event", + e); + s.dom_element () << *i.registration_removed_event (); + } + } + + { + if (i.registration_expired_event ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "registration_expired_event", + e); + s.dom_element () << *i.registration_expired_event (); + } + } + + { + if (i.open_link_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "open_link_request", + e); + s.dom_element () << *i.open_link_request (); + } + } + + { + if (i.close_link_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "close_link_request", + e); + s.dom_element () << *i.close_link_request (); + } + } + + { + if (i.add_link_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "add_link_request", + e); + s.dom_element () << *i.add_link_request (); + } + } + + { + if (i.delete_link_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "delete_link_request", + e); + s.dom_element () << *i.delete_link_request (); + } + } + + { + if (i.reconfigure_link_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "reconfigure_link_request", + e); + s.dom_element () << *i.reconfigure_link_request (); + } + } + + { + if (i.send_bundle_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "send_bundle_request", + e); + s.dom_element () << *i.send_bundle_request (); + } + } + + { + if (i.send_bundle_broadcast_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "send_bundle_broadcast_request", + e); + s.dom_element () << *i.send_bundle_broadcast_request (); + } + } + + { + if (i.cancel_bundle_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "cancel_bundle_request", + e); + s.dom_element () << *i.cancel_bundle_request (); + } + } + + { + if (i.inject_bundle_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "inject_bundle_request", + e); + s.dom_element () << *i.inject_bundle_request (); + } + } + + { + if (i.delete_bundle_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "delete_bundle_request", + e); + s.dom_element () << *i.delete_bundle_request (); + } + } + + { + if (i.set_cl_params_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "set_cl_params_request", + e); + s.dom_element () << *i.set_cl_params_request (); + } + } + + { + if (i.intentional_name_resolution_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "intentional_name_resolution_request", + e); + s.dom_element () << *i.intentional_name_resolution_request (); + } + } + + { + if (i.deliver_bundle_to_app_request ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "deliver_bundle_to_app_request", + e); + s.dom_element () << *i.deliver_bundle_to_app_request (); + } + } + + { + if (i.link_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_query", + e); + s.dom_element () << *i.link_query (); + } + } + + { + if (i.link_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_report", + e); + s.dom_element () << *i.link_report (); + } + } + + { + if (i.link_attributes_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attributes_query", + e); + s.dom_element () << *i.link_attributes_query (); + } + } + + { + if (i.link_attributes_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "link_attributes_report", + e); + s.dom_element () << *i.link_attributes_report (); + } + } + + { + if (i.contact_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_query", + e); + s.dom_element () << *i.contact_query (); + } + } + + { + if (i.contact_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "contact_report", + e); + s.dom_element () << *i.contact_report (); + } + } + + { + if (i.route_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_query", + e); + s.dom_element () << *i.route_query (); + } + } + + { + if (i.route_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "route_report", + e); + s.dom_element () << *i.route_report (); + } + } + + { + if (i.bundle_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_query", + e); + s.dom_element () << *i.bundle_query (); + } + } + + { + if (i.bundle_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_report", + e); + s.dom_element () << *i.bundle_report (); + } + } + + { + if (i.bundle_attributes_query ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes_query", + e); + s.dom_element () << *i.bundle_attributes_query (); + } + } + + { + if (i.bundle_attributes_report ()) + { + ::xsd::cxx::xml::dom::element< char > s ( + "bundle_attributes_report", + e); + s.dom_element () << *i.bundle_attributes_report (); + } + } + + if (i.eid ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "eid", + e); + + a.dom_attribute () << *i.eid (); + } + + if (i.hello_interval ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "hello_interval", + e); + + a.dom_attribute () << *i.hello_interval (); + } + + if (i.alert ()) + { + ::xsd::cxx::xml::dom::attribute< char > a ( + "alert", + e); + + a.dom_attribute () << *i.alert (); + } + } + } +} + +#include + +// Begin epilogue. +// +#endif +// +// End epilogue. +