diff options
Diffstat (limited to 'modules/CIAO/tools/Config_Handlers/CIAO_Events')
7 files changed, 2285 insertions, 0 deletions
diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp new file mode 100644 index 00000000000..2f2db561642 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp @@ -0,0 +1,1360 @@ +/* $Id$ + * This code was generated by the XML Schema Compiler. + * + * Changes made to this code will most likely be overwritten + * when the handlers are recompiled. + * + * If you find errors or feel that there are bugfixes to be made, + * please contact the current XSC maintainer: + * Will Otte <wotte@dre.vanderbilt.edu> + */ + +#include "CIAOEvents.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // EventServiceType + // + + EventServiceType::Value EventServiceType:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::EventServiceType const& a, ::CIAO::Config_Handlers::EventServiceType const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::EventServiceType const& a, ::CIAO::Config_Handlers::EventServiceType const& b) + { + return a.v_ != b.v_; + } + + EventServiceType:: + EventServiceType (EventServiceType::Value v) + : v_ (v) + { + } + + // CIAOEventsDef + // + + CIAOEventsDef:: + CIAOEventsDef () + : + ::XSCRT::Type (), + regulator__ () + { + } + + CIAOEventsDef:: + CIAOEventsDef (::CIAO::Config_Handlers::CIAOEventsDef const& s) + : + ::XSCRT::Type (), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + { + for (eventServiceConfiguration_const_iterator i (s.eventServiceConfiguration_.begin ());i != s.eventServiceConfiguration_.end ();++i) add_eventServiceConfiguration (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::CIAOEventsDef& CIAOEventsDef:: + operator= (::CIAO::Config_Handlers::CIAOEventsDef const& s) + { + eventServiceConfiguration_.clear (); + { + for (eventServiceConfiguration_const_iterator i (s.eventServiceConfiguration_.begin ());i != s.eventServiceConfiguration_.end ();++i) add_eventServiceConfiguration (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // CIAOEventsDef + // + CIAOEventsDef::eventServiceConfiguration_iterator CIAOEventsDef:: + begin_eventServiceConfiguration () + { + return eventServiceConfiguration_.begin (); + } + + CIAOEventsDef::eventServiceConfiguration_iterator CIAOEventsDef:: + end_eventServiceConfiguration () + { + return eventServiceConfiguration_.end (); + } + + CIAOEventsDef::eventServiceConfiguration_const_iterator CIAOEventsDef:: + begin_eventServiceConfiguration () const + { + return eventServiceConfiguration_.begin (); + } + + CIAOEventsDef::eventServiceConfiguration_const_iterator CIAOEventsDef:: + end_eventServiceConfiguration () const + { + return eventServiceConfiguration_.end (); + } + + void CIAOEventsDef:: + add_eventServiceConfiguration (::CIAO::Config_Handlers::EventServiceDescription const& e) + { + eventServiceConfiguration_.push_back (e); + } + + size_t CIAOEventsDef:: + count_eventServiceConfiguration(void) const + { + return eventServiceConfiguration_.size (); + } + + // CIAOEventsDef + // + bool CIAOEventsDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& CIAOEventsDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& CIAOEventsDef:: + id () + { + return *id_; + } + + void CIAOEventsDef:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // EventServiceDescription + // + + EventServiceDescription:: + EventServiceDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::CIAO::Config_Handlers::EventServiceType const& type__, + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + type_ (new ::CIAO::Config_Handlers::EventServiceType (type__)), + svc_cfg_file_ (new ::XMLSchema::string< ACE_TCHAR > (svc_cfg_file__)), + regulator__ () + { + name_->container (this); + node_->container (this); + type_->container (this); + svc_cfg_file_->container (this); + } + + EventServiceDescription:: + EventServiceDescription (::CIAO::Config_Handlers::EventServiceDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + type_ (new ::CIAO::Config_Handlers::EventServiceType (*s.type_)), + svc_cfg_file_ (new ::XMLSchema::string< ACE_TCHAR > (*s.svc_cfg_file_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + node_->container (this); + type_->container (this); + svc_cfg_file_->container (this); + { + for (filter_const_iterator i (s.filter_.begin ());i != s.filter_.end ();++i) add_filter (*i); + } + + { + for (addr_serv_const_iterator i (s.addr_serv_.begin ());i != s.addr_serv_.end ();++i) add_addr_serv (*i); + } + + { + for (udp_sender_const_iterator i (s.udp_sender_.begin ());i != s.udp_sender_.end ();++i) add_udp_sender (*i); + } + + { + for (udp_receiver_const_iterator i (s.udp_receiver_.begin ());i != s.udp_receiver_.end ();++i) add_udp_receiver (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::EventServiceDescription& EventServiceDescription:: + operator= (::CIAO::Config_Handlers::EventServiceDescription const& s) + { + name (s.name ()); + + node (s.node ()); + + type (s.type ()); + + svc_cfg_file (s.svc_cfg_file ()); + + filter_.clear (); + { + for (filter_const_iterator i (s.filter_.begin ());i != s.filter_.end ();++i) add_filter (*i); + } + + addr_serv_.clear (); + { + for (addr_serv_const_iterator i (s.addr_serv_.begin ());i != s.addr_serv_.end ();++i) add_addr_serv (*i); + } + + udp_sender_.clear (); + { + for (udp_sender_const_iterator i (s.udp_sender_.begin ());i != s.udp_sender_.end ();++i) add_udp_sender (*i); + } + + udp_receiver_.clear (); + { + for (udp_receiver_const_iterator i (s.udp_receiver_.begin ());i != s.udp_receiver_.end ();++i) add_udp_receiver (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + name () const + { + return *name_; + } + + void EventServiceDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + node () const + { + return *node_; + } + + void EventServiceDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // EventServiceDescription + // + ::CIAO::Config_Handlers::EventServiceType const& EventServiceDescription:: + type () const + { + return *type_; + } + + void EventServiceDescription:: + type (::CIAO::Config_Handlers::EventServiceType const& e) + { + *type_ = e; + } + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + svc_cfg_file () const + { + return *svc_cfg_file_; + } + + void EventServiceDescription:: + svc_cfg_file (::XMLSchema::string< ACE_TCHAR > const& e) + { + *svc_cfg_file_ = e; + } + + // EventServiceDescription + // + EventServiceDescription::filter_iterator EventServiceDescription:: + begin_filter () + { + return filter_.begin (); + } + + EventServiceDescription::filter_iterator EventServiceDescription:: + end_filter () + { + return filter_.end (); + } + + EventServiceDescription::filter_const_iterator EventServiceDescription:: + begin_filter () const + { + return filter_.begin (); + } + + EventServiceDescription::filter_const_iterator EventServiceDescription:: + end_filter () const + { + return filter_.end (); + } + + void EventServiceDescription:: + add_filter (::CIAO::Config_Handlers::Filter const& e) + { + filter_.push_back (e); + } + + size_t EventServiceDescription:: + count_filter(void) const + { + return filter_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::addr_serv_iterator EventServiceDescription:: + begin_addr_serv () + { + return addr_serv_.begin (); + } + + EventServiceDescription::addr_serv_iterator EventServiceDescription:: + end_addr_serv () + { + return addr_serv_.end (); + } + + EventServiceDescription::addr_serv_const_iterator EventServiceDescription:: + begin_addr_serv () const + { + return addr_serv_.begin (); + } + + EventServiceDescription::addr_serv_const_iterator EventServiceDescription:: + end_addr_serv () const + { + return addr_serv_.end (); + } + + void EventServiceDescription:: + add_addr_serv (::CIAO::Config_Handlers::AddressServerDescription const& e) + { + addr_serv_.push_back (e); + } + + size_t EventServiceDescription:: + count_addr_serv(void) const + { + return addr_serv_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::udp_sender_iterator EventServiceDescription:: + begin_udp_sender () + { + return udp_sender_.begin (); + } + + EventServiceDescription::udp_sender_iterator EventServiceDescription:: + end_udp_sender () + { + return udp_sender_.end (); + } + + EventServiceDescription::udp_sender_const_iterator EventServiceDescription:: + begin_udp_sender () const + { + return udp_sender_.begin (); + } + + EventServiceDescription::udp_sender_const_iterator EventServiceDescription:: + end_udp_sender () const + { + return udp_sender_.end (); + } + + void EventServiceDescription:: + add_udp_sender (::CIAO::Config_Handlers::UDPSenderDescription const& e) + { + udp_sender_.push_back (e); + } + + size_t EventServiceDescription:: + count_udp_sender(void) const + { + return udp_sender_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::udp_receiver_iterator EventServiceDescription:: + begin_udp_receiver () + { + return udp_receiver_.begin (); + } + + EventServiceDescription::udp_receiver_iterator EventServiceDescription:: + end_udp_receiver () + { + return udp_receiver_.end (); + } + + EventServiceDescription::udp_receiver_const_iterator EventServiceDescription:: + begin_udp_receiver () const + { + return udp_receiver_.begin (); + } + + EventServiceDescription::udp_receiver_const_iterator EventServiceDescription:: + end_udp_receiver () const + { + return udp_receiver_.end (); + } + + void EventServiceDescription:: + add_udp_receiver (::CIAO::Config_Handlers::UDPReceiverDescription const& e) + { + udp_receiver_.push_back (e); + } + + size_t EventServiceDescription:: + count_udp_receiver(void) const + { + return udp_receiver_.size (); + } + + // EventServiceDescription + // + bool EventServiceDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& EventServiceDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& EventServiceDescription:: + id () + { + return *id_; + } + + void EventServiceDescription:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // FilterType + // + + FilterType::Value FilterType:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::FilterType const& a, ::CIAO::Config_Handlers::FilterType const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::FilterType const& a, ::CIAO::Config_Handlers::FilterType const& b) + { + return a.v_ != b.v_; + } + + FilterType:: + FilterType (FilterType::Value v) + : v_ (v) + { + } + + // Filter + // + + Filter:: + Filter (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::FilterType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::FilterType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + Filter:: + Filter (::CIAO::Config_Handlers::Filter const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::FilterType (*s.type_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + type_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::Filter& Filter:: + operator= (::CIAO::Config_Handlers::Filter const& s) + { + name (s.name ()); + + type (s.type ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // Filter + // + ::XMLSchema::string< ACE_TCHAR > const& Filter:: + name () const + { + return *name_; + } + + void Filter:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Filter + // + ::CIAO::Config_Handlers::FilterType const& Filter:: + type () const + { + return *type_; + } + + void Filter:: + type (::CIAO::Config_Handlers::FilterType const& e) + { + *type_ = e; + } + + // Filter + // + Filter::source_iterator Filter:: + begin_source () + { + return source_.begin (); + } + + Filter::source_iterator Filter:: + end_source () + { + return source_.end (); + } + + Filter::source_const_iterator Filter:: + begin_source () const + { + return source_.begin (); + } + + Filter::source_const_iterator Filter:: + end_source () const + { + return source_.end (); + } + + void Filter:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t Filter:: + count_source(void) const + { + return source_.size (); + } + + // Filter + // + bool Filter:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& Filter:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& Filter:: + id () + { + return *id_; + } + + void Filter:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // AddressServerDescription + // + + AddressServerDescription:: + AddressServerDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::unsignedShort const& port__, + ::XMLSchema::string< ACE_TCHAR > const& address__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + port_ (new ::XMLSchema::unsignedShort (port__)), + address_ (new ::XMLSchema::string< ACE_TCHAR > (address__)), + regulator__ () + { + name_->container (this); + port_->container (this); + address_->container (this); + } + + AddressServerDescription:: + AddressServerDescription (::CIAO::Config_Handlers::AddressServerDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + port_ (new ::XMLSchema::unsignedShort (*s.port_)), + address_ (new ::XMLSchema::string< ACE_TCHAR > (*s.address_)), + regulator__ () + { + name_->container (this); + port_->container (this); + address_->container (this); + } + + ::CIAO::Config_Handlers::AddressServerDescription& AddressServerDescription:: + operator= (::CIAO::Config_Handlers::AddressServerDescription const& s) + { + name (s.name ()); + + port (s.port ()); + + address (s.address ()); + + return *this; + } + + + // AddressServerDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AddressServerDescription:: + name () const + { + return *name_; + } + + void AddressServerDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AddressServerDescription + // + ::XMLSchema::unsignedShort const& AddressServerDescription:: + port () const + { + return *port_; + } + + void AddressServerDescription:: + port (::XMLSchema::unsignedShort const& e) + { + *port_ = e; + } + + // AddressServerDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AddressServerDescription:: + address () const + { + return *address_; + } + + void AddressServerDescription:: + address (::XMLSchema::string< ACE_TCHAR > const& e) + { + *address_ = e; + } + + + // UDPSenderDescription + // + + UDPSenderDescription:: + UDPSenderDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + addr_serv_id_ (new ::XMLSchema::string< ACE_TCHAR > (addr_serv_id__)), + regulator__ () + { + name_->container (this); + addr_serv_id_->container (this); + } + + UDPSenderDescription:: + UDPSenderDescription (::CIAO::Config_Handlers::UDPSenderDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + addr_serv_id_ (new ::XMLSchema::string< ACE_TCHAR > (*s.addr_serv_id_)), + regulator__ () + { + name_->container (this); + addr_serv_id_->container (this); + } + + ::CIAO::Config_Handlers::UDPSenderDescription& UDPSenderDescription:: + operator= (::CIAO::Config_Handlers::UDPSenderDescription const& s) + { + name (s.name ()); + + addr_serv_id (s.addr_serv_id ()); + + return *this; + } + + + // UDPSenderDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPSenderDescription:: + name () const + { + return *name_; + } + + void UDPSenderDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // UDPSenderDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPSenderDescription:: + addr_serv_id () const + { + return *addr_serv_id_; + } + + void UDPSenderDescription:: + addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& e) + { + *addr_serv_id_ = e; + } + + + // UDPReceiverDescription + // + + UDPReceiverDescription:: + UDPReceiverDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& is_multicast__, + ::XMLSchema::unsignedShort const& listen_port__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + is_multicast_ (new ::XMLSchema::boolean (is_multicast__)), + listen_port_ (new ::XMLSchema::unsignedShort (listen_port__)), + regulator__ () + { + name_->container (this); + is_multicast_->container (this); + listen_port_->container (this); + } + + UDPReceiverDescription:: + UDPReceiverDescription (::CIAO::Config_Handlers::UDPReceiverDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + addr_serv_id_ (s.addr_serv_id_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.addr_serv_id_) : 0), + is_multicast_ (new ::XMLSchema::boolean (*s.is_multicast_)), + listen_port_ (new ::XMLSchema::unsignedShort (*s.listen_port_)), + regulator__ () + { + name_->container (this); + if (addr_serv_id_.get ()) addr_serv_id_->container (this); + is_multicast_->container (this); + listen_port_->container (this); + } + + ::CIAO::Config_Handlers::UDPReceiverDescription& UDPReceiverDescription:: + operator= (::CIAO::Config_Handlers::UDPReceiverDescription const& s) + { + name (s.name ()); + + if (s.addr_serv_id_.get ()) addr_serv_id (*(s.addr_serv_id_)); + else addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + is_multicast (s.is_multicast ()); + + listen_port (s.listen_port ()); + + return *this; + } + + + // UDPReceiverDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPReceiverDescription:: + name () const + { + return *name_; + } + + void UDPReceiverDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // UDPReceiverDescription + // + bool UDPReceiverDescription:: + addr_serv_id_p () const + { + return addr_serv_id_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& UDPReceiverDescription:: + addr_serv_id () const + { + return *addr_serv_id_; + } + + void UDPReceiverDescription:: + addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (addr_serv_id_.get ()) + { + *addr_serv_id_ = e; + } + + else + { + addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + addr_serv_id_->container (this); + } + } + + // UDPReceiverDescription + // + ::XMLSchema::boolean const& UDPReceiverDescription:: + is_multicast () const + { + return *is_multicast_; + } + + void UDPReceiverDescription:: + is_multicast (::XMLSchema::boolean const& e) + { + *is_multicast_ = e; + } + + // UDPReceiverDescription + // + ::XMLSchema::unsignedShort const& UDPReceiverDescription:: + listen_port () const + { + return *listen_port_; + } + + void UDPReceiverDescription:: + listen_port (::XMLSchema::unsignedShort const& e) + { + *listen_port_ = e; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // EventServiceType + // + + EventServiceType:: + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "EC") v_ = EC_l; + else if (v == "RTEC") v_ = RTEC_l; + else if (v == "NOTIFY") v_ = NOTIFY_l; + else if (v == "RTNOTIFY") v_ = RTNOTIFY_l; + else + { + } + } + + EventServiceType:: + EventServiceType (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "EC") v_ = EC_l; + else if (v == "RTEC") v_ = RTEC_l; + else if (v == "NOTIFY") v_ = NOTIFY_l; + else if (v == "RTNOTIFY") v_ = RTNOTIFY_l; + else + { + } + } + + EventServiceType const EventServiceType::EC (EventServiceType::EC_l); + EventServiceType const EventServiceType::RTEC (EventServiceType::RTEC_l); + EventServiceType const EventServiceType::NOTIFY (EventServiceType::NOTIFY_l); + EventServiceType const EventServiceType::RTNOTIFY (EventServiceType::RTNOTIFY_l); + + // CIAOEventsDef + // + + CIAOEventsDef:: + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "eventServiceConfiguration") + { + ::CIAO::Config_Handlers::EventServiceDescription t (e); + add_eventServiceConfiguration (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // EventServiceDescription + // + + EventServiceDescription:: + EventServiceDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::EventServiceType > (new ::CIAO::Config_Handlers::EventServiceType (e)); + type_->container (this); + } + + else if (n == "svc_cfg_file") + { + svc_cfg_file_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + svc_cfg_file_->container (this); + } + + else if (n == "filter") + { + ::CIAO::Config_Handlers::Filter t (e); + add_filter (t); + } + + else if (n == "addr_serv") + { + ::CIAO::Config_Handlers::AddressServerDescription t (e); + add_addr_serv (t); + } + + else if (n == "udp_sender") + { + ::CIAO::Config_Handlers::UDPSenderDescription t (e); + add_udp_sender (t); + } + + else if (n == "udp_receiver") + { + ::CIAO::Config_Handlers::UDPReceiverDescription t (e); + add_udp_receiver (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // FilterType + // + + FilterType:: + FilterType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "CONJUNCTION") v_ = CONJUNCTION_l; + else if (v == "DISJUNCTION") v_ = DISJUNCTION_l; + else if (v == "LOGICAL_AND") v_ = LOGICAL_AND_l; + else if (v == "NEGATE") v_ = NEGATE_l; + else + { + } + } + + FilterType:: + FilterType (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "CONJUNCTION") v_ = CONJUNCTION_l; + else if (v == "DISJUNCTION") v_ = DISJUNCTION_l; + else if (v == "LOGICAL_AND") v_ = LOGICAL_AND_l; + else if (v == "NEGATE") v_ = NEGATE_l; + else + { + } + } + + FilterType const FilterType::CONJUNCTION (FilterType::CONJUNCTION_l); + FilterType const FilterType::DISJUNCTION (FilterType::DISJUNCTION_l); + FilterType const FilterType::LOGICAL_AND (FilterType::LOGICAL_AND_l); + FilterType const FilterType::NEGATE (FilterType::NEGATE_l); + + // Filter + // + + Filter:: + Filter (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::FilterType > (new ::CIAO::Config_Handlers::FilterType (e)); + type_->container (this); + } + + else if (n == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // AddressServerDescription + // + + AddressServerDescription:: + AddressServerDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "port") + { + port_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (new ::XMLSchema::unsignedShort (e)); + port_->container (this); + } + + else if (n == "address") + { + address_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + address_->container (this); + } + + else + { + } + } + } + + // UDPSenderDescription + // + + UDPSenderDescription:: + UDPSenderDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "addr_serv_id") + { + addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + addr_serv_id_->container (this); + } + + else + { + } + } + } + + // UDPReceiverDescription + // + + UDPReceiverDescription:: + UDPReceiverDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base__ (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "addr_serv_id") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + addr_serv_id (t); + } + + else if (n == "is_multicast") + { + is_multicast_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + is_multicast_->container (this); + } + + else if (n == "listen_port") + { + listen_port_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (new ::XMLSchema::unsignedShort (e)); + listen_port_->container (this); + } + + else + { + } + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + ::CIAO::Config_Handlers::CIAOEventsDef + CIAOEvents (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "CIAOEvents") + { + ::CIAO::Config_Handlers::CIAOEventsDef r (e); + return r; + } + + else + { + throw 1; + } + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp new file mode 100644 index 00000000000..692b6b940d0 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp @@ -0,0 +1,514 @@ +/* $Id$ + * This code was generated by the XML Schema Compiler. + * + * Changes made to this code will most likely be overwritten + * when the handlers are recompiled. + * + * If you find errors or feel that there are bugfixes to be made, + * please contact the current XSC maintainer: + * Will Otte <wotte@dre.vanderbilt.edu> + */ + +// Fix for Borland compilers, which seem to have a broken +// <string> include. +#ifdef __BORLANDC__ +# include <string.h> +#endif + +#include "CIAO_Events_Handlers_Export.h" +#ifndef CIAOEVENTS_HPP +#define CIAOEVENTS_HPP + +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class EventServiceType; + class CIAOEventsDef; + class EventServiceDescription; + class FilterType; + class Filter; + class AddressServerDescription; + class UDPSenderDescription; + class UDPReceiverDescription; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class CIAO_Events_Handlers_Export EventServiceType : public ::XSCRT::Type + { + public: + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR > const&); + EventServiceType (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static EventServiceType const EC; + static EventServiceType const RTEC; + static EventServiceType const NOTIFY; + static EventServiceType const RTNOTIFY; + + enum Value + { + EC_l,RTEC_l,NOTIFY_l,RTNOTIFY_l + }; + + + Value + integral () const; + + friend bool CIAO_Events_Handlers_Export + operator== (EventServiceType const& a, EventServiceType const& b); + + friend bool CIAO_Events_Handlers_Export + operator!= (EventServiceType const& a, EventServiceType const& b); + + private: + EventServiceType (Value v); + + Value v_; + }; + + bool CIAO_Events_Handlers_Export operator== (EventServiceType const &a, EventServiceType const &b); + + bool CIAO_Events_Handlers_Export operator!= (EventServiceType const &a, EventServiceType const &b); + + + class CIAO_Events_Handlers_Export CIAOEventsDef : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // eventServiceConfiguration + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::EventServiceDescription >::iterator eventServiceConfiguration_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::EventServiceDescription >::const_iterator eventServiceConfiguration_const_iterator; + eventServiceConfiguration_iterator begin_eventServiceConfiguration (); + eventServiceConfiguration_iterator end_eventServiceConfiguration (); + eventServiceConfiguration_const_iterator begin_eventServiceConfiguration () const; + eventServiceConfiguration_const_iterator end_eventServiceConfiguration () const; + void add_eventServiceConfiguration (::CIAO::Config_Handlers::EventServiceDescription const& ); + size_t count_eventServiceConfiguration (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::EventServiceDescription > eventServiceConfiguration_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + CIAOEventsDef (); + + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + CIAOEventsDef (CIAOEventsDef const& s); + + CIAOEventsDef& + operator= (CIAOEventsDef const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export EventServiceDescription : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // node + // + public: + ::XMLSchema::string< ACE_TCHAR > const& node () const; + void node (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > node_; + + // type + // + public: + ::CIAO::Config_Handlers::EventServiceType const& type () const; + void type (::CIAO::Config_Handlers::EventServiceType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::EventServiceType > type_; + + // svc_cfg_file + // + public: + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file () const; + void svc_cfg_file (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > svc_cfg_file_; + + // filter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Filter >::iterator filter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Filter >::const_iterator filter_const_iterator; + filter_iterator begin_filter (); + filter_iterator end_filter (); + filter_const_iterator begin_filter () const; + filter_const_iterator end_filter () const; + void add_filter (::CIAO::Config_Handlers::Filter const& ); + size_t count_filter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Filter > filter_; + + // addr_serv + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::AddressServerDescription >::iterator addr_serv_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::AddressServerDescription >::const_iterator addr_serv_const_iterator; + addr_serv_iterator begin_addr_serv (); + addr_serv_iterator end_addr_serv (); + addr_serv_const_iterator begin_addr_serv () const; + addr_serv_const_iterator end_addr_serv () const; + void add_addr_serv (::CIAO::Config_Handlers::AddressServerDescription const& ); + size_t count_addr_serv (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::AddressServerDescription > addr_serv_; + + // udp_sender + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription >::iterator udp_sender_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription >::const_iterator udp_sender_const_iterator; + udp_sender_iterator begin_udp_sender (); + udp_sender_iterator end_udp_sender (); + udp_sender_const_iterator begin_udp_sender () const; + udp_sender_const_iterator end_udp_sender () const; + void add_udp_sender (::CIAO::Config_Handlers::UDPSenderDescription const& ); + size_t count_udp_sender (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription > udp_sender_; + + // udp_receiver + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription >::iterator udp_receiver_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription >::const_iterator udp_receiver_const_iterator; + udp_receiver_iterator begin_udp_receiver (); + udp_receiver_iterator end_udp_receiver (); + udp_receiver_const_iterator begin_udp_receiver () const; + udp_receiver_const_iterator end_udp_receiver () const; + void add_udp_receiver (::CIAO::Config_Handlers::UDPReceiverDescription const& ); + size_t count_udp_receiver (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription > udp_receiver_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + EventServiceDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::CIAO::Config_Handlers::EventServiceType const& type__, + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file__); + + EventServiceDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + EventServiceDescription (EventServiceDescription const& s); + + EventServiceDescription& + operator= (EventServiceDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export FilterType : public ::XSCRT::Type + { + public: + FilterType (::XSCRT::XML::Element< ACE_TCHAR > const&); + FilterType (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static FilterType const CONJUNCTION; + static FilterType const DISJUNCTION; + static FilterType const LOGICAL_AND; + static FilterType const NEGATE; + + enum Value + { + CONJUNCTION_l,DISJUNCTION_l,LOGICAL_AND_l,NEGATE_l + }; + + + Value + integral () const; + + friend bool CIAO_Events_Handlers_Export + operator== (FilterType const& a, FilterType const& b); + + friend bool CIAO_Events_Handlers_Export + operator!= (FilterType const& a, FilterType const& b); + + private: + FilterType (Value v); + + Value v_; + }; + + bool CIAO_Events_Handlers_Export operator== (FilterType const &a, FilterType const &b); + + bool CIAO_Events_Handlers_Export operator!= (FilterType const &a, FilterType const &b); + + + class CIAO_Events_Handlers_Export Filter : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // type + // + public: + ::CIAO::Config_Handlers::FilterType const& type () const; + void type (::CIAO::Config_Handlers::FilterType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::FilterType > type_; + + // source + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator source_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_source (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > source_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + Filter (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::FilterType const& type__); + + Filter (::XSCRT::XML::Element< ACE_TCHAR > const&); + Filter (Filter const& s); + + Filter& + operator= (Filter const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export AddressServerDescription : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // port + // + public: + ::XMLSchema::unsignedShort const& port () const; + void port (::XMLSchema::unsignedShort const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedShort > port_; + + // address + // + public: + ::XMLSchema::string< ACE_TCHAR > const& address () const; + void address (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > address_; + + public: + AddressServerDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::unsignedShort const& port__, + ::XMLSchema::string< ACE_TCHAR > const& address__); + + AddressServerDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + AddressServerDescription (AddressServerDescription const& s); + + AddressServerDescription& + operator= (AddressServerDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export UDPSenderDescription : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // addr_serv_id + // + public: + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id () const; + void addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > addr_serv_id_; + + public: + UDPSenderDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id__); + + UDPSenderDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + UDPSenderDescription (UDPSenderDescription const& s); + + UDPSenderDescription& + operator= (UDPSenderDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export UDPReceiverDescription : public ::XSCRT::Type + { + //@@ VC6 anathema + typedef ::XSCRT::Type Base__; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // addr_serv_id + // + public: + bool addr_serv_id_p () const; + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id () const; + void addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > addr_serv_id_; + + // is_multicast + // + public: + ::XMLSchema::boolean const& is_multicast () const; + void is_multicast (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > is_multicast_; + + // listen_port + // + public: + ::XMLSchema::unsignedShort const& listen_port () const; + void listen_port (::XMLSchema::unsignedShort const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedShort > listen_port_; + + public: + UDPReceiverDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& is_multicast__, + ::XMLSchema::unsignedShort const& listen_port__); + + UDPReceiverDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + UDPReceiverDescription (UDPReceiverDescription const& s); + + UDPReceiverDescription& + operator= (UDPReceiverDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + CIAO_Events_Handlers_Export + ::CIAO::Config_Handlers::CIAOEventsDef + CIAOEvents (xercesc::DOMDocument const*); + } +} + +#endif // CIAOEVENTS_HPP diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp new file mode 100644 index 00000000000..fd7cb12a464 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp @@ -0,0 +1,197 @@ +// $Id$ +#include "Utils/XML_Helper.h" +#include "CIAOEvents_Handler.h" +#include "CIAOEvents.hpp" +#include "ciao/Deployment_EventsC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + CIAOEvents_Handler::CIAOEvents_Handler (const ACE_TCHAR *file) : + idl_esd_(0), + esd_(0), + retval_ (false) + { + XML_Helper helper; + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + helper.create_dom (file); + + if (!dom) + throw CIAOEvents_Handler::NoESD (); + + this->esd_.reset (new CIAOEventsDef + (CIAOEvents (dom))); + + if (!this->build_esd ()) + throw NoESD (); + } + + CIAOEvents_Handler::CIAOEvents_Handler (CIAOEventsDef *esd): + idl_esd_(0), + esd_(esd), + retval_(false) + { + if(!this->build_esd()) + throw NoESD (); + } + + + CIAOEvents_Handler::~CIAOEvents_Handler (void) + { + } + + bool + CIAOEvents_Handler::build_esd () + { + this->idl_esd_.reset ( new ::CIAO::DAnCE::EventServiceDeploymentDescriptions ); + + + this->idl_esd_->length (this->esd_->count_eventServiceConfiguration ()); + CORBA::ULong pos_i = 0; + for (CIAOEventsDef::eventServiceConfiguration_const_iterator i = this->esd_->begin_eventServiceConfiguration (); + i != this->esd_->end_eventServiceConfiguration (); + i++) + { + CIAO::DAnCE::EventServiceDeploymentDescription a_esd; + + a_esd.name = CORBA::string_dup (i->name ().c_str ()); + a_esd.node = CORBA::string_dup (i->node ().c_str ()); + + switch (i->type ().integral ()) + { + case ::CIAO::Config_Handlers::EventServiceType::EC_l: + a_esd.type = CIAO::EC; + break; + case ::CIAO::Config_Handlers::EventServiceType::NOTIFY_l: + a_esd.type = CIAO::NOTIFY; + break; + case ::CIAO::Config_Handlers::EventServiceType::RTEC_l: + a_esd.type = CIAO::RTEC; + break; + case ::CIAO::Config_Handlers::EventServiceType::RTNOTIFY_l: + a_esd.type = CIAO::RTNOTIFY; + break; + default: + ACE_ERROR ((LM_ERROR, + "Invalid event service type\n")); + return false; + } + + a_esd.svc_cfg_file = CORBA::string_dup (i->svc_cfg_file ().c_str ()); + + + // Populate filtering information for this event channel + a_esd.filters.length (i->count_filter ()); + CORBA::ULong pos_j = 0; + for (EventServiceDescription::filter_const_iterator j = i->begin_filter (); + j != i->end_filter (); + j++) + { + a_esd.filters[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + switch (j->type ().integral ()) + { + case ::CIAO::Config_Handlers::FilterType::CONJUNCTION_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::CONJUNCTION; + break; + case ::CIAO::Config_Handlers::FilterType::DISJUNCTION_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::DISJUNCTION; + break; + case ::CIAO::Config_Handlers::FilterType::LOGICAL_AND_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::LOGICAL_AND; + break; + case ::CIAO::Config_Handlers::FilterType::NEGATE_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::NEGATE; + break; + default: + ACE_ERROR ((LM_ERROR, + "Invalid filter type\n")); + return false; + } + + a_esd.filters[pos_j].sources.length (j->count_source ()); + CORBA::ULong pos_k = 0; + for (Filter::source_const_iterator k = j->begin_source (); + k != j->end_source (); + k++) + { + a_esd.filters[pos_j].sources[pos_k] = CORBA::string_dup (k->c_str ()); + pos_k++; + + } + pos_j++; + } + + // Populate address server information for this event channel + a_esd.addr_servs.length (i->count_addr_serv ()); + pos_j = 0; + for (EventServiceDescription::addr_serv_const_iterator j = i->begin_addr_serv (); + j != i->end_addr_serv (); + j++) + { + a_esd.addr_servs[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.addr_servs[pos_j].port = j->port (); + a_esd.addr_servs[pos_j].address = CORBA::string_dup (j->address ().c_str ()); + pos_j++; + } + + // Populate UDP sender information for this event channel + a_esd.senders.length (i->count_udp_sender ()); + pos_j = 0; + for (EventServiceDescription::udp_sender_const_iterator j = i->begin_udp_sender (); + j != i->end_udp_sender (); + j++) + { + a_esd.senders[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.senders[pos_j].addr_serv_id = + CORBA::string_dup (j->addr_serv_id ().c_str ()); + pos_j++; + } + + // Populate UDP receiver information for this event channel + a_esd.receivers.length (i->count_udp_receiver ()); + pos_j = 0; + for (EventServiceDescription::udp_receiver_const_iterator j = i->begin_udp_receiver (); + j != i->end_udp_receiver (); + j++) + { + a_esd.receivers[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.receivers[pos_j].addr_serv_id = + CORBA::string_dup (j->addr_serv_id ().c_str ()); + a_esd.receivers[pos_j].is_multicast = j->is_multicast (); + a_esd.receivers[pos_j].listen_port = j->listen_port (); + pos_j++; + } + + (*this->idl_esd_)[pos_i] = a_esd; + pos_i++; + } + return true; + } + + + ::CIAO::DAnCE::EventServiceDeploymentDescriptions const * + CIAOEvents_Handler::esd_idl () const + throw (CIAOEvents_Handler::NoESD) + { + if(!this->idl_esd_.get()) + throw NoESD (); + + //else + return this->idl_esd_.get(); + } + + ::CIAO::DAnCE::EventServiceDeploymentDescriptions * + CIAOEvents_Handler::esd_idl () + throw (CIAOEvents_Handler::NoESD) + { + if(!this->idl_esd_.get()) + throw NoESD(); + + //else + return this->idl_esd_.release(); + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h new file mode 100644 index 00000000000..7a27aa76a64 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h @@ -0,0 +1,74 @@ +//================================================ +/** + * @file CIAOEvents_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Utils/XML_Helper.h" +#include "ciao/Deployment_EventsC.h" +#include "CIAO_Events_Handlers_Export.h" +#include "ciao/DeploymentC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO +{ + namespace Config_Handlers + { + class CIAOEventsDef; + + /* + * @class CIAOEvents_Handler + * + * @brief Handler class for <CIAOEvents> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class CIAO_Events_Handlers_Export CIAOEvents_Handler + { + + public: + class NoESD {}; + + CIAOEvents_Handler (const ACE_TCHAR *file); + + CIAOEvents_Handler(CIAOEventsDef *esd); + + ~CIAOEvents_Handler (void); + + CIAO::DAnCE::EventServiceDeploymentDescriptions const *esd_idl (void) const + throw (CIAOEvents_Handler::NoESD); + + CIAO::DAnCE::EventServiceDeploymentDescriptions *esd_idl (void) + throw (CIAOEvents_Handler::NoESD); + + private: + bool build_esd (); + + auto_ptr <CIAO::DAnCE::EventServiceDeploymentDescriptions > idl_esd_; + + auto_ptr <CIAOEventsDef> esd_; + + bool retval_; + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc new file mode 100644 index 00000000000..395b76fd09e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc @@ -0,0 +1,28 @@ +//$Id$ + +project (CIAO_Events_Handlers) : acelib, ciao_xml_utils, ciao_events_dnc, ciao_deployment_stub { + sharedname = CIAO_Events_Handlers + dynamicflags = CIAO_EVENTS_HANDLERS_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + + Source_Files { + CIAOEvents.cpp + CIAOEvents_Handler.cpp + } + + Header_Files { + } +} + +project (CIAO_Events_Handlers_Tests) : ciao_xml_utils, ciao_server_dnc { + exename = test + after += CIAO_Events_Handlers + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + libs += CIAO_Events_Handlers + + Source_Files { + test.cpp + } +} diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h new file mode 100644 index 00000000000..efe95849905 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl -n CIAO_Events_Handlers +// ------------------------------ +#ifndef CIAO_EVENTS_HANDLERS_EXPORT_H +#define CIAO_EVENTS_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (CIAO_EVENTS_HANDLERS_HAS_DLL) +# define CIAO_EVENTS_HANDLERS_HAS_DLL 1 +#endif /* ! CIAO_EVENTS_HANDLERS_HAS_DLL */ + +#if defined (CIAO_EVENTS_HANDLERS_HAS_DLL) && (CIAO_EVENTS_HANDLERS_HAS_DLL == 1) +# if defined (CIAO_EVENTS_HANDLERS_BUILD_DLL) +# define CIAO_Events_Handlers_Export ACE_Proper_Export_Flag +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CIAO_EVENTS_HANDLERS_BUILD_DLL */ +# define CIAO_Events_Handlers_Export ACE_Proper_Import_Flag +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CIAO_EVENTS_HANDLERS_BUILD_DLL */ +#else /* CIAO_EVENTS_HANDLERS_HAS_DLL == 1 */ +# define CIAO_Events_Handlers_Export +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CIAO_EVENTS_HANDLERS_HAS_DLL == 1 */ + +// Set CIAO_EVENTS_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CIAO_EVENTS_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define CIAO_EVENTS_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CIAO_EVENTS_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CIAO_EVENTS_HANDLERS_NTRACE */ + +#if (CIAO_EVENTS_HANDLERS_NTRACE == 1) +# define CIAO_EVENTS_HANDLERS_TRACE(X) +#else /* (CIAO_EVENTS_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CIAO_EVENTS_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CIAO_EVENTS_HANDLERS_NTRACE == 1) */ + +#endif /* CIAO_EVENTS_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp b/modules/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp new file mode 100644 index 00000000000..63c024a0a89 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp @@ -0,0 +1,58 @@ +// $Id$ + +#include <iostream> + +#include "CIAOEvents.hpp" +#include "CIAOEvents_Handler.h" +#include "ciao/Deployment_EventsC.h" + +#include "ace/Get_Opt.h" +#include "tao/ORB.h" + +static const char *input_file = "test.ced"; + + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "i:"); + + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'i': + input_file = get_opts.opt_arg (); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-i <input file> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command-line + return 0; +} + +using namespace CIAO::Config_Handlers; + +int main (int argc, char *argv[]) +{ + + if (parse_args (argc, argv) != 0) + return 1; + + CIAOEvents_Handler event_handler (input_file); + // Convert XSC to idl datatype + + std::cout << "Instance document import succeeded. Dumping contents to file\n"; + + std::cout << "Test completed!"; + + return 0; + +} |