diff options
Diffstat (limited to 'CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp')
| -rw-r--r-- | CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp | 16440 |
1 files changed, 16440 insertions, 0 deletions
diff --git a/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp new file mode 100644 index 00000000000..969cbc06c53 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp @@ -0,0 +1,16440 @@ +/* $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 "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // TCKind + // + + TCKind::Value TCKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::TCKind const& a, ::CIAO::Config_Handlers::TCKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::TCKind const& a, ::CIAO::Config_Handlers::TCKind const& b) + { + return a.v_ != b.v_; + } + + TCKind:: + TCKind (TCKind::Value v) + : v_ (v) + { + } + + // DataType + // + + DataType:: + DataType (::CIAO::Config_Handlers::TCKind const& kind__) + : + ::XSCRT::Type (), + kind_ (new ::CIAO::Config_Handlers::TCKind (kind__)), + regulator__ () + { + kind_->container (this); + } + + DataType:: + DataType (::CIAO::Config_Handlers::DataType const& s) + : + ::XSCRT::Type (), + kind_ (new ::CIAO::Config_Handlers::TCKind (*s.kind_)), + enum__ (s.enum__.get () ? new ::CIAO::Config_Handlers::EnumType (*s.enum__) : 0), + struct__ (s.struct__.get () ? new ::CIAO::Config_Handlers::StructType (*s.struct__) : 0), + value_ (s.value_.get () ? new ::CIAO::Config_Handlers::ValueType (*s.value_) : 0), + sequence_ (s.sequence_.get () ? new ::CIAO::Config_Handlers::SequenceType (*s.sequence_) : 0), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + kind_->container (this); + if (enum__.get ()) enum__->container (this); + if (struct__.get ()) struct__->container (this); + if (value_.get ()) value_->container (this); + if (sequence_.get ()) sequence_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::DataType& DataType:: + operator= (::CIAO::Config_Handlers::DataType const& s) + { + kind (s.kind ()); + + if (s.enum__.get ()) enum_ (*(s.enum__)); + else enum__ = ::std::auto_ptr< ::CIAO::Config_Handlers::EnumType > (0); + + if (s.struct__.get ()) struct_ (*(s.struct__)); + else struct__ = ::std::auto_ptr< ::CIAO::Config_Handlers::StructType > (0); + + if (s.value_.get ()) value (*(s.value_)); + else value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ValueType > (0); + + if (s.sequence_.get ()) sequence (*(s.sequence_)); + else sequence_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SequenceType > (0); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // DataType + // + ::CIAO::Config_Handlers::TCKind const& DataType:: + kind () const + { + return *kind_; + } + + void DataType:: + kind (::CIAO::Config_Handlers::TCKind const& e) + { + *kind_ = e; + } + + // DataType + // + bool DataType:: + enum_p () const + { + return enum__.get () != 0; + } + + ::CIAO::Config_Handlers::EnumType const& DataType:: + enum_ () const + { + return *enum__; + } + + void DataType:: + enum_ (::CIAO::Config_Handlers::EnumType const& e) + { + if (enum__.get ()) + { + *enum__ = e; + } + + else + { + enum__ = ::std::auto_ptr< ::CIAO::Config_Handlers::EnumType > (new ::CIAO::Config_Handlers::EnumType (e)); + enum__->container (this); + } + } + + // DataType + // + bool DataType:: + struct_p () const + { + return struct__.get () != 0; + } + + ::CIAO::Config_Handlers::StructType const& DataType:: + struct_ () const + { + return *struct__; + } + + void DataType:: + struct_ (::CIAO::Config_Handlers::StructType const& e) + { + if (struct__.get ()) + { + *struct__ = e; + } + + else + { + struct__ = ::std::auto_ptr< ::CIAO::Config_Handlers::StructType > (new ::CIAO::Config_Handlers::StructType (e)); + struct__->container (this); + } + } + + // DataType + // + bool DataType:: + value_p () const + { + return value_.get () != 0; + } + + ::CIAO::Config_Handlers::ValueType const& DataType:: + value () const + { + return *value_; + } + + void DataType:: + value (::CIAO::Config_Handlers::ValueType const& e) + { + if (value_.get ()) + { + *value_ = e; + } + + else + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ValueType > (new ::CIAO::Config_Handlers::ValueType (e)); + value_->container (this); + } + } + + // DataType + // + bool DataType:: + sequence_p () const + { + return sequence_.get () != 0; + } + + ::CIAO::Config_Handlers::SequenceType const& DataType:: + sequence () const + { + return *sequence_; + } + + void DataType:: + sequence (::CIAO::Config_Handlers::SequenceType const& e) + { + if (sequence_.get ()) + { + *sequence_ = e; + } + + else + { + sequence_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SequenceType > (new ::CIAO::Config_Handlers::SequenceType (e)); + sequence_->container (this); + } + } + + // DataType + // + bool DataType:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& DataType:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& DataType:: + id () + { + return *id_; + } + + void DataType:: + 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); + } + } + + + // DataValue + // + + DataValue:: + DataValue () + : + ::XSCRT::Type (), + regulator__ () + { + } + + DataValue:: + DataValue (::CIAO::Config_Handlers::DataValue const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (short_const_iterator i (s.short_.begin ());i != s.short_.end ();++i) add_short (*i); + } + + { + for (long_const_iterator i (s.long_.begin ());i != s.long_.end ();++i) add_long (*i); + } + + { + for (ushort_const_iterator i (s.ushort_.begin ());i != s.ushort_.end ();++i) add_ushort (*i); + } + + { + for (ulong_const_iterator i (s.ulong_.begin ());i != s.ulong_.end ();++i) add_ulong (*i); + } + + { + for (float_const_iterator i (s.float_.begin ());i != s.float_.end ();++i) add_float (*i); + } + + { + for (double_const_iterator i (s.double_.begin ());i != s.double_.end ();++i) add_double (*i); + } + + { + for (boolean_const_iterator i (s.boolean_.begin ());i != s.boolean_.end ();++i) add_boolean (*i); + } + + { + for (octet_const_iterator i (s.octet_.begin ());i != s.octet_.end ();++i) add_octet (*i); + } + + { + for (enum_const_iterator i (s.enum_.begin ());i != s.enum_.end ();++i) add_enum (*i); + } + + { + for (string_const_iterator i (s.string_.begin ());i != s.string_.end ();++i) add_string (*i); + } + + { + for (longlong_const_iterator i (s.longlong_.begin ());i != s.longlong_.end ();++i) add_longlong (*i); + } + + { + for (ulonglong_const_iterator i (s.ulonglong_.begin ());i != s.ulonglong_.end ();++i) add_ulonglong (*i); + } + + { + for (longdouble_const_iterator i (s.longdouble_.begin ());i != s.longdouble_.end ();++i) add_longdouble (*i); + } + + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::DataValue& DataValue:: + operator= (::CIAO::Config_Handlers::DataValue const& s) + { + short_.clear (); + { + for (short_const_iterator i (s.short_.begin ());i != s.short_.end ();++i) add_short (*i); + } + + long_.clear (); + { + for (long_const_iterator i (s.long_.begin ());i != s.long_.end ();++i) add_long (*i); + } + + ushort_.clear (); + { + for (ushort_const_iterator i (s.ushort_.begin ());i != s.ushort_.end ();++i) add_ushort (*i); + } + + ulong_.clear (); + { + for (ulong_const_iterator i (s.ulong_.begin ());i != s.ulong_.end ();++i) add_ulong (*i); + } + + float_.clear (); + { + for (float_const_iterator i (s.float_.begin ());i != s.float_.end ();++i) add_float (*i); + } + + double_.clear (); + { + for (double_const_iterator i (s.double_.begin ());i != s.double_.end ();++i) add_double (*i); + } + + boolean_.clear (); + { + for (boolean_const_iterator i (s.boolean_.begin ());i != s.boolean_.end ();++i) add_boolean (*i); + } + + octet_.clear (); + { + for (octet_const_iterator i (s.octet_.begin ());i != s.octet_.end ();++i) add_octet (*i); + } + + enum_.clear (); + { + for (enum_const_iterator i (s.enum_.begin ());i != s.enum_.end ();++i) add_enum (*i); + } + + string_.clear (); + { + for (string_const_iterator i (s.string_.begin ());i != s.string_.end ();++i) add_string (*i); + } + + longlong_.clear (); + { + for (longlong_const_iterator i (s.longlong_.begin ());i != s.longlong_.end ();++i) add_longlong (*i); + } + + ulonglong_.clear (); + { + for (ulonglong_const_iterator i (s.ulonglong_.begin ());i != s.ulonglong_.end ();++i) add_ulonglong (*i); + } + + longdouble_.clear (); + { + for (longdouble_const_iterator i (s.longdouble_.begin ());i != s.longdouble_.end ();++i) add_longdouble (*i); + } + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // DataValue + // + DataValue::short_iterator DataValue:: + begin_short () + { + return short_.begin (); + } + + DataValue::short_iterator DataValue:: + end_short () + { + return short_.end (); + } + + DataValue::short_const_iterator DataValue:: + begin_short () const + { + return short_.begin (); + } + + DataValue::short_const_iterator DataValue:: + end_short () const + { + return short_.end (); + } + + void DataValue:: + add_short (::XMLSchema::short_ const& e) + { + short_.push_back (e); + } + + size_t DataValue:: + count_short(void) const + { + return short_.size (); + } + + // DataValue + // + DataValue::long_iterator DataValue:: + begin_long () + { + return long_.begin (); + } + + DataValue::long_iterator DataValue:: + end_long () + { + return long_.end (); + } + + DataValue::long_const_iterator DataValue:: + begin_long () const + { + return long_.begin (); + } + + DataValue::long_const_iterator DataValue:: + end_long () const + { + return long_.end (); + } + + void DataValue:: + add_long (::XMLSchema::int_ const& e) + { + long_.push_back (e); + } + + size_t DataValue:: + count_long(void) const + { + return long_.size (); + } + + // DataValue + // + DataValue::ushort_iterator DataValue:: + begin_ushort () + { + return ushort_.begin (); + } + + DataValue::ushort_iterator DataValue:: + end_ushort () + { + return ushort_.end (); + } + + DataValue::ushort_const_iterator DataValue:: + begin_ushort () const + { + return ushort_.begin (); + } + + DataValue::ushort_const_iterator DataValue:: + end_ushort () const + { + return ushort_.end (); + } + + void DataValue:: + add_ushort (::XMLSchema::unsignedShort const& e) + { + ushort_.push_back (e); + } + + size_t DataValue:: + count_ushort(void) const + { + return ushort_.size (); + } + + // DataValue + // + DataValue::ulong_iterator DataValue:: + begin_ulong () + { + return ulong_.begin (); + } + + DataValue::ulong_iterator DataValue:: + end_ulong () + { + return ulong_.end (); + } + + DataValue::ulong_const_iterator DataValue:: + begin_ulong () const + { + return ulong_.begin (); + } + + DataValue::ulong_const_iterator DataValue:: + end_ulong () const + { + return ulong_.end (); + } + + void DataValue:: + add_ulong (::XMLSchema::unsignedInt const& e) + { + ulong_.push_back (e); + } + + size_t DataValue:: + count_ulong(void) const + { + return ulong_.size (); + } + + // DataValue + // + DataValue::float_iterator DataValue:: + begin_float () + { + return float_.begin (); + } + + DataValue::float_iterator DataValue:: + end_float () + { + return float_.end (); + } + + DataValue::float_const_iterator DataValue:: + begin_float () const + { + return float_.begin (); + } + + DataValue::float_const_iterator DataValue:: + end_float () const + { + return float_.end (); + } + + void DataValue:: + add_float (::XMLSchema::float_ const& e) + { + float_.push_back (e); + } + + size_t DataValue:: + count_float(void) const + { + return float_.size (); + } + + // DataValue + // + DataValue::double_iterator DataValue:: + begin_double () + { + return double_.begin (); + } + + DataValue::double_iterator DataValue:: + end_double () + { + return double_.end (); + } + + DataValue::double_const_iterator DataValue:: + begin_double () const + { + return double_.begin (); + } + + DataValue::double_const_iterator DataValue:: + end_double () const + { + return double_.end (); + } + + void DataValue:: + add_double (::XMLSchema::double_ const& e) + { + double_.push_back (e); + } + + size_t DataValue:: + count_double(void) const + { + return double_.size (); + } + + // DataValue + // + DataValue::boolean_iterator DataValue:: + begin_boolean () + { + return boolean_.begin (); + } + + DataValue::boolean_iterator DataValue:: + end_boolean () + { + return boolean_.end (); + } + + DataValue::boolean_const_iterator DataValue:: + begin_boolean () const + { + return boolean_.begin (); + } + + DataValue::boolean_const_iterator DataValue:: + end_boolean () const + { + return boolean_.end (); + } + + void DataValue:: + add_boolean (::XMLSchema::boolean const& e) + { + boolean_.push_back (e); + } + + size_t DataValue:: + count_boolean(void) const + { + return boolean_.size (); + } + + // DataValue + // + DataValue::octet_iterator DataValue:: + begin_octet () + { + return octet_.begin (); + } + + DataValue::octet_iterator DataValue:: + end_octet () + { + return octet_.end (); + } + + DataValue::octet_const_iterator DataValue:: + begin_octet () const + { + return octet_.begin (); + } + + DataValue::octet_const_iterator DataValue:: + end_octet () const + { + return octet_.end (); + } + + void DataValue:: + add_octet (::XMLSchema::unsignedByte const& e) + { + octet_.push_back (e); + } + + size_t DataValue:: + count_octet(void) const + { + return octet_.size (); + } + + // DataValue + // + DataValue::enum_iterator DataValue:: + begin_enum () + { + return enum_.begin (); + } + + DataValue::enum_iterator DataValue:: + end_enum () + { + return enum_.end (); + } + + DataValue::enum_const_iterator DataValue:: + begin_enum () const + { + return enum_.begin (); + } + + DataValue::enum_const_iterator DataValue:: + end_enum () const + { + return enum_.end (); + } + + void DataValue:: + add_enum (::XMLSchema::string< ACE_TCHAR > const& e) + { + enum_.push_back (e); + } + + size_t DataValue:: + count_enum(void) const + { + return enum_.size (); + } + + // DataValue + // + DataValue::string_iterator DataValue:: + begin_string () + { + return string_.begin (); + } + + DataValue::string_iterator DataValue:: + end_string () + { + return string_.end (); + } + + DataValue::string_const_iterator DataValue:: + begin_string () const + { + return string_.begin (); + } + + DataValue::string_const_iterator DataValue:: + end_string () const + { + return string_.end (); + } + + void DataValue:: + add_string (::XMLSchema::string< ACE_TCHAR > const& e) + { + string_.push_back (e); + } + + size_t DataValue:: + count_string(void) const + { + return string_.size (); + } + + // DataValue + // + DataValue::longlong_iterator DataValue:: + begin_longlong () + { + return longlong_.begin (); + } + + DataValue::longlong_iterator DataValue:: + end_longlong () + { + return longlong_.end (); + } + + DataValue::longlong_const_iterator DataValue:: + begin_longlong () const + { + return longlong_.begin (); + } + + DataValue::longlong_const_iterator DataValue:: + end_longlong () const + { + return longlong_.end (); + } + + void DataValue:: + add_longlong (::XMLSchema::long_ const& e) + { + longlong_.push_back (e); + } + + size_t DataValue:: + count_longlong(void) const + { + return longlong_.size (); + } + + // DataValue + // + DataValue::ulonglong_iterator DataValue:: + begin_ulonglong () + { + return ulonglong_.begin (); + } + + DataValue::ulonglong_iterator DataValue:: + end_ulonglong () + { + return ulonglong_.end (); + } + + DataValue::ulonglong_const_iterator DataValue:: + begin_ulonglong () const + { + return ulonglong_.begin (); + } + + DataValue::ulonglong_const_iterator DataValue:: + end_ulonglong () const + { + return ulonglong_.end (); + } + + void DataValue:: + add_ulonglong (::XMLSchema::unsignedLong const& e) + { + ulonglong_.push_back (e); + } + + size_t DataValue:: + count_ulonglong(void) const + { + return ulonglong_.size (); + } + + // DataValue + // + DataValue::longdouble_iterator DataValue:: + begin_longdouble () + { + return longdouble_.begin (); + } + + DataValue::longdouble_iterator DataValue:: + end_longdouble () + { + return longdouble_.end (); + } + + DataValue::longdouble_const_iterator DataValue:: + begin_longdouble () const + { + return longdouble_.begin (); + } + + DataValue::longdouble_const_iterator DataValue:: + end_longdouble () const + { + return longdouble_.end (); + } + + void DataValue:: + add_longdouble (::XMLSchema::double_ const& e) + { + longdouble_.push_back (e); + } + + size_t DataValue:: + count_longdouble(void) const + { + return longdouble_.size (); + } + + // DataValue + // + DataValue::member_iterator DataValue:: + begin_member () + { + return member_.begin (); + } + + DataValue::member_iterator DataValue:: + end_member () + { + return member_.end (); + } + + DataValue::member_const_iterator DataValue:: + begin_member () const + { + return member_.begin (); + } + + DataValue::member_const_iterator DataValue:: + end_member () const + { + return member_.end (); + } + + void DataValue:: + add_member (::CIAO::Config_Handlers::NamedValue const& e) + { + member_.push_back (e); + } + + size_t DataValue:: + count_member(void) const + { + return member_.size (); + } + + + // EnumType + // + + EnumType:: + EnumType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + EnumType:: + EnumType (::CIAO::Config_Handlers::EnumType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::EnumType& EnumType:: + operator= (::CIAO::Config_Handlers::EnumType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // EnumType + // + ::XMLSchema::string< ACE_TCHAR > const& EnumType:: + name () const + { + return *name_; + } + + void EnumType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // EnumType + // + ::XMLSchema::string< ACE_TCHAR > const& EnumType:: + typeId () const + { + return *typeId_; + } + + void EnumType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // EnumType + // + EnumType::member_iterator EnumType:: + begin_member () + { + return member_.begin (); + } + + EnumType::member_iterator EnumType:: + end_member () + { + return member_.end (); + } + + EnumType::member_const_iterator EnumType:: + begin_member () const + { + return member_.begin (); + } + + EnumType::member_const_iterator EnumType:: + end_member () const + { + return member_.end (); + } + + void EnumType:: + add_member (::XMLSchema::string< ACE_TCHAR > const& e) + { + member_.push_back (e); + } + + size_t EnumType:: + count_member(void) const + { + return member_.size (); + } + + + // StructType + // + + StructType:: + StructType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + StructType:: + StructType (::CIAO::Config_Handlers::StructType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::StructType& StructType:: + operator= (::CIAO::Config_Handlers::StructType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // StructType + // + ::XMLSchema::string< ACE_TCHAR > const& StructType:: + name () const + { + return *name_; + } + + void StructType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // StructType + // + ::XMLSchema::string< ACE_TCHAR > const& StructType:: + typeId () const + { + return *typeId_; + } + + void StructType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // StructType + // + StructType::member_iterator StructType:: + begin_member () + { + return member_.begin (); + } + + StructType::member_iterator StructType:: + end_member () + { + return member_.end (); + } + + StructType::member_const_iterator StructType:: + begin_member () const + { + return member_.begin (); + } + + StructType::member_const_iterator StructType:: + end_member () const + { + return member_.end (); + } + + void StructType:: + add_member (::CIAO::Config_Handlers::StructMemberType const& e) + { + member_.push_back (e); + } + + size_t StructType:: + count_member(void) const + { + return member_.size (); + } + + + // StructMemberType + // + + StructMemberType:: + StructMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + StructMemberType:: + StructMemberType (::CIAO::Config_Handlers::StructMemberType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::StructMemberType& StructMemberType:: + operator= (::CIAO::Config_Handlers::StructMemberType const& s) + { + name (s.name ()); + + type (s.type ()); + + return *this; + } + + + // StructMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& StructMemberType:: + name () const + { + return *name_; + } + + void StructMemberType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // StructMemberType + // + ::CIAO::Config_Handlers::DataType const& StructMemberType:: + type () const + { + return *type_; + } + + void StructMemberType:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // ValueType + // + + ValueType:: + ValueType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::XMLSchema::string< ACE_TCHAR > const& modifier__, + ::CIAO::Config_Handlers::DataType const& baseType__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + modifier_ (new ::XMLSchema::string< ACE_TCHAR > (modifier__)), + baseType_ (new ::CIAO::Config_Handlers::DataType (baseType__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + modifier_->container (this); + baseType_->container (this); + } + + ValueType:: + ValueType (::CIAO::Config_Handlers::ValueType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + modifier_ (new ::XMLSchema::string< ACE_TCHAR > (*s.modifier_)), + baseType_ (new ::CIAO::Config_Handlers::DataType (*s.baseType_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + modifier_->container (this); + baseType_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::ValueType& ValueType:: + operator= (::CIAO::Config_Handlers::ValueType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + modifier (s.modifier ()); + + baseType (s.baseType ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + name () const + { + return *name_; + } + + void ValueType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + typeId () const + { + return *typeId_; + } + + void ValueType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + modifier () const + { + return *modifier_; + } + + void ValueType:: + modifier (::XMLSchema::string< ACE_TCHAR > const& e) + { + *modifier_ = e; + } + + // ValueType + // + ::CIAO::Config_Handlers::DataType const& ValueType:: + baseType () const + { + return *baseType_; + } + + void ValueType:: + baseType (::CIAO::Config_Handlers::DataType const& e) + { + *baseType_ = e; + } + + // ValueType + // + ValueType::member_iterator ValueType:: + begin_member () + { + return member_.begin (); + } + + ValueType::member_iterator ValueType:: + end_member () + { + return member_.end (); + } + + ValueType::member_const_iterator ValueType:: + begin_member () const + { + return member_.begin (); + } + + ValueType::member_const_iterator ValueType:: + end_member () const + { + return member_.end (); + } + + void ValueType:: + add_member (::CIAO::Config_Handlers::ValueMemberType const& e) + { + member_.push_back (e); + } + + size_t ValueType:: + count_member(void) const + { + return member_.size (); + } + + + // ValueMemberType + // + + ValueMemberType:: + ValueMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& visibility__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + visibility_ (new ::XMLSchema::string< ACE_TCHAR > (visibility__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + visibility_->container (this); + type_->container (this); + } + + ValueMemberType:: + ValueMemberType (::CIAO::Config_Handlers::ValueMemberType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + visibility_ (new ::XMLSchema::string< ACE_TCHAR > (*s.visibility_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + visibility_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::ValueMemberType& ValueMemberType:: + operator= (::CIAO::Config_Handlers::ValueMemberType const& s) + { + name (s.name ()); + + visibility (s.visibility ()); + + type (s.type ()); + + return *this; + } + + + // ValueMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueMemberType:: + name () const + { + return *name_; + } + + void ValueMemberType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ValueMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueMemberType:: + visibility () const + { + return *visibility_; + } + + void ValueMemberType:: + visibility (::XMLSchema::string< ACE_TCHAR > const& e) + { + *visibility_ = e; + } + + // ValueMemberType + // + ::CIAO::Config_Handlers::DataType const& ValueMemberType:: + type () const + { + return *type_; + } + + void ValueMemberType:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // NamedValue + // + + NamedValue:: + NamedValue (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataValue const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + NamedValue:: + NamedValue (::CIAO::Config_Handlers::NamedValue const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + value_ (new ::CIAO::Config_Handlers::DataValue (*s.value_)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::NamedValue& NamedValue:: + operator= (::CIAO::Config_Handlers::NamedValue const& s) + { + name (s.name ()); + + value (s.value ()); + + return *this; + } + + + // NamedValue + // + ::XMLSchema::string< ACE_TCHAR > const& NamedValue:: + name () const + { + return *name_; + } + + void NamedValue:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // NamedValue + // + ::CIAO::Config_Handlers::DataValue const& NamedValue:: + value () const + { + return *value_; + } + + void NamedValue:: + value (::CIAO::Config_Handlers::DataValue const& e) + { + *value_ = e; + } + + + // SequenceType + // + + SequenceType:: + SequenceType (::CIAO::Config_Handlers::DataType const& elementType__) + : + ::XSCRT::Type (), + elementType_ (new ::CIAO::Config_Handlers::DataType (elementType__)), + regulator__ () + { + elementType_->container (this); + } + + SequenceType:: + SequenceType (::CIAO::Config_Handlers::SequenceType const& s) + : + ::XSCRT::Type (), + bound_ (s.bound_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.bound_) : 0), + elementType_ (new ::CIAO::Config_Handlers::DataType (*s.elementType_)), + regulator__ () + { + if (bound_.get ()) bound_->container (this); + elementType_->container (this); + } + + ::CIAO::Config_Handlers::SequenceType& SequenceType:: + operator= (::CIAO::Config_Handlers::SequenceType const& s) + { + if (s.bound_.get ()) bound (*(s.bound_)); + else bound_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + elementType (s.elementType ()); + + return *this; + } + + + // SequenceType + // + bool SequenceType:: + bound_p () const + { + return bound_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& SequenceType:: + bound () const + { + return *bound_; + } + + void SequenceType:: + bound (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (bound_.get ()) + { + *bound_ = e; + } + + else + { + bound_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + bound_->container (this); + } + } + + // SequenceType + // + ::CIAO::Config_Handlers::DataType const& SequenceType:: + elementType () const + { + return *elementType_; + } + + void SequenceType:: + elementType (::CIAO::Config_Handlers::DataType const& e) + { + *elementType_ = e; + } + + + // Any + // + + Any:: + Any (::CIAO::Config_Handlers::DataType const& type__, + ::CIAO::Config_Handlers::DataValue const& value__) + : + ::XSCRT::Type (), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + type_->container (this); + value_->container (this); + } + + Any:: + Any (::CIAO::Config_Handlers::Any const& s) + : + ::XSCRT::Type (), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + value_ (new ::CIAO::Config_Handlers::DataValue (*s.value_)), + regulator__ () + { + type_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::Any& Any:: + operator= (::CIAO::Config_Handlers::Any const& s) + { + type (s.type ()); + + value (s.value ()); + + return *this; + } + + + // Any + // + ::CIAO::Config_Handlers::DataType const& Any:: + type () const + { + return *type_; + } + + void Any:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + // Any + // + ::CIAO::Config_Handlers::DataValue const& Any:: + value () const + { + return *value_; + } + + void Any:: + value (::CIAO::Config_Handlers::DataValue const& e) + { + *value_ = e; + } + + + // Property + // + + Property:: + Property (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::Any const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::Any (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + Property:: + Property (::CIAO::Config_Handlers::Property const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + value_ (new ::CIAO::Config_Handlers::Any (*s.value_)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::Property& Property:: + operator= (::CIAO::Config_Handlers::Property const& s) + { + name (s.name ()); + + value (s.value ()); + + return *this; + } + + + // Property + // + ::XMLSchema::string< ACE_TCHAR > const& Property:: + name () const + { + return *name_; + } + + void Property:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Property + // + ::CIAO::Config_Handlers::Any const& Property:: + value () const + { + return *value_; + } + + void Property:: + value (::CIAO::Config_Handlers::Any const& e) + { + *value_ = e; + } + + + // SatisfierPropertyKind + // + + SatisfierPropertyKind::Value SatisfierPropertyKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::SatisfierPropertyKind const& a, ::CIAO::Config_Handlers::SatisfierPropertyKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::SatisfierPropertyKind const& a, ::CIAO::Config_Handlers::SatisfierPropertyKind const& b) + { + return a.v_ != b.v_; + } + + SatisfierPropertyKind:: + SatisfierPropertyKind (SatisfierPropertyKind::Value v) + : v_ (v) + { + } + + // SatisfierProperty + // + + SatisfierProperty:: + SatisfierProperty (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::SatisfierPropertyKind const& kind__, + ::XMLSchema::boolean const& dynamic__, + ::CIAO::Config_Handlers::Any const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind (kind__)), + dynamic_ (new ::XMLSchema::boolean (dynamic__)), + value_ (new ::CIAO::Config_Handlers::Any (value__)), + regulator__ () + { + name_->container (this); + kind_->container (this); + dynamic_->container (this); + value_->container (this); + } + + SatisfierProperty:: + SatisfierProperty (::CIAO::Config_Handlers::SatisfierProperty const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind (*s.kind_)), + dynamic_ (new ::XMLSchema::boolean (*s.dynamic_)), + value_ (new ::CIAO::Config_Handlers::Any (*s.value_)), + regulator__ () + { + name_->container (this); + kind_->container (this); + dynamic_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::SatisfierProperty& SatisfierProperty:: + operator= (::CIAO::Config_Handlers::SatisfierProperty const& s) + { + name (s.name ()); + + kind (s.kind ()); + + dynamic (s.dynamic ()); + + value (s.value ()); + + return *this; + } + + + // SatisfierProperty + // + ::XMLSchema::string< ACE_TCHAR > const& SatisfierProperty:: + name () const + { + return *name_; + } + + void SatisfierProperty:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // SatisfierProperty + // + ::CIAO::Config_Handlers::SatisfierPropertyKind const& SatisfierProperty:: + kind () const + { + return *kind_; + } + + void SatisfierProperty:: + kind (::CIAO::Config_Handlers::SatisfierPropertyKind const& e) + { + *kind_ = e; + } + + // SatisfierProperty + // + ::XMLSchema::boolean const& SatisfierProperty:: + dynamic () const + { + return *dynamic_; + } + + void SatisfierProperty:: + dynamic (::XMLSchema::boolean const& e) + { + *dynamic_ = e; + } + + // SatisfierProperty + // + ::CIAO::Config_Handlers::Any const& SatisfierProperty:: + value () const + { + return *value_; + } + + void SatisfierProperty:: + value (::CIAO::Config_Handlers::Any const& e) + { + *value_ = e; + } + + + // Resource + // + + Resource:: + Resource (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Resource:: + Resource (::CIAO::Config_Handlers::Resource const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Resource& Resource:: + operator= (::CIAO::Config_Handlers::Resource const& s) + { + name (s.name ()); + + resourceType_.clear (); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Resource + // + ::XMLSchema::string< ACE_TCHAR > const& Resource:: + name () const + { + return *name_; + } + + void Resource:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Resource + // + Resource::resourceType_iterator Resource:: + begin_resourceType () + { + return resourceType_.begin (); + } + + Resource::resourceType_iterator Resource:: + end_resourceType () + { + return resourceType_.end (); + } + + Resource::resourceType_const_iterator Resource:: + begin_resourceType () const + { + return resourceType_.begin (); + } + + Resource::resourceType_const_iterator Resource:: + end_resourceType () const + { + return resourceType_.end (); + } + + void Resource:: + add_resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + resourceType_.push_back (e); + } + + size_t Resource:: + count_resourceType(void) const + { + return resourceType_.size (); + } + + // Resource + // + Resource::property_iterator Resource:: + begin_property () + { + return property_.begin (); + } + + Resource::property_iterator Resource:: + end_property () + { + return property_.end (); + } + + Resource::property_const_iterator Resource:: + begin_property () const + { + return property_.begin (); + } + + Resource::property_const_iterator Resource:: + end_property () const + { + return property_.end (); + } + + void Resource:: + add_property (::CIAO::Config_Handlers::SatisfierProperty const& e) + { + property_.push_back (e); + } + + size_t Resource:: + count_property(void) const + { + return property_.size (); + } + + + // Requirement + // + + Requirement:: + Requirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + } + + Requirement:: + Requirement (::CIAO::Config_Handlers::Requirement const& s) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Requirement& Requirement:: + operator= (::CIAO::Config_Handlers::Requirement const& s) + { + resourceType (s.resourceType ()); + + name (s.name ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + resourceType () const + { + return *resourceType_; + } + + void Requirement:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = e; + } + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + name () const + { + return *name_; + } + + void Requirement:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Requirement + // + Requirement::property_iterator Requirement:: + begin_property () + { + return property_.begin (); + } + + Requirement::property_iterator Requirement:: + end_property () + { + return property_.end (); + } + + Requirement::property_const_iterator Requirement:: + begin_property () const + { + return property_.begin (); + } + + Requirement::property_const_iterator Requirement:: + end_property () const + { + return property_.end (); + } + + void Requirement:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t Requirement:: + count_property(void) const + { + return property_.size (); + } + + + // ResourceDeploymentDescription + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + } + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ResourceDeploymentDescription& ResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s) + { + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void ResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // ResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void ResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // ResourceDeploymentDescription + // + ResourceDeploymentDescription::property_iterator ResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + ResourceDeploymentDescription::property_iterator ResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + ResourceDeploymentDescription::property_const_iterator ResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + ResourceDeploymentDescription::property_const_iterator ResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void ResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // ArtifactDeploymentDescription + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + regulator__ () + { + name_->container (this); + node_->container (this); + } + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + node_->container (this); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ArtifactDeploymentDescription& ArtifactDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s) + { + name (s.name ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + node (s.node ()); + + location_.clear (); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + execParameter_.clear (); + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ArtifactDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ArtifactDeploymentDescription:: + name () const + { + return *name_; + } + + void ArtifactDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::source_iterator ArtifactDeploymentDescription:: + begin_source () + { + return source_.begin (); + } + + ArtifactDeploymentDescription::source_iterator ArtifactDeploymentDescription:: + end_source () + { + return source_.end (); + } + + ArtifactDeploymentDescription::source_const_iterator ArtifactDeploymentDescription:: + begin_source () const + { + return source_.begin (); + } + + ArtifactDeploymentDescription::source_const_iterator ArtifactDeploymentDescription:: + end_source () const + { + return source_.end (); + } + + void ArtifactDeploymentDescription:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_source(void) const + { + return source_.size (); + } + + // ArtifactDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ArtifactDeploymentDescription:: + node () const + { + return *node_; + } + + void ArtifactDeploymentDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::location_iterator ArtifactDeploymentDescription:: + begin_location () + { + return location_.begin (); + } + + ArtifactDeploymentDescription::location_iterator ArtifactDeploymentDescription:: + end_location () + { + return location_.end (); + } + + ArtifactDeploymentDescription::location_const_iterator ArtifactDeploymentDescription:: + begin_location () const + { + return location_.begin (); + } + + ArtifactDeploymentDescription::location_const_iterator ArtifactDeploymentDescription:: + end_location () const + { + return location_.end (); + } + + void ArtifactDeploymentDescription:: + add_location (::XMLSchema::string< ACE_TCHAR > const& e) + { + location_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_location(void) const + { + return location_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::execParameter_iterator ArtifactDeploymentDescription:: + begin_execParameter () + { + return execParameter_.begin (); + } + + ArtifactDeploymentDescription::execParameter_iterator ArtifactDeploymentDescription:: + end_execParameter () + { + return execParameter_.end (); + } + + ArtifactDeploymentDescription::execParameter_const_iterator ArtifactDeploymentDescription:: + begin_execParameter () const + { + return execParameter_.begin (); + } + + ArtifactDeploymentDescription::execParameter_const_iterator ArtifactDeploymentDescription:: + end_execParameter () const + { + return execParameter_.end (); + } + + void ArtifactDeploymentDescription:: + add_execParameter (::CIAO::Config_Handlers::Property const& e) + { + execParameter_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_execParameter(void) const + { + return execParameter_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::deployRequirement_iterator ArtifactDeploymentDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + ArtifactDeploymentDescription::deployRequirement_iterator ArtifactDeploymentDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + ArtifactDeploymentDescription::deployRequirement_const_iterator ArtifactDeploymentDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + ArtifactDeploymentDescription::deployRequirement_const_iterator ArtifactDeploymentDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void ArtifactDeploymentDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::deployedResource_iterator ArtifactDeploymentDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + ArtifactDeploymentDescription::deployedResource_iterator ArtifactDeploymentDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + ArtifactDeploymentDescription::deployedResource_const_iterator ArtifactDeploymentDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + ArtifactDeploymentDescription::deployedResource_const_iterator ArtifactDeploymentDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void ArtifactDeploymentDescription:: + add_deployedResource (::CIAO::Config_Handlers::ResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + // ArtifactDeploymentDescription + // + bool ArtifactDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ArtifactDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ArtifactDeploymentDescription:: + id () + { + return *id_; + } + + void ArtifactDeploymentDescription:: + 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); + } + } + + + // MonolithicDeploymentDescription + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::MonolithicDeploymentDescription& MonolithicDeploymentDescription:: + operator= (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s) + { + name (s.name ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + artifact_.clear (); + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + execParameter_.clear (); + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // MonolithicDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& MonolithicDeploymentDescription:: + name () const + { + return *name_; + } + + void MonolithicDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::source_iterator MonolithicDeploymentDescription:: + begin_source () + { + return source_.begin (); + } + + MonolithicDeploymentDescription::source_iterator MonolithicDeploymentDescription:: + end_source () + { + return source_.end (); + } + + MonolithicDeploymentDescription::source_const_iterator MonolithicDeploymentDescription:: + begin_source () const + { + return source_.begin (); + } + + MonolithicDeploymentDescription::source_const_iterator MonolithicDeploymentDescription:: + end_source () const + { + return source_.end (); + } + + void MonolithicDeploymentDescription:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_source(void) const + { + return source_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::artifact_iterator MonolithicDeploymentDescription:: + begin_artifact () + { + return artifact_.begin (); + } + + MonolithicDeploymentDescription::artifact_iterator MonolithicDeploymentDescription:: + end_artifact () + { + return artifact_.end (); + } + + MonolithicDeploymentDescription::artifact_const_iterator MonolithicDeploymentDescription:: + begin_artifact () const + { + return artifact_.begin (); + } + + MonolithicDeploymentDescription::artifact_const_iterator MonolithicDeploymentDescription:: + end_artifact () const + { + return artifact_.end (); + } + + void MonolithicDeploymentDescription:: + add_artifact (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + artifact_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_artifact(void) const + { + return artifact_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::execParameter_iterator MonolithicDeploymentDescription:: + begin_execParameter () + { + return execParameter_.begin (); + } + + MonolithicDeploymentDescription::execParameter_iterator MonolithicDeploymentDescription:: + end_execParameter () + { + return execParameter_.end (); + } + + MonolithicDeploymentDescription::execParameter_const_iterator MonolithicDeploymentDescription:: + begin_execParameter () const + { + return execParameter_.begin (); + } + + MonolithicDeploymentDescription::execParameter_const_iterator MonolithicDeploymentDescription:: + end_execParameter () const + { + return execParameter_.end (); + } + + void MonolithicDeploymentDescription:: + add_execParameter (::CIAO::Config_Handlers::Property const& e) + { + execParameter_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_execParameter(void) const + { + return execParameter_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::deployRequirement_iterator MonolithicDeploymentDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + MonolithicDeploymentDescription::deployRequirement_iterator MonolithicDeploymentDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + MonolithicDeploymentDescription::deployRequirement_const_iterator MonolithicDeploymentDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + MonolithicDeploymentDescription::deployRequirement_const_iterator MonolithicDeploymentDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void MonolithicDeploymentDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // MonolithicDeploymentDescription + // + bool MonolithicDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& MonolithicDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& MonolithicDeploymentDescription:: + id () + { + return *id_; + } + + void MonolithicDeploymentDescription:: + 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); + } + } + + + // ResourceUsageKind + // + + ResourceUsageKind::Value ResourceUsageKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::ResourceUsageKind const& a, ::CIAO::Config_Handlers::ResourceUsageKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::ResourceUsageKind const& a, ::CIAO::Config_Handlers::ResourceUsageKind const& b) + { + return a.v_ != b.v_; + } + + ResourceUsageKind:: + ResourceUsageKind (ResourceUsageKind::Value v) + : v_ (v) + { + } + + // InstanceResourceDeploymentDescription + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (resourceUsage__)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + resourceUsage_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + resourceUsage_->container (this); + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& InstanceResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s) + { + resourceUsage (s.resourceUsage ()); + + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // InstanceResourceDeploymentDescription + // + ::CIAO::Config_Handlers::ResourceUsageKind const& InstanceResourceDeploymentDescription:: + resourceUsage () const + { + return *resourceUsage_; + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e) + { + *resourceUsage_ = e; + } + + // InstanceResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void InstanceResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // InstanceResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void InstanceResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // InstanceResourceDeploymentDescription + // + InstanceResourceDeploymentDescription::property_iterator InstanceResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + InstanceResourceDeploymentDescription::property_iterator InstanceResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + InstanceResourceDeploymentDescription::property_const_iterator InstanceResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + InstanceResourceDeploymentDescription::property_const_iterator InstanceResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void InstanceResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t InstanceResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // InstanceDeploymentDescription + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::XMLSchema::string< ACE_TCHAR > const& source__, + ::XMLSchema::IDREF< ACE_TCHAR > const& implementation__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + source_ (new ::XMLSchema::string< ACE_TCHAR > (source__)), + implementation_ (new ::XMLSchema::IDREF< ACE_TCHAR > (implementation__)), + regulator__ () + { + name_->container (this); + node_->container (this); + source_->container (this); + implementation_->container (this); + } + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::CIAO::Config_Handlers::InstanceDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + source_ (new ::XMLSchema::string< ACE_TCHAR > (*s.source_)), + implementation_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.implementation_)), + deployedSharedResource_ (s.deployedSharedResource_.get () ? new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (*s.deployedSharedResource_) : 0), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + node_->container (this); + source_->container (this); + implementation_->container (this); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (deployedSharedResource_.get ()) deployedSharedResource_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::InstanceDeploymentDescription& InstanceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::InstanceDeploymentDescription const& s) + { + name (s.name ()); + + node (s.node ()); + + source (s.source ()); + + implementation (s.implementation ()); + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (s.deployedSharedResource_.get ()) deployedSharedResource (*(s.deployedSharedResource_)); + else deployedSharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (0); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + name () const + { + return *name_; + } + + void InstanceDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + node () const + { + return *node_; + } + + void InstanceDeploymentDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + source () const + { + return *source_; + } + + void InstanceDeploymentDescription:: + source (::XMLSchema::string< ACE_TCHAR > const& e) + { + *source_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::IDREF< ACE_TCHAR > const& InstanceDeploymentDescription:: + implementation () const + { + return *implementation_; + } + + void InstanceDeploymentDescription:: + implementation (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *implementation_ = e; + } + + // InstanceDeploymentDescription + // + InstanceDeploymentDescription::configProperty_iterator InstanceDeploymentDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + InstanceDeploymentDescription::configProperty_iterator InstanceDeploymentDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + InstanceDeploymentDescription::configProperty_const_iterator InstanceDeploymentDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + InstanceDeploymentDescription::configProperty_const_iterator InstanceDeploymentDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void InstanceDeploymentDescription:: + add_configProperty (::CIAO::Config_Handlers::Property const& e) + { + configProperty_.push_back (e); + } + + size_t InstanceDeploymentDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // InstanceDeploymentDescription + // + InstanceDeploymentDescription::deployedResource_iterator InstanceDeploymentDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + InstanceDeploymentDescription::deployedResource_iterator InstanceDeploymentDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + InstanceDeploymentDescription::deployedResource_const_iterator InstanceDeploymentDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + InstanceDeploymentDescription::deployedResource_const_iterator InstanceDeploymentDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void InstanceDeploymentDescription:: + add_deployedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t InstanceDeploymentDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + // InstanceDeploymentDescription + // + bool InstanceDeploymentDescription:: + deployedSharedResource_p () const + { + return deployedSharedResource_.get () != 0; + } + + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& InstanceDeploymentDescription:: + deployedSharedResource () const + { + return *deployedSharedResource_; + } + + void InstanceDeploymentDescription:: + deployedSharedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& e) + { + if (deployedSharedResource_.get ()) + { + *deployedSharedResource_ = e; + } + + else + { + deployedSharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (e)); + deployedSharedResource_->container (this); + } + } + + // InstanceDeploymentDescription + // + bool InstanceDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& InstanceDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& InstanceDeploymentDescription:: + id () + { + return *id_; + } + + void InstanceDeploymentDescription:: + 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); + } + } + + + // CCMComponentPortKind + // + + CCMComponentPortKind::Value CCMComponentPortKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::CCMComponentPortKind const& a, ::CIAO::Config_Handlers::CCMComponentPortKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::CCMComponentPortKind const& a, ::CIAO::Config_Handlers::CCMComponentPortKind const& b) + { + return a.v_ != b.v_; + } + + CCMComponentPortKind:: + CCMComponentPortKind (CCMComponentPortKind::Value v) + : v_ (v) + { + } + + // ComponentPortDescription + // + + ComponentPortDescription:: + ComponentPortDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& provider__, + ::XMLSchema::boolean const& exclusiveProvider__, + ::XMLSchema::boolean const& exclusiveUser__, + ::XMLSchema::boolean const& optional__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + provider_ (new ::XMLSchema::boolean (provider__)), + exclusiveProvider_ (new ::XMLSchema::boolean (exclusiveProvider__)), + exclusiveUser_ (new ::XMLSchema::boolean (exclusiveUser__)), + optional_ (new ::XMLSchema::boolean (optional__)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (kind__)), + regulator__ () + { + name_->container (this); + provider_->container (this); + exclusiveProvider_->container (this); + exclusiveUser_->container (this); + optional_->container (this); + kind_->container (this); + } + + ComponentPortDescription:: + ComponentPortDescription (::CIAO::Config_Handlers::ComponentPortDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + specificType_ (s.specificType_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.specificType_) : 0), + provider_ (new ::XMLSchema::boolean (*s.provider_)), + exclusiveProvider_ (new ::XMLSchema::boolean (*s.exclusiveProvider_)), + exclusiveUser_ (new ::XMLSchema::boolean (*s.exclusiveUser_)), + optional_ (new ::XMLSchema::boolean (*s.optional_)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)), + regulator__ () + { + name_->container (this); + if (specificType_.get ()) specificType_->container (this); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + provider_->container (this); + exclusiveProvider_->container (this); + exclusiveUser_->container (this); + optional_->container (this); + kind_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPortDescription& ComponentPortDescription:: + operator= (::CIAO::Config_Handlers::ComponentPortDescription const& s) + { + name (s.name ()); + + if (s.specificType_.get ()) specificType (*(s.specificType_)); + else specificType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + supportedType_.clear (); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + provider (s.provider ()); + + exclusiveProvider (s.exclusiveProvider ()); + + exclusiveUser (s.exclusiveUser ()); + + optional (s.optional ()); + + kind (s.kind ()); + + return *this; + } + + + // ComponentPortDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPortDescription:: + name () const + { + return *name_; + } + + void ComponentPortDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ComponentPortDescription + // + bool ComponentPortDescription:: + specificType_p () const + { + return specificType_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPortDescription:: + specificType () const + { + return *specificType_; + } + + void ComponentPortDescription:: + specificType (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (specificType_.get ()) + { + *specificType_ = e; + } + + else + { + specificType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + specificType_->container (this); + } + } + + // ComponentPortDescription + // + ComponentPortDescription::supportedType_iterator ComponentPortDescription:: + begin_supportedType () + { + return supportedType_.begin (); + } + + ComponentPortDescription::supportedType_iterator ComponentPortDescription:: + end_supportedType () + { + return supportedType_.end (); + } + + ComponentPortDescription::supportedType_const_iterator ComponentPortDescription:: + begin_supportedType () const + { + return supportedType_.begin (); + } + + ComponentPortDescription::supportedType_const_iterator ComponentPortDescription:: + end_supportedType () const + { + return supportedType_.end (); + } + + void ComponentPortDescription:: + add_supportedType (::XMLSchema::string< ACE_TCHAR > const& e) + { + supportedType_.push_back (e); + } + + size_t ComponentPortDescription:: + count_supportedType(void) const + { + return supportedType_.size (); + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + provider () const + { + return *provider_; + } + + void ComponentPortDescription:: + provider (::XMLSchema::boolean const& e) + { + *provider_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + exclusiveProvider () const + { + return *exclusiveProvider_; + } + + void ComponentPortDescription:: + exclusiveProvider (::XMLSchema::boolean const& e) + { + *exclusiveProvider_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + exclusiveUser () const + { + return *exclusiveUser_; + } + + void ComponentPortDescription:: + exclusiveUser (::XMLSchema::boolean const& e) + { + *exclusiveUser_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + optional () const + { + return *optional_; + } + + void ComponentPortDescription:: + optional (::XMLSchema::boolean const& e) + { + *optional_ = e; + } + + // ComponentPortDescription + // + ::CIAO::Config_Handlers::CCMComponentPortKind const& ComponentPortDescription:: + kind () const + { + return *kind_; + } + + void ComponentPortDescription:: + kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e) + { + *kind_ = e; + } + + + // ComponentPropertyDescription + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ComponentPropertyDescription:: + ComponentPropertyDescription (::CIAO::Config_Handlers::ComponentPropertyDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPropertyDescription& ComponentPropertyDescription:: + operator= (::CIAO::Config_Handlers::ComponentPropertyDescription const& s) + { + name (s.name ()); + + type (s.type ()); + + return *this; + } + + + // ComponentPropertyDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPropertyDescription:: + name () const + { + return *name_; + } + + void ComponentPropertyDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ComponentPropertyDescription + // + ::CIAO::Config_Handlers::DataType const& ComponentPropertyDescription:: + type () const + { + return *type_; + } + + void ComponentPropertyDescription:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // ComponentExternalPortEndpoint + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + regulator__ () + { + portName_->container (this); + } + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + regulator__ () + { + portName_->container (this); + } + + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint& ComponentExternalPortEndpoint:: + operator= (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& s) + { + portName (s.portName ()); + + return *this; + } + + + // ComponentExternalPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentExternalPortEndpoint:: + portName () const + { + return *portName_; + } + + void ComponentExternalPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + + // PlanSubcomponentPortEndpoint + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__, + ::XMLSchema::IDREF< ACE_TCHAR > const& instance__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (kind__)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (instance__)), + regulator__ () + { + portName_->container (this); + kind_->container (this); + instance_->container (this); + } + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + provider_ (s.provider_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.provider_) : 0), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.instance_)), + regulator__ () + { + portName_->container (this); + if (provider_.get ()) provider_->container (this); + kind_->container (this); + instance_->container (this); + } + + ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint& PlanSubcomponentPortEndpoint:: + operator= (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& s) + { + portName (s.portName ()); + + if (s.provider_.get ()) provider (*(s.provider_)); + else provider_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + kind (s.kind ()); + + instance (s.instance ()); + + return *this; + } + + + // PlanSubcomponentPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + portName () const + { + return *portName_; + } + + void PlanSubcomponentPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + // PlanSubcomponentPortEndpoint + // + bool PlanSubcomponentPortEndpoint:: + provider_p () const + { + return provider_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + provider () const + { + return *provider_; + } + + void PlanSubcomponentPortEndpoint:: + provider (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (provider_.get ()) + { + *provider_ = e; + } + + else + { + provider_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + provider_->container (this); + } + } + + // PlanSubcomponentPortEndpoint + // + ::CIAO::Config_Handlers::CCMComponentPortKind const& PlanSubcomponentPortEndpoint:: + kind () const + { + return *kind_; + } + + void PlanSubcomponentPortEndpoint:: + kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e) + { + *kind_ = e; + } + + // PlanSubcomponentPortEndpoint + // + ::XMLSchema::IDREF< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void PlanSubcomponentPortEndpoint:: + instance (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *instance_ = e; + } + + + // ExternalReferenceEndpoint + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XMLSchema::string< ACE_TCHAR > const& location__) + : + ::XSCRT::Type (), + location_ (new ::XMLSchema::string< ACE_TCHAR > (location__)), + regulator__ () + { + location_->container (this); + } + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& s) + : + ::XSCRT::Type (), + location_ (new ::XMLSchema::string< ACE_TCHAR > (*s.location_)), + regulator__ () + { + location_->container (this); + } + + ::CIAO::Config_Handlers::ExternalReferenceEndpoint& ExternalReferenceEndpoint:: + operator= (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& s) + { + location (s.location ()); + + return *this; + } + + + // ExternalReferenceEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& ExternalReferenceEndpoint:: + location () const + { + return *location_; + } + + void ExternalReferenceEndpoint:: + location (::XMLSchema::string< ACE_TCHAR > const& e) + { + *location_ = e; + } + + + // ConnectionResourceDeploymentDescription + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& targetName__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + targetName_ (new ::XMLSchema::string< ACE_TCHAR > (targetName__)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + targetName_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + targetName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.targetName_)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + targetName_->container (this); + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription& ConnectionResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s) + { + targetName (s.targetName ()); + + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + targetName () const + { + return *targetName_; + } + + void ConnectionResourceDeploymentDescription:: + targetName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *targetName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void ConnectionResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void ConnectionResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ConnectionResourceDeploymentDescription::property_iterator ConnectionResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + ConnectionResourceDeploymentDescription::property_iterator ConnectionResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + ConnectionResourceDeploymentDescription::property_const_iterator ConnectionResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + ConnectionResourceDeploymentDescription::property_const_iterator ConnectionResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void ConnectionResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ConnectionResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // PlanConnectionDescription + // + + PlanConnectionDescription:: + PlanConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + PlanConnectionDescription:: + PlanConnectionDescription (::CIAO::Config_Handlers::PlanConnectionDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + source_ (s.source_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.source_) : 0), + regulator__ () + { + name_->container (this); + if (source_.get ()) source_->container (this); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + } + + ::CIAO::Config_Handlers::PlanConnectionDescription& PlanConnectionDescription:: + operator= (::CIAO::Config_Handlers::PlanConnectionDescription const& s) + { + name (s.name ()); + + if (s.source_.get ()) source (*(s.source_)); + else source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + externalEndpoint_.clear (); + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + internalEndpoint_.clear (); + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + externalReference_.clear (); + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + return *this; + } + + + // PlanConnectionDescription + // + ::XMLSchema::string< ACE_TCHAR > const& PlanConnectionDescription:: + name () const + { + return *name_; + } + + void PlanConnectionDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // PlanConnectionDescription + // + bool PlanConnectionDescription:: + source_p () const + { + return source_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PlanConnectionDescription:: + source () const + { + return *source_; + } + + void PlanConnectionDescription:: + source (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (source_.get ()) + { + *source_ = e; + } + + else + { + source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + source_->container (this); + } + } + + // PlanConnectionDescription + // + PlanConnectionDescription::deployRequirement_iterator PlanConnectionDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + PlanConnectionDescription::deployRequirement_iterator PlanConnectionDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + PlanConnectionDescription::deployRequirement_const_iterator PlanConnectionDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + PlanConnectionDescription::deployRequirement_const_iterator PlanConnectionDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void PlanConnectionDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::externalEndpoint_iterator PlanConnectionDescription:: + begin_externalEndpoint () + { + return externalEndpoint_.begin (); + } + + PlanConnectionDescription::externalEndpoint_iterator PlanConnectionDescription:: + end_externalEndpoint () + { + return externalEndpoint_.end (); + } + + PlanConnectionDescription::externalEndpoint_const_iterator PlanConnectionDescription:: + begin_externalEndpoint () const + { + return externalEndpoint_.begin (); + } + + PlanConnectionDescription::externalEndpoint_const_iterator PlanConnectionDescription:: + end_externalEndpoint () const + { + return externalEndpoint_.end (); + } + + void PlanConnectionDescription:: + add_externalEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& e) + { + externalEndpoint_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_externalEndpoint(void) const + { + return externalEndpoint_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::internalEndpoint_iterator PlanConnectionDescription:: + begin_internalEndpoint () + { + return internalEndpoint_.begin (); + } + + PlanConnectionDescription::internalEndpoint_iterator PlanConnectionDescription:: + end_internalEndpoint () + { + return internalEndpoint_.end (); + } + + PlanConnectionDescription::internalEndpoint_const_iterator PlanConnectionDescription:: + begin_internalEndpoint () const + { + return internalEndpoint_.begin (); + } + + PlanConnectionDescription::internalEndpoint_const_iterator PlanConnectionDescription:: + end_internalEndpoint () const + { + return internalEndpoint_.end (); + } + + void PlanConnectionDescription:: + add_internalEndpoint (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& e) + { + internalEndpoint_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_internalEndpoint(void) const + { + return internalEndpoint_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::externalReference_iterator PlanConnectionDescription:: + begin_externalReference () + { + return externalReference_.begin (); + } + + PlanConnectionDescription::externalReference_iterator PlanConnectionDescription:: + end_externalReference () + { + return externalReference_.end (); + } + + PlanConnectionDescription::externalReference_const_iterator PlanConnectionDescription:: + begin_externalReference () const + { + return externalReference_.begin (); + } + + PlanConnectionDescription::externalReference_const_iterator PlanConnectionDescription:: + end_externalReference () const + { + return externalReference_.end (); + } + + void PlanConnectionDescription:: + add_externalReference (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& e) + { + externalReference_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_externalReference(void) const + { + return externalReference_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::deployedResource_iterator PlanConnectionDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + PlanConnectionDescription::deployedResource_iterator PlanConnectionDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + PlanConnectionDescription::deployedResource_const_iterator PlanConnectionDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + PlanConnectionDescription::deployedResource_const_iterator PlanConnectionDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void PlanConnectionDescription:: + add_deployedResource (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + + // ImplementationDependency + // + + ImplementationDependency:: + ImplementationDependency (::XMLSchema::string< ACE_TCHAR > const& requiredType__) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ImplementationDependency:: + ImplementationDependency (::CIAO::Config_Handlers::ImplementationDependency const& s) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requiredType_)), + regulator__ () + { + requiredType_->container (this); + } + + ::CIAO::Config_Handlers::ImplementationDependency& ImplementationDependency:: + operator= (::CIAO::Config_Handlers::ImplementationDependency const& s) + { + requiredType (s.requiredType ()); + + return *this; + } + + + // ImplementationDependency + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationDependency:: + requiredType () const + { + return *requiredType_; + } + + void ImplementationDependency:: + requiredType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requiredType_ = e; + } + + + // Capability + // + + Capability:: + Capability (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Capability:: + Capability (::CIAO::Config_Handlers::Capability const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Capability& Capability:: + operator= (::CIAO::Config_Handlers::Capability const& s) + { + name (s.name ()); + + resourceType_.clear (); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Capability + // + ::XMLSchema::string< ACE_TCHAR > const& Capability:: + name () const + { + return *name_; + } + + void Capability:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Capability + // + Capability::resourceType_iterator Capability:: + begin_resourceType () + { + return resourceType_.begin (); + } + + Capability::resourceType_iterator Capability:: + end_resourceType () + { + return resourceType_.end (); + } + + Capability::resourceType_const_iterator Capability:: + begin_resourceType () const + { + return resourceType_.begin (); + } + + Capability::resourceType_const_iterator Capability:: + end_resourceType () const + { + return resourceType_.end (); + } + + void Capability:: + add_resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + resourceType_.push_back (e); + } + + size_t Capability:: + count_resourceType(void) const + { + return resourceType_.size (); + } + + // Capability + // + Capability::property_iterator Capability:: + begin_property () + { + return property_.begin (); + } + + Capability::property_iterator Capability:: + end_property () + { + return property_.end (); + } + + Capability::property_const_iterator Capability:: + begin_property () const + { + return property_.begin (); + } + + Capability::property_const_iterator Capability:: + end_property () const + { + return property_.end (); + } + + void Capability:: + add_property (::CIAO::Config_Handlers::SatisfierProperty const& e) + { + property_.push_back (e); + } + + size_t Capability:: + count_property(void) const + { + return property_.size (); + } + + + // ImplementationRequirement + // + + ImplementationRequirement:: + ImplementationRequirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + } + + ImplementationRequirement:: + ImplementationRequirement (::CIAO::Config_Handlers::ImplementationRequirement const& s) + : + ::XSCRT::Type (), + resourceUsage_ (s.resourceUsage_.get () ? new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_) : 0), + resourcePort_ (s.resourcePort_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.resourcePort_) : 0), + componentPort_ (s.componentPort_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.componentPort_) : 0), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + if (resourceUsage_.get ()) resourceUsage_->container (this); + if (resourcePort_.get ()) resourcePort_->container (this); + if (componentPort_.get ()) componentPort_->container (this); + resourceType_->container (this); + name_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ImplementationRequirement& ImplementationRequirement:: + operator= (::CIAO::Config_Handlers::ImplementationRequirement const& s) + { + if (s.resourceUsage_.get ()) resourceUsage (*(s.resourceUsage_)); + else resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (0); + + if (s.resourcePort_.get ()) resourcePort (*(s.resourcePort_)); + else resourcePort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.componentPort_.get ()) componentPort (*(s.componentPort_)); + else componentPort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + resourceType (s.resourceType ()); + + name (s.name ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ImplementationRequirement + // + bool ImplementationRequirement:: + resourceUsage_p () const + { + return resourceUsage_.get () != 0; + } + + ::CIAO::Config_Handlers::ResourceUsageKind const& ImplementationRequirement:: + resourceUsage () const + { + return *resourceUsage_; + } + + void ImplementationRequirement:: + resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e) + { + if (resourceUsage_.get ()) + { + *resourceUsage_ = e; + } + + else + { + resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (new ::CIAO::Config_Handlers::ResourceUsageKind (e)); + resourceUsage_->container (this); + } + } + + // ImplementationRequirement + // + bool ImplementationRequirement:: + resourcePort_p () const + { + return resourcePort_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + resourcePort () const + { + return *resourcePort_; + } + + void ImplementationRequirement:: + resourcePort (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (resourcePort_.get ()) + { + *resourcePort_ = e; + } + + else + { + resourcePort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourcePort_->container (this); + } + } + + // ImplementationRequirement + // + bool ImplementationRequirement:: + componentPort_p () const + { + return componentPort_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + componentPort () const + { + return *componentPort_; + } + + void ImplementationRequirement:: + componentPort (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (componentPort_.get ()) + { + *componentPort_ = e; + } + + else + { + componentPort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + componentPort_->container (this); + } + } + + // ImplementationRequirement + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + resourceType () const + { + return *resourceType_; + } + + void ImplementationRequirement:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = e; + } + + // ImplementationRequirement + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + name () const + { + return *name_; + } + + void ImplementationRequirement:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ImplementationRequirement + // + ImplementationRequirement::property_iterator ImplementationRequirement:: + begin_property () + { + return property_.begin (); + } + + ImplementationRequirement::property_iterator ImplementationRequirement:: + end_property () + { + return property_.end (); + } + + ImplementationRequirement::property_const_iterator ImplementationRequirement:: + begin_property () const + { + return property_.begin (); + } + + ImplementationRequirement::property_const_iterator ImplementationRequirement:: + end_property () const + { + return property_.end (); + } + + void ImplementationRequirement:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ImplementationRequirement:: + count_property(void) const + { + return property_.size (); + } + + + // ComponentPackageReference + // + + ComponentPackageReference:: + ComponentPackageReference (::XMLSchema::string< ACE_TCHAR > const& requiredType__) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ComponentPackageReference:: + ComponentPackageReference (::CIAO::Config_Handlers::ComponentPackageReference const& s) + : + ::XSCRT::Type (), + requiredUUID_ (s.requiredUUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.requiredUUID_) : 0), + requiredName_ (s.requiredName_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.requiredName_) : 0), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requiredType_)), + regulator__ () + { + if (requiredUUID_.get ()) requiredUUID_->container (this); + if (requiredName_.get ()) requiredName_->container (this); + requiredType_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPackageReference& ComponentPackageReference:: + operator= (::CIAO::Config_Handlers::ComponentPackageReference const& s) + { + if (s.requiredUUID_.get ()) requiredUUID (*(s.requiredUUID_)); + else requiredUUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.requiredName_.get ()) requiredName (*(s.requiredName_)); + else requiredName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + requiredType (s.requiredType ()); + + return *this; + } + + + // ComponentPackageReference + // + bool ComponentPackageReference:: + requiredUUID_p () const + { + return requiredUUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredUUID () const + { + return *requiredUUID_; + } + + void ComponentPackageReference:: + requiredUUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (requiredUUID_.get ()) + { + *requiredUUID_ = e; + } + + else + { + requiredUUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredUUID_->container (this); + } + } + + // ComponentPackageReference + // + bool ComponentPackageReference:: + requiredName_p () const + { + return requiredName_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredName () const + { + return *requiredName_; + } + + void ComponentPackageReference:: + requiredName (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (requiredName_.get ()) + { + *requiredName_ = e; + } + + else + { + requiredName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredName_->container (this); + } + } + + // ComponentPackageReference + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredType () const + { + return *requiredType_; + } + + void ComponentPackageReference:: + requiredType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requiredType_ = e; + } + + + // SubcomponentPortEndpoint + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::XMLSchema::IDREF< ACE_TCHAR > const& instance__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (instance__)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.instance_)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + ::CIAO::Config_Handlers::SubcomponentPortEndpoint& SubcomponentPortEndpoint:: + operator= (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& s) + { + portName (s.portName ()); + + instance (s.instance ()); + + return *this; + } + + + // SubcomponentPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& SubcomponentPortEndpoint:: + portName () const + { + return *portName_; + } + + void SubcomponentPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + // SubcomponentPortEndpoint + // + ::XMLSchema::IDREF< ACE_TCHAR > const& SubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void SubcomponentPortEndpoint:: + instance (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *instance_ = e; + } + + + // AssemblyConnectionDescription + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::CIAO::Config_Handlers::AssemblyConnectionDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + } + + ::CIAO::Config_Handlers::AssemblyConnectionDescription& AssemblyConnectionDescription:: + operator= (::CIAO::Config_Handlers::AssemblyConnectionDescription const& s) + { + name (s.name ()); + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + internalEndpoint_.clear (); + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + externalEndpoint_.clear (); + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + externalReference_.clear (); + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + return *this; + } + + + // AssemblyConnectionDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AssemblyConnectionDescription:: + name () const + { + return *name_; + } + + void AssemblyConnectionDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::deployRequirement_iterator AssemblyConnectionDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + AssemblyConnectionDescription::deployRequirement_iterator AssemblyConnectionDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + AssemblyConnectionDescription::deployRequirement_const_iterator AssemblyConnectionDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + AssemblyConnectionDescription::deployRequirement_const_iterator AssemblyConnectionDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void AssemblyConnectionDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::internalEndpoint_iterator AssemblyConnectionDescription:: + begin_internalEndpoint () + { + return internalEndpoint_.begin (); + } + + AssemblyConnectionDescription::internalEndpoint_iterator AssemblyConnectionDescription:: + end_internalEndpoint () + { + return internalEndpoint_.end (); + } + + AssemblyConnectionDescription::internalEndpoint_const_iterator AssemblyConnectionDescription:: + begin_internalEndpoint () const + { + return internalEndpoint_.begin (); + } + + AssemblyConnectionDescription::internalEndpoint_const_iterator AssemblyConnectionDescription:: + end_internalEndpoint () const + { + return internalEndpoint_.end (); + } + + void AssemblyConnectionDescription:: + add_internalEndpoint (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& e) + { + internalEndpoint_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_internalEndpoint(void) const + { + return internalEndpoint_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::externalEndpoint_iterator AssemblyConnectionDescription:: + begin_externalEndpoint () + { + return externalEndpoint_.begin (); + } + + AssemblyConnectionDescription::externalEndpoint_iterator AssemblyConnectionDescription:: + end_externalEndpoint () + { + return externalEndpoint_.end (); + } + + AssemblyConnectionDescription::externalEndpoint_const_iterator AssemblyConnectionDescription:: + begin_externalEndpoint () const + { + return externalEndpoint_.begin (); + } + + AssemblyConnectionDescription::externalEndpoint_const_iterator AssemblyConnectionDescription:: + end_externalEndpoint () const + { + return externalEndpoint_.end (); + } + + void AssemblyConnectionDescription:: + add_externalEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& e) + { + externalEndpoint_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_externalEndpoint(void) const + { + return externalEndpoint_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::externalReference_iterator AssemblyConnectionDescription:: + begin_externalReference () + { + return externalReference_.begin (); + } + + AssemblyConnectionDescription::externalReference_iterator AssemblyConnectionDescription:: + end_externalReference () + { + return externalReference_.end (); + } + + AssemblyConnectionDescription::externalReference_const_iterator AssemblyConnectionDescription:: + begin_externalReference () const + { + return externalReference_.begin (); + } + + AssemblyConnectionDescription::externalReference_const_iterator AssemblyConnectionDescription:: + end_externalReference () const + { + return externalReference_.end (); + } + + void AssemblyConnectionDescription:: + add_externalReference (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& e) + { + externalReference_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_externalReference(void) const + { + return externalReference_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // TCKind + // + + TCKind:: + TCKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "tk_null") v_ = tk_null_l; + else if (v == "tk_void") v_ = tk_void_l; + else if (v == "tk_short") v_ = tk_short_l; + else if (v == "tk_long") v_ = tk_long_l; + else if (v == "tk_ushort") v_ = tk_ushort_l; + else if (v == "tk_ulong") v_ = tk_ulong_l; + else if (v == "tk_float") v_ = tk_float_l; + else if (v == "tk_double") v_ = tk_double_l; + else if (v == "tk_boolean") v_ = tk_boolean_l; + else if (v == "tk_char") v_ = tk_char_l; + else if (v == "tk_octet") v_ = tk_octet_l; + else if (v == "tk_any") v_ = tk_any_l; + else if (v == "tk_TypeCode") v_ = tk_TypeCode_l; + else if (v == "tk_Principal") v_ = tk_Principal_l; + else if (v == "tk_objref") v_ = tk_objref_l; + else if (v == "tk_struct") v_ = tk_struct_l; + else if (v == "tk_union") v_ = tk_union_l; + else if (v == "tk_enum") v_ = tk_enum_l; + else if (v == "tk_string") v_ = tk_string_l; + else if (v == "tk_sequence") v_ = tk_sequence_l; + else if (v == "tk_array") v_ = tk_array_l; + else if (v == "tk_alias") v_ = tk_alias_l; + else if (v == "tk_except") v_ = tk_except_l; + else if (v == "tk_longlong") v_ = tk_longlong_l; + else if (v == "tk_ulonglong") v_ = tk_ulonglong_l; + else if (v == "tk_longdouble") v_ = tk_longdouble_l; + else if (v == "tk_wchar") v_ = tk_wchar_l; + else if (v == "tk_wstring") v_ = tk_wstring_l; + else if (v == "tk_wfixed") v_ = tk_wfixed_l; + else if (v == "tk_value") v_ = tk_value_l; + else if (v == "tk_value_box") v_ = tk_value_box_l; + else if (v == "tk_native") v_ = tk_native_l; + else if (v == "tk_abstract_interface") v_ = tk_abstract_interface_l; + else if (v == "tk_local_interface") v_ = tk_local_interface_l; + else if (v == "tk_component") v_ = tk_component_l; + else if (v == "tk_home") v_ = tk_home_l; + else if (v == "tk_event") v_ = tk_event_l; + else + { + } + } + + TCKind:: + TCKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "tk_null") v_ = tk_null_l; + else if (v == "tk_void") v_ = tk_void_l; + else if (v == "tk_short") v_ = tk_short_l; + else if (v == "tk_long") v_ = tk_long_l; + else if (v == "tk_ushort") v_ = tk_ushort_l; + else if (v == "tk_ulong") v_ = tk_ulong_l; + else if (v == "tk_float") v_ = tk_float_l; + else if (v == "tk_double") v_ = tk_double_l; + else if (v == "tk_boolean") v_ = tk_boolean_l; + else if (v == "tk_char") v_ = tk_char_l; + else if (v == "tk_octet") v_ = tk_octet_l; + else if (v == "tk_any") v_ = tk_any_l; + else if (v == "tk_TypeCode") v_ = tk_TypeCode_l; + else if (v == "tk_Principal") v_ = tk_Principal_l; + else if (v == "tk_objref") v_ = tk_objref_l; + else if (v == "tk_struct") v_ = tk_struct_l; + else if (v == "tk_union") v_ = tk_union_l; + else if (v == "tk_enum") v_ = tk_enum_l; + else if (v == "tk_string") v_ = tk_string_l; + else if (v == "tk_sequence") v_ = tk_sequence_l; + else if (v == "tk_array") v_ = tk_array_l; + else if (v == "tk_alias") v_ = tk_alias_l; + else if (v == "tk_except") v_ = tk_except_l; + else if (v == "tk_longlong") v_ = tk_longlong_l; + else if (v == "tk_ulonglong") v_ = tk_ulonglong_l; + else if (v == "tk_longdouble") v_ = tk_longdouble_l; + else if (v == "tk_wchar") v_ = tk_wchar_l; + else if (v == "tk_wstring") v_ = tk_wstring_l; + else if (v == "tk_wfixed") v_ = tk_wfixed_l; + else if (v == "tk_value") v_ = tk_value_l; + else if (v == "tk_value_box") v_ = tk_value_box_l; + else if (v == "tk_native") v_ = tk_native_l; + else if (v == "tk_abstract_interface") v_ = tk_abstract_interface_l; + else if (v == "tk_local_interface") v_ = tk_local_interface_l; + else if (v == "tk_component") v_ = tk_component_l; + else if (v == "tk_home") v_ = tk_home_l; + else if (v == "tk_event") v_ = tk_event_l; + else + { + } + } + + TCKind const TCKind::tk_null (TCKind::tk_null_l); + TCKind const TCKind::tk_void (TCKind::tk_void_l); + TCKind const TCKind::tk_short (TCKind::tk_short_l); + TCKind const TCKind::tk_long (TCKind::tk_long_l); + TCKind const TCKind::tk_ushort (TCKind::tk_ushort_l); + TCKind const TCKind::tk_ulong (TCKind::tk_ulong_l); + TCKind const TCKind::tk_float (TCKind::tk_float_l); + TCKind const TCKind::tk_double (TCKind::tk_double_l); + TCKind const TCKind::tk_boolean (TCKind::tk_boolean_l); + TCKind const TCKind::tk_char (TCKind::tk_char_l); + TCKind const TCKind::tk_octet (TCKind::tk_octet_l); + TCKind const TCKind::tk_any (TCKind::tk_any_l); + TCKind const TCKind::tk_TypeCode (TCKind::tk_TypeCode_l); + TCKind const TCKind::tk_Principal (TCKind::tk_Principal_l); + TCKind const TCKind::tk_objref (TCKind::tk_objref_l); + TCKind const TCKind::tk_struct (TCKind::tk_struct_l); + TCKind const TCKind::tk_union (TCKind::tk_union_l); + TCKind const TCKind::tk_enum (TCKind::tk_enum_l); + TCKind const TCKind::tk_string (TCKind::tk_string_l); + TCKind const TCKind::tk_sequence (TCKind::tk_sequence_l); + TCKind const TCKind::tk_array (TCKind::tk_array_l); + TCKind const TCKind::tk_alias (TCKind::tk_alias_l); + TCKind const TCKind::tk_except (TCKind::tk_except_l); + TCKind const TCKind::tk_longlong (TCKind::tk_longlong_l); + TCKind const TCKind::tk_ulonglong (TCKind::tk_ulonglong_l); + TCKind const TCKind::tk_longdouble (TCKind::tk_longdouble_l); + TCKind const TCKind::tk_wchar (TCKind::tk_wchar_l); + TCKind const TCKind::tk_wstring (TCKind::tk_wstring_l); + TCKind const TCKind::tk_wfixed (TCKind::tk_wfixed_l); + TCKind const TCKind::tk_value (TCKind::tk_value_l); + TCKind const TCKind::tk_value_box (TCKind::tk_value_box_l); + TCKind const TCKind::tk_native (TCKind::tk_native_l); + TCKind const TCKind::tk_abstract_interface (TCKind::tk_abstract_interface_l); + TCKind const TCKind::tk_local_interface (TCKind::tk_local_interface_l); + TCKind const TCKind::tk_component (TCKind::tk_component_l); + TCKind const TCKind::tk_home (TCKind::tk_home_l); + TCKind const TCKind::tk_event (TCKind::tk_event_l); + + // DataType + // + + DataType:: + DataType (::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 == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > (new ::CIAO::Config_Handlers::TCKind (e)); + kind_->container (this); + } + + else if (n == "enum") + { + ::CIAO::Config_Handlers::EnumType t (e); + enum_ (t); + } + + else if (n == "struct") + { + ::CIAO::Config_Handlers::StructType t (e); + struct_ (t); + } + + else if (n == "value") + { + ::CIAO::Config_Handlers::ValueType t (e); + value (t); + } + + else if (n == "sequence") + { + ::CIAO::Config_Handlers::SequenceType t (e); + sequence (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 + { + } + } + } + + // DataValue + // + + DataValue:: + DataValue (::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 == "short") + { + ::XMLSchema::short_ t (e); + add_short (t); + } + + else if (n == "long") + { + ::XMLSchema::int_ t (e); + add_long (t); + } + + else if (n == "ushort") + { + ::XMLSchema::unsignedShort t (e); + add_ushort (t); + } + + else if (n == "ulong") + { + ::XMLSchema::unsignedInt t (e); + add_ulong (t); + } + + else if (n == "float") + { + ::XMLSchema::float_ t (e); + add_float (t); + } + + else if (n == "double") + { + ::XMLSchema::double_ t (e); + add_double (t); + } + + else if (n == "boolean") + { + ::XMLSchema::boolean t (e); + add_boolean (t); + } + + else if (n == "octet") + { + ::XMLSchema::unsignedByte t (e); + add_octet (t); + } + + else if (n == "enum") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_enum (t); + } + + else if (n == "string") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_string (t); + } + + else if (n == "longlong") + { + ::XMLSchema::long_ t (e); + add_longlong (t); + } + + else if (n == "ulonglong") + { + ::XMLSchema::unsignedLong t (e); + add_ulonglong (t); + } + + else if (n == "longdouble") + { + ::XMLSchema::double_ t (e); + add_longdouble (t); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::NamedValue t (e); + add_member (t); + } + + else + { + } + } + } + + // EnumType + // + + EnumType:: + EnumType (::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 == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "member") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_member (t); + } + + else + { + } + } + } + + // StructType + // + + StructType:: + StructType (::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 == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::StructMemberType t (e); + add_member (t); + } + + else + { + } + } + } + + // StructMemberType + // + + StructMemberType:: + StructMemberType (::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::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // ValueType + // + + ValueType:: + ValueType (::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 == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "modifier") + { + modifier_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + modifier_->container (this); + } + + else if (n == "baseType") + { + baseType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + baseType_->container (this); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::ValueMemberType t (e); + add_member (t); + } + + else + { + } + } + } + + // ValueMemberType + // + + ValueMemberType:: + ValueMemberType (::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 == "visibility") + { + visibility_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + visibility_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // NamedValue + // + + NamedValue:: + NamedValue (::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 == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > (new ::CIAO::Config_Handlers::DataValue (e)); + value_->container (this); + } + + else + { + } + } + } + + // SequenceType + // + + SequenceType:: + SequenceType (::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 == "bound") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + bound (t); + } + + else if (n == "elementType") + { + elementType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + elementType_->container (this); + } + + else + { + } + } + } + + // Any + // + + Any:: + Any (::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 == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > (new ::CIAO::Config_Handlers::DataValue (e)); + value_->container (this); + } + + else + { + } + } + } + + // Property + // + + Property:: + Property (::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 == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Any > (new ::CIAO::Config_Handlers::Any (e)); + value_->container (this); + } + + else + { + } + } + } + + // SatisfierPropertyKind + // + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "Quantity") v_ = Quantity_l; + else if (v == "Capacity") v_ = Capacity_l; + else if (v == "Minimum") v_ = Minimum_l; + else if (v == "Maximum") v_ = Maximum_l; + else if (v == "Attribute") v_ = Attribute_l; + else if (v == "Selection") v_ = Selection_l; + else + { + } + } + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "Quantity") v_ = Quantity_l; + else if (v == "Capacity") v_ = Capacity_l; + else if (v == "Minimum") v_ = Minimum_l; + else if (v == "Maximum") v_ = Maximum_l; + else if (v == "Attribute") v_ = Attribute_l; + else if (v == "Selection") v_ = Selection_l; + else + { + } + } + + SatisfierPropertyKind const SatisfierPropertyKind::Quantity (SatisfierPropertyKind::Quantity_l); + SatisfierPropertyKind const SatisfierPropertyKind::Capacity (SatisfierPropertyKind::Capacity_l); + SatisfierPropertyKind const SatisfierPropertyKind::Minimum (SatisfierPropertyKind::Minimum_l); + SatisfierPropertyKind const SatisfierPropertyKind::Maximum (SatisfierPropertyKind::Maximum_l); + SatisfierPropertyKind const SatisfierPropertyKind::Attribute (SatisfierPropertyKind::Attribute_l); + SatisfierPropertyKind const SatisfierPropertyKind::Selection (SatisfierPropertyKind::Selection_l); + + // SatisfierProperty + // + + SatisfierProperty:: + SatisfierProperty (::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 == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierPropertyKind > (new ::CIAO::Config_Handlers::SatisfierPropertyKind (e)); + kind_->container (this); + } + + else if (n == "dynamic") + { + dynamic_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + dynamic_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Any > (new ::CIAO::Config_Handlers::Any (e)); + value_->container (this); + } + + else + { + } + } + } + + // Resource + // + + Resource:: + Resource (::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 == "resourceType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_resourceType (t); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::SatisfierProperty t (e); + add_property (t); + } + + else + { + } + } + } + + // Requirement + // + + Requirement:: + Requirement (::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 == "resourceType") + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ResourceDeploymentDescription + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::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 == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ArtifactDeploymentDescription + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::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 == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == "location") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_location (t); + } + + else if (n == "execParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_execParameter (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::ResourceDeploymentDescription t (e); + add_deployedResource (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 + { + } + } + } + + // MonolithicDeploymentDescription + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::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 == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else if (n == "artifact") + { + ::XMLSchema::IDREF< ACE_TCHAR > t (e); + add_artifact (t); + } + + else if (n == "execParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_execParameter (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (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 + { + } + } + } + + // ResourceUsageKind + // + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "None") v_ = None_l; + else if (v == "InstanceUsesResource") v_ = InstanceUsesResource_l; + else if (v == "ResourceUsesInstance") v_ = ResourceUsesInstance_l; + else if (v == "PortUsesResource") v_ = PortUsesResource_l; + else if (v == "ResourceUsesPort") v_ = ResourceUsesPort_l; + else + { + } + } + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "None") v_ = None_l; + else if (v == "InstanceUsesResource") v_ = InstanceUsesResource_l; + else if (v == "ResourceUsesInstance") v_ = ResourceUsesInstance_l; + else if (v == "PortUsesResource") v_ = PortUsesResource_l; + else if (v == "ResourceUsesPort") v_ = ResourceUsesPort_l; + else + { + } + } + + ResourceUsageKind const ResourceUsageKind::None (ResourceUsageKind::None_l); + ResourceUsageKind const ResourceUsageKind::InstanceUsesResource (ResourceUsageKind::InstanceUsesResource_l); + ResourceUsageKind const ResourceUsageKind::ResourceUsesInstance (ResourceUsageKind::ResourceUsesInstance_l); + ResourceUsageKind const ResourceUsageKind::PortUsesResource (ResourceUsageKind::PortUsesResource_l); + ResourceUsageKind const ResourceUsageKind::ResourceUsesPort (ResourceUsageKind::ResourceUsesPort_l); + + // InstanceResourceDeploymentDescription + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::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 == "resourceUsage") + { + resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (new ::CIAO::Config_Handlers::ResourceUsageKind (e)); + resourceUsage_->container (this); + } + + else if (n == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // InstanceDeploymentDescription + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::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 == "source") + { + source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + source_->container (this); + } + + else if (n == "implementation") + { + implementation_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + implementation_->container (this); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e); + add_deployedResource (t); + } + + else if (n == "deployedSharedResource") + { + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e); + deployedSharedResource (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 + { + } + } + } + + // CCMComponentPortKind + // + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "Facet") v_ = Facet_l; + else if (v == "SimplexReceptacle") v_ = SimplexReceptacle_l; + else if (v == "MultiplexReceptacle") v_ = MultiplexReceptacle_l; + else if (v == "EventEmitter") v_ = EventEmitter_l; + else if (v == "EventPublisher") v_ = EventPublisher_l; + else if (v == "EventConsumer") v_ = EventConsumer_l; + else + { + } + } + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "Facet") v_ = Facet_l; + else if (v == "SimplexReceptacle") v_ = SimplexReceptacle_l; + else if (v == "MultiplexReceptacle") v_ = MultiplexReceptacle_l; + else if (v == "EventEmitter") v_ = EventEmitter_l; + else if (v == "EventPublisher") v_ = EventPublisher_l; + else if (v == "EventConsumer") v_ = EventConsumer_l; + else + { + } + } + + CCMComponentPortKind const CCMComponentPortKind::Facet (CCMComponentPortKind::Facet_l); + CCMComponentPortKind const CCMComponentPortKind::SimplexReceptacle (CCMComponentPortKind::SimplexReceptacle_l); + CCMComponentPortKind const CCMComponentPortKind::MultiplexReceptacle (CCMComponentPortKind::MultiplexReceptacle_l); + CCMComponentPortKind const CCMComponentPortKind::EventEmitter (CCMComponentPortKind::EventEmitter_l); + CCMComponentPortKind const CCMComponentPortKind::EventPublisher (CCMComponentPortKind::EventPublisher_l); + CCMComponentPortKind const CCMComponentPortKind::EventConsumer (CCMComponentPortKind::EventConsumer_l); + + // ComponentPortDescription + // + + ComponentPortDescription:: + ComponentPortDescription (::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 == "specificType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + specificType (t); + } + + else if (n == "supportedType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_supportedType (t); + } + + else if (n == "provider") + { + provider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + provider_->container (this); + } + + else if (n == "exclusiveProvider") + { + exclusiveProvider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveProvider_->container (this); + } + + else if (n == "exclusiveUser") + { + exclusiveUser_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveUser_->container (this); + } + + else if (n == "optional") + { + optional_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + optional_->container (this); + } + + else if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else + { + } + } + } + + // ComponentPropertyDescription + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::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::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // ComponentExternalPortEndpoint + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::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 == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else + { + } + } + } + + // PlanSubcomponentPortEndpoint + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::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 == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == "provider") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + provider (t); + } + + else if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else if (n == "instance") + { + instance_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + instance_->container (this); + } + + else + { + } + } + } + + // ExternalReferenceEndpoint + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::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 == "location") + { + location_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + location_->container (this); + } + + else + { + } + } + } + + // ConnectionResourceDeploymentDescription + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::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 == "targetName") + { + targetName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + targetName_->container (this); + } + + else if (n == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // PlanConnectionDescription + // + + PlanConnectionDescription:: + PlanConnectionDescription (::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 == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + source (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "externalEndpoint") + { + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint t (e); + add_externalEndpoint (t); + } + + else if (n == "internalEndpoint") + { + ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint t (e); + add_internalEndpoint (t); + } + + else if (n == "externalReference") + { + ::CIAO::Config_Handlers::ExternalReferenceEndpoint t (e); + add_externalReference (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription t (e); + add_deployedResource (t); + } + + else + { + } + } + } + + // ImplementationDependency + // + + ImplementationDependency:: + ImplementationDependency (::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 == "requiredType") + { + requiredType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredType_->container (this); + } + + else + { + } + } + } + + // Capability + // + + Capability:: + Capability (::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 == "resourceType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_resourceType (t); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::SatisfierProperty t (e); + add_property (t); + } + + else + { + } + } + } + + // ImplementationRequirement + // + + ImplementationRequirement:: + ImplementationRequirement (::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 == "resourceUsage") + { + ::CIAO::Config_Handlers::ResourceUsageKind t (e); + resourceUsage (t); + } + + else if (n == "resourcePort") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + resourcePort (t); + } + + else if (n == "componentPort") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + componentPort (t); + } + + else if (n == "resourceType") + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ComponentPackageReference + // + + ComponentPackageReference:: + ComponentPackageReference (::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 == "requiredUUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredUUID (t); + } + + else if (n == "requiredName") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredName (t); + } + + else if (n == "requiredType") + { + requiredType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredType_->container (this); + } + + else + { + } + } + } + + // SubcomponentPortEndpoint + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::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 == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == "instance") + { + instance_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + instance_->container (this); + } + + else + { + } + } + } + + // AssemblyConnectionDescription + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::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 == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "internalEndpoint") + { + ::CIAO::Config_Handlers::SubcomponentPortEndpoint t (e); + add_internalEndpoint (t); + } + + else if (n == "externalEndpoint") + { + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint t (e); + add_externalEndpoint (t); + } + + else if (n == "externalReference") + { + ::CIAO::Config_Handlers::ExternalReferenceEndpoint t (e); + add_externalReference (t); + } + + else + { + } + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/TypeInfo.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace + { + ::XMLSchema::TypeInfoInitializer < ACE_TCHAR > XMLSchemaTypeInfoInitializer_ (::XSCRT::extended_type_info_map ()); + + struct TCKindTypeInfoInitializer + { + TCKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (TCKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + TCKindTypeInfoInitializer TCKindTypeInfoInitializer_; + + struct DataTypeTypeInfoInitializer + { + DataTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (DataType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + DataTypeTypeInfoInitializer DataTypeTypeInfoInitializer_; + + struct DataValueTypeInfoInitializer + { + DataValueTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (DataValue)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + DataValueTypeInfoInitializer DataValueTypeInfoInitializer_; + + struct EnumTypeTypeInfoInitializer + { + EnumTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (EnumType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + EnumTypeTypeInfoInitializer EnumTypeTypeInfoInitializer_; + + struct StructTypeTypeInfoInitializer + { + StructTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (StructType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + StructTypeTypeInfoInitializer StructTypeTypeInfoInitializer_; + + struct StructMemberTypeTypeInfoInitializer + { + StructMemberTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (StructMemberType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + StructMemberTypeTypeInfoInitializer StructMemberTypeTypeInfoInitializer_; + + struct ValueTypeTypeInfoInitializer + { + ValueTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ValueType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ValueTypeTypeInfoInitializer ValueTypeTypeInfoInitializer_; + + struct ValueMemberTypeTypeInfoInitializer + { + ValueMemberTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ValueMemberType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ValueMemberTypeTypeInfoInitializer ValueMemberTypeTypeInfoInitializer_; + + struct NamedValueTypeInfoInitializer + { + NamedValueTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (NamedValue)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + NamedValueTypeInfoInitializer NamedValueTypeInfoInitializer_; + + struct SequenceTypeTypeInfoInitializer + { + SequenceTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SequenceType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SequenceTypeTypeInfoInitializer SequenceTypeTypeInfoInitializer_; + + struct AnyTypeInfoInitializer + { + AnyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Any)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + AnyTypeInfoInitializer AnyTypeInfoInitializer_; + + struct PropertyTypeInfoInitializer + { + PropertyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Property)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PropertyTypeInfoInitializer PropertyTypeInfoInitializer_; + + struct SatisfierPropertyKindTypeInfoInitializer + { + SatisfierPropertyKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SatisfierPropertyKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SatisfierPropertyKindTypeInfoInitializer SatisfierPropertyKindTypeInfoInitializer_; + + struct SatisfierPropertyTypeInfoInitializer + { + SatisfierPropertyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SatisfierProperty)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SatisfierPropertyTypeInfoInitializer SatisfierPropertyTypeInfoInitializer_; + + struct ResourceTypeInfoInitializer + { + ResourceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Resource)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceTypeInfoInitializer ResourceTypeInfoInitializer_; + + struct RequirementTypeInfoInitializer + { + RequirementTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Requirement)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + RequirementTypeInfoInitializer RequirementTypeInfoInitializer_; + + struct ResourceDeploymentDescriptionTypeInfoInitializer + { + ResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceDeploymentDescriptionTypeInfoInitializer ResourceDeploymentDescriptionTypeInfoInitializer_; + + struct ArtifactDeploymentDescriptionTypeInfoInitializer + { + ArtifactDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ArtifactDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ArtifactDeploymentDescriptionTypeInfoInitializer ArtifactDeploymentDescriptionTypeInfoInitializer_; + + struct MonolithicDeploymentDescriptionTypeInfoInitializer + { + MonolithicDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (MonolithicDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + MonolithicDeploymentDescriptionTypeInfoInitializer MonolithicDeploymentDescriptionTypeInfoInitializer_; + + struct ResourceUsageKindTypeInfoInitializer + { + ResourceUsageKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ResourceUsageKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceUsageKindTypeInfoInitializer ResourceUsageKindTypeInfoInitializer_; + + struct InstanceResourceDeploymentDescriptionTypeInfoInitializer + { + InstanceResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (InstanceResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + InstanceResourceDeploymentDescriptionTypeInfoInitializer InstanceResourceDeploymentDescriptionTypeInfoInitializer_; + + struct InstanceDeploymentDescriptionTypeInfoInitializer + { + InstanceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (InstanceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + InstanceDeploymentDescriptionTypeInfoInitializer InstanceDeploymentDescriptionTypeInfoInitializer_; + + struct CCMComponentPortKindTypeInfoInitializer + { + CCMComponentPortKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (CCMComponentPortKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + CCMComponentPortKindTypeInfoInitializer CCMComponentPortKindTypeInfoInitializer_; + + struct ComponentPortDescriptionTypeInfoInitializer + { + ComponentPortDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPortDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPortDescriptionTypeInfoInitializer ComponentPortDescriptionTypeInfoInitializer_; + + struct ComponentPropertyDescriptionTypeInfoInitializer + { + ComponentPropertyDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPropertyDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPropertyDescriptionTypeInfoInitializer ComponentPropertyDescriptionTypeInfoInitializer_; + + struct ComponentExternalPortEndpointTypeInfoInitializer + { + ComponentExternalPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentExternalPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentExternalPortEndpointTypeInfoInitializer ComponentExternalPortEndpointTypeInfoInitializer_; + + struct PlanSubcomponentPortEndpointTypeInfoInitializer + { + PlanSubcomponentPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PlanSubcomponentPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PlanSubcomponentPortEndpointTypeInfoInitializer PlanSubcomponentPortEndpointTypeInfoInitializer_; + + struct ExternalReferenceEndpointTypeInfoInitializer + { + ExternalReferenceEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ExternalReferenceEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ExternalReferenceEndpointTypeInfoInitializer ExternalReferenceEndpointTypeInfoInitializer_; + + struct ConnectionResourceDeploymentDescriptionTypeInfoInitializer + { + ConnectionResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ConnectionResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ConnectionResourceDeploymentDescriptionTypeInfoInitializer ConnectionResourceDeploymentDescriptionTypeInfoInitializer_; + + struct PlanConnectionDescriptionTypeInfoInitializer + { + PlanConnectionDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PlanConnectionDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PlanConnectionDescriptionTypeInfoInitializer PlanConnectionDescriptionTypeInfoInitializer_; + + struct ImplementationDependencyTypeInfoInitializer + { + ImplementationDependencyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ImplementationDependency)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ImplementationDependencyTypeInfoInitializer ImplementationDependencyTypeInfoInitializer_; + + struct CapabilityTypeInfoInitializer + { + CapabilityTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Capability)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + CapabilityTypeInfoInitializer CapabilityTypeInfoInitializer_; + + struct ImplementationRequirementTypeInfoInitializer + { + ImplementationRequirementTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ImplementationRequirement)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ImplementationRequirementTypeInfoInitializer ImplementationRequirementTypeInfoInitializer_; + + struct ComponentPackageReferenceTypeInfoInitializer + { + ComponentPackageReferenceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPackageReference)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPackageReferenceTypeInfoInitializer ComponentPackageReferenceTypeInfoInitializer_; + + struct SubcomponentPortEndpointTypeInfoInitializer + { + SubcomponentPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SubcomponentPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SubcomponentPortEndpointTypeInfoInitializer SubcomponentPortEndpointTypeInfoInitializer_; + + struct AssemblyConnectionDescriptionTypeInfoInitializer + { + AssemblyConnectionDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (AssemblyConnectionDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + AssemblyConnectionDescriptionTypeInfoInitializer AssemblyConnectionDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // DataType + // + // + + void DataType:: + traverse (Type& o) + { + pre (o); + kind (o); + if (o.enum_p ()) enum_ (o); + else enum_none (o); + if (o.struct_p ()) struct_ (o); + else struct_none (o); + if (o.value_p ()) value (o); + else value_none (o); + if (o.sequence_p ()) sequence (o); + else sequence_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void DataType:: + traverse (Type const& o) + { + pre (o); + kind (o); + if (o.enum_p ()) enum_ (o); + else enum_none (o); + if (o.struct_p ()) struct_ (o); + else struct_none (o); + if (o.value_p ()) value (o); + else value_none (o); + if (o.sequence_p ()) sequence (o); + else sequence_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void DataType:: + pre (Type&) + { + } + + void DataType:: + pre (Type const&) + { + } + + void DataType:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void DataType:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void DataType:: + enum_ (Type& o) + { + dispatch (o.enum_ ()); + } + + void DataType:: + enum_ (Type const& o) + { + dispatch (o.enum_ ()); + } + + void DataType:: + enum_none (Type&) + { + } + + void DataType:: + enum_none (Type const&) + { + } + + void DataType:: + struct_ (Type& o) + { + dispatch (o.struct_ ()); + } + + void DataType:: + struct_ (Type const& o) + { + dispatch (o.struct_ ()); + } + + void DataType:: + struct_none (Type&) + { + } + + void DataType:: + struct_none (Type const&) + { + } + + void DataType:: + value (Type& o) + { + dispatch (o.value ()); + } + + void DataType:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void DataType:: + value_none (Type&) + { + } + + void DataType:: + value_none (Type const&) + { + } + + void DataType:: + sequence (Type& o) + { + dispatch (o.sequence ()); + } + + void DataType:: + sequence (Type const& o) + { + dispatch (o.sequence ()); + } + + void DataType:: + sequence_none (Type&) + { + } + + void DataType:: + sequence_none (Type const&) + { + } + + void DataType:: + id (Type& o) + { + dispatch (o.id ()); + } + + void DataType:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void DataType:: + id_none (Type&) + { + } + + void DataType:: + id_none (Type const&) + { + } + + void DataType:: + post (Type&) + { + } + + void DataType:: + post (Type const&) + { + } + + // DataValue + // + // + + void DataValue:: + traverse (Type& o) + { + pre (o); + short_ (o); + long_ (o); + ushort (o); + ulong (o); + float_ (o); + double_ (o); + boolean (o); + octet (o); + enum_ (o); + string (o); + longlong (o); + ulonglong (o); + longdouble (o); + member (o); + post (o); + } + + void DataValue:: + traverse (Type const& o) + { + pre (o); + short_ (o); + long_ (o); + ushort (o); + ulong (o); + float_ (o); + double_ (o); + boolean (o); + octet (o); + enum_ (o); + string (o); + longlong (o); + ulonglong (o); + longdouble (o); + member (o); + post (o); + } + + void DataValue:: + pre (Type&) + { + } + + void DataValue:: + pre (Type const&) + { + } + + void DataValue:: + short_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::short_iterator b (o.begin_short()), e (o.end_short()); + + if (b != e) + { + short_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) short_next (o); + } + + short_post (o); + } + + else short_none (o); + } + + void DataValue:: + short_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::short_const_iterator b (o.begin_short()), e (o.end_short()); + + if (b != e) + { + short_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) short_next (o); + } + + short_post (o); + } + + else short_none (o); + } + + void DataValue:: + short_pre (Type&) + { + } + + void DataValue:: + short_pre (Type const&) + { + } + + void DataValue:: + short_next (Type&) + { + } + + void DataValue:: + short_next (Type const&) + { + } + + void DataValue:: + short_post (Type&) + { + } + + void DataValue:: + short_post (Type const&) + { + } + + void DataValue:: + short_none (Type&) + { + } + + void DataValue:: + short_none (Type const&) + { + } + + void DataValue:: + long_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::long_iterator b (o.begin_long()), e (o.end_long()); + + if (b != e) + { + long_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) long_next (o); + } + + long_post (o); + } + + else long_none (o); + } + + void DataValue:: + long_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::long_const_iterator b (o.begin_long()), e (o.end_long()); + + if (b != e) + { + long_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) long_next (o); + } + + long_post (o); + } + + else long_none (o); + } + + void DataValue:: + long_pre (Type&) + { + } + + void DataValue:: + long_pre (Type const&) + { + } + + void DataValue:: + long_next (Type&) + { + } + + void DataValue:: + long_next (Type const&) + { + } + + void DataValue:: + long_post (Type&) + { + } + + void DataValue:: + long_post (Type const&) + { + } + + void DataValue:: + long_none (Type&) + { + } + + void DataValue:: + long_none (Type const&) + { + } + + void DataValue:: + ushort (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ushort_iterator b (o.begin_ushort()), e (o.end_ushort()); + + if (b != e) + { + ushort_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ushort_next (o); + } + + ushort_post (o); + } + + else ushort_none (o); + } + + void DataValue:: + ushort (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ushort_const_iterator b (o.begin_ushort()), e (o.end_ushort()); + + if (b != e) + { + ushort_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ushort_next (o); + } + + ushort_post (o); + } + + else ushort_none (o); + } + + void DataValue:: + ushort_pre (Type&) + { + } + + void DataValue:: + ushort_pre (Type const&) + { + } + + void DataValue:: + ushort_next (Type&) + { + } + + void DataValue:: + ushort_next (Type const&) + { + } + + void DataValue:: + ushort_post (Type&) + { + } + + void DataValue:: + ushort_post (Type const&) + { + } + + void DataValue:: + ushort_none (Type&) + { + } + + void DataValue:: + ushort_none (Type const&) + { + } + + void DataValue:: + ulong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulong_iterator b (o.begin_ulong()), e (o.end_ulong()); + + if (b != e) + { + ulong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulong_next (o); + } + + ulong_post (o); + } + + else ulong_none (o); + } + + void DataValue:: + ulong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulong_const_iterator b (o.begin_ulong()), e (o.end_ulong()); + + if (b != e) + { + ulong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulong_next (o); + } + + ulong_post (o); + } + + else ulong_none (o); + } + + void DataValue:: + ulong_pre (Type&) + { + } + + void DataValue:: + ulong_pre (Type const&) + { + } + + void DataValue:: + ulong_next (Type&) + { + } + + void DataValue:: + ulong_next (Type const&) + { + } + + void DataValue:: + ulong_post (Type&) + { + } + + void DataValue:: + ulong_post (Type const&) + { + } + + void DataValue:: + ulong_none (Type&) + { + } + + void DataValue:: + ulong_none (Type const&) + { + } + + void DataValue:: + float_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::float_iterator b (o.begin_float()), e (o.end_float()); + + if (b != e) + { + float_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) float_next (o); + } + + float_post (o); + } + + else float_none (o); + } + + void DataValue:: + float_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::float_const_iterator b (o.begin_float()), e (o.end_float()); + + if (b != e) + { + float_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) float_next (o); + } + + float_post (o); + } + + else float_none (o); + } + + void DataValue:: + float_pre (Type&) + { + } + + void DataValue:: + float_pre (Type const&) + { + } + + void DataValue:: + float_next (Type&) + { + } + + void DataValue:: + float_next (Type const&) + { + } + + void DataValue:: + float_post (Type&) + { + } + + void DataValue:: + float_post (Type const&) + { + } + + void DataValue:: + float_none (Type&) + { + } + + void DataValue:: + float_none (Type const&) + { + } + + void DataValue:: + double_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::double_iterator b (o.begin_double()), e (o.end_double()); + + if (b != e) + { + double_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) double_next (o); + } + + double_post (o); + } + + else double_none (o); + } + + void DataValue:: + double_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::double_const_iterator b (o.begin_double()), e (o.end_double()); + + if (b != e) + { + double_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) double_next (o); + } + + double_post (o); + } + + else double_none (o); + } + + void DataValue:: + double_pre (Type&) + { + } + + void DataValue:: + double_pre (Type const&) + { + } + + void DataValue:: + double_next (Type&) + { + } + + void DataValue:: + double_next (Type const&) + { + } + + void DataValue:: + double_post (Type&) + { + } + + void DataValue:: + double_post (Type const&) + { + } + + void DataValue:: + double_none (Type&) + { + } + + void DataValue:: + double_none (Type const&) + { + } + + void DataValue:: + boolean (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::boolean_iterator b (o.begin_boolean()), e (o.end_boolean()); + + if (b != e) + { + boolean_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) boolean_next (o); + } + + boolean_post (o); + } + + else boolean_none (o); + } + + void DataValue:: + boolean (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::boolean_const_iterator b (o.begin_boolean()), e (o.end_boolean()); + + if (b != e) + { + boolean_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) boolean_next (o); + } + + boolean_post (o); + } + + else boolean_none (o); + } + + void DataValue:: + boolean_pre (Type&) + { + } + + void DataValue:: + boolean_pre (Type const&) + { + } + + void DataValue:: + boolean_next (Type&) + { + } + + void DataValue:: + boolean_next (Type const&) + { + } + + void DataValue:: + boolean_post (Type&) + { + } + + void DataValue:: + boolean_post (Type const&) + { + } + + void DataValue:: + boolean_none (Type&) + { + } + + void DataValue:: + boolean_none (Type const&) + { + } + + void DataValue:: + octet (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::octet_iterator b (o.begin_octet()), e (o.end_octet()); + + if (b != e) + { + octet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) octet_next (o); + } + + octet_post (o); + } + + else octet_none (o); + } + + void DataValue:: + octet (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::octet_const_iterator b (o.begin_octet()), e (o.end_octet()); + + if (b != e) + { + octet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) octet_next (o); + } + + octet_post (o); + } + + else octet_none (o); + } + + void DataValue:: + octet_pre (Type&) + { + } + + void DataValue:: + octet_pre (Type const&) + { + } + + void DataValue:: + octet_next (Type&) + { + } + + void DataValue:: + octet_next (Type const&) + { + } + + void DataValue:: + octet_post (Type&) + { + } + + void DataValue:: + octet_post (Type const&) + { + } + + void DataValue:: + octet_none (Type&) + { + } + + void DataValue:: + octet_none (Type const&) + { + } + + void DataValue:: + enum_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::enum_iterator b (o.begin_enum()), e (o.end_enum()); + + if (b != e) + { + enum_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) enum_next (o); + } + + enum_post (o); + } + + else enum_none (o); + } + + void DataValue:: + enum_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::enum_const_iterator b (o.begin_enum()), e (o.end_enum()); + + if (b != e) + { + enum_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) enum_next (o); + } + + enum_post (o); + } + + else enum_none (o); + } + + void DataValue:: + enum_pre (Type&) + { + } + + void DataValue:: + enum_pre (Type const&) + { + } + + void DataValue:: + enum_next (Type&) + { + } + + void DataValue:: + enum_next (Type const&) + { + } + + void DataValue:: + enum_post (Type&) + { + } + + void DataValue:: + enum_post (Type const&) + { + } + + void DataValue:: + enum_none (Type&) + { + } + + void DataValue:: + enum_none (Type const&) + { + } + + void DataValue:: + string (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::string_iterator b (o.begin_string()), e (o.end_string()); + + if (b != e) + { + string_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) string_next (o); + } + + string_post (o); + } + + else string_none (o); + } + + void DataValue:: + string (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::string_const_iterator b (o.begin_string()), e (o.end_string()); + + if (b != e) + { + string_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) string_next (o); + } + + string_post (o); + } + + else string_none (o); + } + + void DataValue:: + string_pre (Type&) + { + } + + void DataValue:: + string_pre (Type const&) + { + } + + void DataValue:: + string_next (Type&) + { + } + + void DataValue:: + string_next (Type const&) + { + } + + void DataValue:: + string_post (Type&) + { + } + + void DataValue:: + string_post (Type const&) + { + } + + void DataValue:: + string_none (Type&) + { + } + + void DataValue:: + string_none (Type const&) + { + } + + void DataValue:: + longlong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longlong_iterator b (o.begin_longlong()), e (o.end_longlong()); + + if (b != e) + { + longlong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longlong_next (o); + } + + longlong_post (o); + } + + else longlong_none (o); + } + + void DataValue:: + longlong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longlong_const_iterator b (o.begin_longlong()), e (o.end_longlong()); + + if (b != e) + { + longlong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longlong_next (o); + } + + longlong_post (o); + } + + else longlong_none (o); + } + + void DataValue:: + longlong_pre (Type&) + { + } + + void DataValue:: + longlong_pre (Type const&) + { + } + + void DataValue:: + longlong_next (Type&) + { + } + + void DataValue:: + longlong_next (Type const&) + { + } + + void DataValue:: + longlong_post (Type&) + { + } + + void DataValue:: + longlong_post (Type const&) + { + } + + void DataValue:: + longlong_none (Type&) + { + } + + void DataValue:: + longlong_none (Type const&) + { + } + + void DataValue:: + ulonglong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulonglong_iterator b (o.begin_ulonglong()), e (o.end_ulonglong()); + + if (b != e) + { + ulonglong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulonglong_next (o); + } + + ulonglong_post (o); + } + + else ulonglong_none (o); + } + + void DataValue:: + ulonglong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulonglong_const_iterator b (o.begin_ulonglong()), e (o.end_ulonglong()); + + if (b != e) + { + ulonglong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulonglong_next (o); + } + + ulonglong_post (o); + } + + else ulonglong_none (o); + } + + void DataValue:: + ulonglong_pre (Type&) + { + } + + void DataValue:: + ulonglong_pre (Type const&) + { + } + + void DataValue:: + ulonglong_next (Type&) + { + } + + void DataValue:: + ulonglong_next (Type const&) + { + } + + void DataValue:: + ulonglong_post (Type&) + { + } + + void DataValue:: + ulonglong_post (Type const&) + { + } + + void DataValue:: + ulonglong_none (Type&) + { + } + + void DataValue:: + ulonglong_none (Type const&) + { + } + + void DataValue:: + longdouble (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longdouble_iterator b (o.begin_longdouble()), e (o.end_longdouble()); + + if (b != e) + { + longdouble_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longdouble_next (o); + } + + longdouble_post (o); + } + + else longdouble_none (o); + } + + void DataValue:: + longdouble (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longdouble_const_iterator b (o.begin_longdouble()), e (o.end_longdouble()); + + if (b != e) + { + longdouble_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longdouble_next (o); + } + + longdouble_post (o); + } + + else longdouble_none (o); + } + + void DataValue:: + longdouble_pre (Type&) + { + } + + void DataValue:: + longdouble_pre (Type const&) + { + } + + void DataValue:: + longdouble_next (Type&) + { + } + + void DataValue:: + longdouble_next (Type const&) + { + } + + void DataValue:: + longdouble_post (Type&) + { + } + + void DataValue:: + longdouble_post (Type const&) + { + } + + void DataValue:: + longdouble_none (Type&) + { + } + + void DataValue:: + longdouble_none (Type const&) + { + } + + void DataValue:: + member (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void DataValue:: + member (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void DataValue:: + member_pre (Type&) + { + } + + void DataValue:: + member_pre (Type const&) + { + } + + void DataValue:: + member_next (Type&) + { + } + + void DataValue:: + member_next (Type const&) + { + } + + void DataValue:: + member_post (Type&) + { + } + + void DataValue:: + member_post (Type const&) + { + } + + void DataValue:: + member_none (Type&) + { + } + + void DataValue:: + member_none (Type const&) + { + } + + void DataValue:: + post (Type&) + { + } + + void DataValue:: + post (Type const&) + { + } + + // EnumType + // + // + + void EnumType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void EnumType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void EnumType:: + pre (Type&) + { + } + + void EnumType:: + pre (Type const&) + { + } + + void EnumType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void EnumType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void EnumType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void EnumType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void EnumType:: + member (Type& o) + { + // VC6 anathema strikes again + // + EnumType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + } + + void EnumType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + EnumType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + } + + void EnumType:: + member_pre (Type&) + { + } + + void EnumType:: + member_pre (Type const&) + { + } + + void EnumType:: + member_next (Type&) + { + } + + void EnumType:: + member_next (Type const&) + { + } + + void EnumType:: + member_post (Type&) + { + } + + void EnumType:: + member_post (Type const&) + { + } + + void EnumType:: + post (Type&) + { + } + + void EnumType:: + post (Type const&) + { + } + + // StructType + // + // + + void StructType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void StructType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void StructType:: + pre (Type&) + { + } + + void StructType:: + pre (Type const&) + { + } + + void StructType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void StructType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void StructType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void StructType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void StructType:: + member (Type& o) + { + // VC6 anathema strikes again + // + StructType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void StructType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + StructType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void StructType:: + member_pre (Type&) + { + } + + void StructType:: + member_pre (Type const&) + { + } + + void StructType:: + member_next (Type&) + { + } + + void StructType:: + member_next (Type const&) + { + } + + void StructType:: + member_post (Type&) + { + } + + void StructType:: + member_post (Type const&) + { + } + + void StructType:: + member_none (Type&) + { + } + + void StructType:: + member_none (Type const&) + { + } + + void StructType:: + post (Type&) + { + } + + void StructType:: + post (Type const&) + { + } + + // StructMemberType + // + // + + void StructMemberType:: + traverse (Type& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void StructMemberType:: + traverse (Type const& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void StructMemberType:: + pre (Type&) + { + } + + void StructMemberType:: + pre (Type const&) + { + } + + void StructMemberType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void StructMemberType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void StructMemberType:: + type (Type& o) + { + dispatch (o.type ()); + } + + void StructMemberType:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void StructMemberType:: + post (Type&) + { + } + + void StructMemberType:: + post (Type const&) + { + } + + // ValueType + // + // + + void ValueType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + modifier (o); + baseType (o); + member (o); + post (o); + } + + void ValueType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + modifier (o); + baseType (o); + member (o); + post (o); + } + + void ValueType:: + pre (Type&) + { + } + + void ValueType:: + pre (Type const&) + { + } + + void ValueType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ValueType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ValueType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void ValueType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void ValueType:: + modifier (Type& o) + { + dispatch (o.modifier ()); + } + + void ValueType:: + modifier (Type const& o) + { + dispatch (o.modifier ()); + } + + void ValueType:: + baseType (Type& o) + { + dispatch (o.baseType ()); + } + + void ValueType:: + baseType (Type const& o) + { + dispatch (o.baseType ()); + } + + void ValueType:: + member (Type& o) + { + // VC6 anathema strikes again + // + ValueType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void ValueType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + ValueType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void ValueType:: + member_pre (Type&) + { + } + + void ValueType:: + member_pre (Type const&) + { + } + + void ValueType:: + member_next (Type&) + { + } + + void ValueType:: + member_next (Type const&) + { + } + + void ValueType:: + member_post (Type&) + { + } + + void ValueType:: + member_post (Type const&) + { + } + + void ValueType:: + member_none (Type&) + { + } + + void ValueType:: + member_none (Type const&) + { + } + + void ValueType:: + post (Type&) + { + } + + void ValueType:: + post (Type const&) + { + } + + // ValueMemberType + // + // + + void ValueMemberType:: + traverse (Type& o) + { + pre (o); + name (o); + visibility (o); + type (o); + post (o); + } + + void ValueMemberType:: + traverse (Type const& o) + { + pre (o); + name (o); + visibility (o); + type (o); + post (o); + } + + void ValueMemberType:: + pre (Type&) + { + } + + void ValueMemberType:: + pre (Type const&) + { + } + + void ValueMemberType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ValueMemberType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ValueMemberType:: + visibility (Type& o) + { + dispatch (o.visibility ()); + } + + void ValueMemberType:: + visibility (Type const& o) + { + dispatch (o.visibility ()); + } + + void ValueMemberType:: + type (Type& o) + { + dispatch (o.type ()); + } + + void ValueMemberType:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void ValueMemberType:: + post (Type&) + { + } + + void ValueMemberType:: + post (Type const&) + { + } + + // NamedValue + // + // + + void NamedValue:: + traverse (Type& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void NamedValue:: + traverse (Type const& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void NamedValue:: + pre (Type&) + { + } + + void NamedValue:: + pre (Type const&) + { + } + + void NamedValue:: + name (Type& o) + { + dispatch (o.name ()); + } + + void NamedValue:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void NamedValue:: + value (Type& o) + { + dispatch (o.value ()); + } + + void NamedValue:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void NamedValue:: + post (Type&) + { + } + + void NamedValue:: + post (Type const&) + { + } + + // SequenceType + // + // + + void SequenceType:: + traverse (Type& o) + { + pre (o); + if (o.bound_p ()) bound (o); + else bound_none (o); + elementType (o); + post (o); + } + + void SequenceType:: + traverse (Type const& o) + { + pre (o); + if (o.bound_p ()) bound (o); + else bound_none (o); + elementType (o); + post (o); + } + + void SequenceType:: + pre (Type&) + { + } + + void SequenceType:: + pre (Type const&) + { + } + + void SequenceType:: + bound (Type& o) + { + dispatch (o.bound ()); + } + + void SequenceType:: + bound (Type const& o) + { + dispatch (o.bound ()); + } + + void SequenceType:: + bound_none (Type&) + { + } + + void SequenceType:: + bound_none (Type const&) + { + } + + void SequenceType:: + elementType (Type& o) + { + dispatch (o.elementType ()); + } + + void SequenceType:: + elementType (Type const& o) + { + dispatch (o.elementType ()); + } + + void SequenceType:: + post (Type&) + { + } + + void SequenceType:: + post (Type const&) + { + } + + // Any + // + // + + void Any:: + traverse (Type& o) + { + pre (o); + type (o); + value (o); + post (o); + } + + void Any:: + traverse (Type const& o) + { + pre (o); + type (o); + value (o); + post (o); + } + + void Any:: + pre (Type&) + { + } + + void Any:: + pre (Type const&) + { + } + + void Any:: + type (Type& o) + { + dispatch (o.type ()); + } + + void Any:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void Any:: + value (Type& o) + { + dispatch (o.value ()); + } + + void Any:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void Any:: + post (Type&) + { + } + + void Any:: + post (Type const&) + { + } + + // Property + // + // + + void Property:: + traverse (Type& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void Property:: + traverse (Type const& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void Property:: + pre (Type&) + { + } + + void Property:: + pre (Type const&) + { + } + + void Property:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Property:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Property:: + value (Type& o) + { + dispatch (o.value ()); + } + + void Property:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void Property:: + post (Type&) + { + } + + void Property:: + post (Type const&) + { + } + + // SatisfierProperty + // + // + + void SatisfierProperty:: + traverse (Type& o) + { + pre (o); + name (o); + kind (o); + dynamic (o); + value (o); + post (o); + } + + void SatisfierProperty:: + traverse (Type const& o) + { + pre (o); + name (o); + kind (o); + dynamic (o); + value (o); + post (o); + } + + void SatisfierProperty:: + pre (Type&) + { + } + + void SatisfierProperty:: + pre (Type const&) + { + } + + void SatisfierProperty:: + name (Type& o) + { + dispatch (o.name ()); + } + + void SatisfierProperty:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void SatisfierProperty:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void SatisfierProperty:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void SatisfierProperty:: + dynamic (Type& o) + { + dispatch (o.dynamic ()); + } + + void SatisfierProperty:: + dynamic (Type const& o) + { + dispatch (o.dynamic ()); + } + + void SatisfierProperty:: + value (Type& o) + { + dispatch (o.value ()); + } + + void SatisfierProperty:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void SatisfierProperty:: + post (Type&) + { + } + + void SatisfierProperty:: + post (Type const&) + { + } + + // Resource + // + // + + void Resource:: + traverse (Type& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Resource:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Resource:: + pre (Type&) + { + } + + void Resource:: + pre (Type const&) + { + } + + void Resource:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Resource:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Resource:: + resourceType (Type& o) + { + // VC6 anathema strikes again + // + Resource::Type::resourceType_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Resource:: + resourceType (Type const& o) + { + // VC6 anathema strikes again + // + Resource::Type::resourceType_const_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Resource:: + resourceType_pre (Type&) + { + } + + void Resource:: + resourceType_pre (Type const&) + { + } + + void Resource:: + resourceType_next (Type&) + { + } + + void Resource:: + resourceType_next (Type const&) + { + } + + void Resource:: + resourceType_post (Type&) + { + } + + void Resource:: + resourceType_post (Type const&) + { + } + + void Resource:: + property (Type& o) + { + // VC6 anathema strikes again + // + Resource::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Resource:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Resource::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Resource:: + property_pre (Type&) + { + } + + void Resource:: + property_pre (Type const&) + { + } + + void Resource:: + property_next (Type&) + { + } + + void Resource:: + property_next (Type const&) + { + } + + void Resource:: + property_post (Type&) + { + } + + void Resource:: + property_post (Type const&) + { + } + + void Resource:: + property_none (Type&) + { + } + + void Resource:: + property_none (Type const&) + { + } + + void Resource:: + post (Type&) + { + } + + void Resource:: + post (Type const&) + { + } + + // Requirement + // + // + + void Requirement:: + traverse (Type& o) + { + pre (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void Requirement:: + traverse (Type const& o) + { + pre (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void Requirement:: + pre (Type&) + { + } + + void Requirement:: + pre (Type const&) + { + } + + void Requirement:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Requirement:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Requirement:: + property (Type& o) + { + // VC6 anathema strikes again + // + Requirement::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Requirement:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Requirement::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Requirement:: + property_pre (Type&) + { + } + + void Requirement:: + property_pre (Type const&) + { + } + + void Requirement:: + property_next (Type&) + { + } + + void Requirement:: + property_next (Type const&) + { + } + + void Requirement:: + property_post (Type&) + { + } + + void Requirement:: + property_post (Type const&) + { + } + + void Requirement:: + property_none (Type&) + { + } + + void Requirement:: + property_none (Type const&) + { + } + + void Requirement:: + post (Type&) + { + } + + void Requirement:: + post (Type const&) + { + } + + // ResourceDeploymentDescription + // + // + + void ResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ResourceDeploymentDescription:: + pre (Type&) + { + } + + void ResourceDeploymentDescription:: + pre (Type const&) + { + } + + void ResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void ResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void ResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void ResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void ResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + ResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void ResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_next (Type&) + { + } + + void ResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_post (Type&) + { + } + + void ResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_none (Type&) + { + } + + void ResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void ResourceDeploymentDescription:: + post (Type&) + { + } + + void ResourceDeploymentDescription:: + post (Type const&) + { + } + + // ArtifactDeploymentDescription + // + // + + void ArtifactDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + source (o); + node (o); + location (o); + execParameter (o); + deployRequirement (o); + deployedResource (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ArtifactDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + source (o); + node (o); + location (o); + execParameter (o); + deployRequirement (o); + deployedResource (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ArtifactDeploymentDescription:: + pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ArtifactDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ArtifactDeploymentDescription:: + source (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::source_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void ArtifactDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::source_const_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void ArtifactDeploymentDescription:: + source_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + source_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + source_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + node (Type& o) + { + dispatch (o.node ()); + } + + void ArtifactDeploymentDescription:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void ArtifactDeploymentDescription:: + location (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::location_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void ArtifactDeploymentDescription:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::location_const_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void ArtifactDeploymentDescription:: + location_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + location_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + location_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::execParameter_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void ArtifactDeploymentDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::execParameter_const_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void ArtifactDeploymentDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ArtifactDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ArtifactDeploymentDescription:: + id_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + id_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + post (Type&) + { + } + + void ArtifactDeploymentDescription:: + post (Type const&) + { + } + + // MonolithicDeploymentDescription + // + // + + void MonolithicDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + source (o); + artifact (o); + execParameter (o); + deployRequirement (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void MonolithicDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + source (o); + artifact (o); + execParameter (o); + deployRequirement (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void MonolithicDeploymentDescription:: + pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void MonolithicDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void MonolithicDeploymentDescription:: + source (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::source_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void MonolithicDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::source_const_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void MonolithicDeploymentDescription:: + source_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + source_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + source_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::artifact_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + } + + void MonolithicDeploymentDescription:: + artifact (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::artifact_const_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::execParameter_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void MonolithicDeploymentDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::execParameter_const_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void MonolithicDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void MonolithicDeploymentDescription:: + id_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + id_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + post (Type&) + { + } + + void MonolithicDeploymentDescription:: + post (Type const&) + { + } + + // InstanceResourceDeploymentDescription + // + // + + void InstanceResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + resourceUsage (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void InstanceResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + resourceUsage (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void InstanceResourceDeploymentDescription:: + pre (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + pre (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type& o) + { + dispatch (o.resourceUsage ()); + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type const& o) + { + dispatch (o.resourceUsage ()); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void InstanceResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + InstanceResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void InstanceResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + InstanceResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_next (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_post (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_none (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + post (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + post (Type const&) + { + } + + // InstanceDeploymentDescription + // + // + + void InstanceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + node (o); + source (o); + implementation (o); + configProperty (o); + deployedResource (o); + if (o.deployedSharedResource_p ()) deployedSharedResource (o); + else deployedSharedResource_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void InstanceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + node (o); + source (o); + implementation (o); + configProperty (o); + deployedResource (o); + if (o.deployedSharedResource_p ()) deployedSharedResource (o); + else deployedSharedResource_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void InstanceDeploymentDescription:: + pre (Type&) + { + } + + void InstanceDeploymentDescription:: + pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void InstanceDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void InstanceDeploymentDescription:: + node (Type& o) + { + dispatch (o.node ()); + } + + void InstanceDeploymentDescription:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void InstanceDeploymentDescription:: + source (Type& o) + { + dispatch (o.source ()); + } + + void InstanceDeploymentDescription:: + source (Type const& o) + { + dispatch (o.source ()); + } + + void InstanceDeploymentDescription:: + implementation (Type& o) + { + dispatch (o.implementation ()); + } + + void InstanceDeploymentDescription:: + implementation (Type const& o) + { + dispatch (o.implementation ()); + } + + void InstanceDeploymentDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void InstanceDeploymentDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_next (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_next (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_post (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_post (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_none (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void InstanceDeploymentDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_none (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type& o) + { + dispatch (o.deployedSharedResource ()); + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type const& o) + { + dispatch (o.deployedSharedResource ()); + } + + void InstanceDeploymentDescription:: + deployedSharedResource_none (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedSharedResource_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void InstanceDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void InstanceDeploymentDescription:: + id_none (Type&) + { + } + + void InstanceDeploymentDescription:: + id_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + post (Type&) + { + } + + void InstanceDeploymentDescription:: + post (Type const&) + { + } + + // ComponentPortDescription + // + // + + void ComponentPortDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + provider (o); + exclusiveProvider (o); + exclusiveUser (o); + optional (o); + kind (o); + post (o); + } + + void ComponentPortDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + provider (o); + exclusiveProvider (o); + exclusiveUser (o); + optional (o); + kind (o); + post (o); + } + + void ComponentPortDescription:: + pre (Type&) + { + } + + void ComponentPortDescription:: + pre (Type const&) + { + } + + void ComponentPortDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ComponentPortDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ComponentPortDescription:: + specificType (Type& o) + { + dispatch (o.specificType ()); + } + + void ComponentPortDescription:: + specificType (Type const& o) + { + dispatch (o.specificType ()); + } + + void ComponentPortDescription:: + specificType_none (Type&) + { + } + + void ComponentPortDescription:: + specificType_none (Type const&) + { + } + + void ComponentPortDescription:: + supportedType (Type& o) + { + // VC6 anathema strikes again + // + ComponentPortDescription::Type::supportedType_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void ComponentPortDescription:: + supportedType (Type const& o) + { + // VC6 anathema strikes again + // + ComponentPortDescription::Type::supportedType_const_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void ComponentPortDescription:: + supportedType_pre (Type&) + { + } + + void ComponentPortDescription:: + supportedType_pre (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_next (Type&) + { + } + + void ComponentPortDescription:: + supportedType_next (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_post (Type&) + { + } + + void ComponentPortDescription:: + supportedType_post (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_none (Type&) + { + } + + void ComponentPortDescription:: + supportedType_none (Type const&) + { + } + + void ComponentPortDescription:: + provider (Type& o) + { + dispatch (o.provider ()); + } + + void ComponentPortDescription:: + provider (Type const& o) + { + dispatch (o.provider ()); + } + + void ComponentPortDescription:: + exclusiveProvider (Type& o) + { + dispatch (o.exclusiveProvider ()); + } + + void ComponentPortDescription:: + exclusiveProvider (Type const& o) + { + dispatch (o.exclusiveProvider ()); + } + + void ComponentPortDescription:: + exclusiveUser (Type& o) + { + dispatch (o.exclusiveUser ()); + } + + void ComponentPortDescription:: + exclusiveUser (Type const& o) + { + dispatch (o.exclusiveUser ()); + } + + void ComponentPortDescription:: + optional (Type& o) + { + dispatch (o.optional ()); + } + + void ComponentPortDescription:: + optional (Type const& o) + { + dispatch (o.optional ()); + } + + void ComponentPortDescription:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void ComponentPortDescription:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void ComponentPortDescription:: + post (Type&) + { + } + + void ComponentPortDescription:: + post (Type const&) + { + } + + // ComponentPropertyDescription + // + // + + void ComponentPropertyDescription:: + traverse (Type& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void ComponentPropertyDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void ComponentPropertyDescription:: + pre (Type&) + { + } + + void ComponentPropertyDescription:: + pre (Type const&) + { + } + + void ComponentPropertyDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ComponentPropertyDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ComponentPropertyDescription:: + type (Type& o) + { + dispatch (o.type ()); + } + + void ComponentPropertyDescription:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void ComponentPropertyDescription:: + post (Type&) + { + } + + void ComponentPropertyDescription:: + post (Type const&) + { + } + + // ComponentExternalPortEndpoint + // + // + + void ComponentExternalPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + post (o); + } + + void ComponentExternalPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + post (o); + } + + void ComponentExternalPortEndpoint:: + pre (Type&) + { + } + + void ComponentExternalPortEndpoint:: + pre (Type const&) + { + } + + void ComponentExternalPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void ComponentExternalPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void ComponentExternalPortEndpoint:: + post (Type&) + { + } + + void ComponentExternalPortEndpoint:: + post (Type const&) + { + } + + // PlanSubcomponentPortEndpoint + // + // + + void PlanSubcomponentPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + if (o.provider_p ()) provider (o); + else provider_none (o); + kind (o); + instance (o); + post (o); + } + + void PlanSubcomponentPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + if (o.provider_p ()) provider (o); + else provider_none (o); + kind (o); + instance (o); + post (o); + } + + void PlanSubcomponentPortEndpoint:: + pre (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + pre (Type const&) + { + } + + void PlanSubcomponentPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void PlanSubcomponentPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type& o) + { + dispatch (o.provider ()); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type const& o) + { + dispatch (o.provider ()); + } + + void PlanSubcomponentPortEndpoint:: + provider_none (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + provider_none (Type const&) + { + } + + void PlanSubcomponentPortEndpoint:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void PlanSubcomponentPortEndpoint:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPortEndpoint:: + post (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + post (Type const&) + { + } + + // ExternalReferenceEndpoint + // + // + + void ExternalReferenceEndpoint:: + traverse (Type& o) + { + pre (o); + location (o); + post (o); + } + + void ExternalReferenceEndpoint:: + traverse (Type const& o) + { + pre (o); + location (o); + post (o); + } + + void ExternalReferenceEndpoint:: + pre (Type&) + { + } + + void ExternalReferenceEndpoint:: + pre (Type const&) + { + } + + void ExternalReferenceEndpoint:: + location (Type& o) + { + dispatch (o.location ()); + } + + void ExternalReferenceEndpoint:: + location (Type const& o) + { + dispatch (o.location ()); + } + + void ExternalReferenceEndpoint:: + post (Type&) + { + } + + void ExternalReferenceEndpoint:: + post (Type const&) + { + } + + // ConnectionResourceDeploymentDescription + // + // + + void ConnectionResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + targetName (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ConnectionResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + targetName (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ConnectionResourceDeploymentDescription:: + pre (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + pre (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type& o) + { + dispatch (o.targetName ()); + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type const& o) + { + dispatch (o.targetName ()); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void ConnectionResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + ConnectionResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ConnectionResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ConnectionResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_none (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + post (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + post (Type const&) + { + } + + // PlanConnectionDescription + // + // + + void PlanConnectionDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.source_p ()) source (o); + else source_none (o); + deployRequirement (o); + externalEndpoint (o); + internalEndpoint (o); + externalReference (o); + deployedResource (o); + post (o); + } + + void PlanConnectionDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.source_p ()) source (o); + else source_none (o); + deployRequirement (o); + externalEndpoint (o); + internalEndpoint (o); + externalReference (o); + deployedResource (o); + post (o); + } + + void PlanConnectionDescription:: + pre (Type&) + { + } + + void PlanConnectionDescription:: + pre (Type const&) + { + } + + void PlanConnectionDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void PlanConnectionDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void PlanConnectionDescription:: + source (Type& o) + { + dispatch (o.source ()); + } + + void PlanConnectionDescription:: + source (Type const& o) + { + dispatch (o.source ()); + } + + void PlanConnectionDescription:: + source_none (Type&) + { + } + + void PlanConnectionDescription:: + source_none (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void PlanConnectionDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_next (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_next (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_post (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_post (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_none (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_none (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalEndpoint_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void PlanConnectionDescription:: + externalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalEndpoint_const_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_none (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_none (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::internalEndpoint_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void PlanConnectionDescription:: + internalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::internalEndpoint_const_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_none (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_none (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalReference_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void PlanConnectionDescription:: + externalReference (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalReference_const_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void PlanConnectionDescription:: + externalReference_pre (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_pre (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_next (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_next (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_post (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_post (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_none (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_none (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void PlanConnectionDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void PlanConnectionDescription:: + deployedResource_pre (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_pre (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_next (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_next (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_post (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_post (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_none (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_none (Type const&) + { + } + + void PlanConnectionDescription:: + post (Type&) + { + } + + void PlanConnectionDescription:: + post (Type const&) + { + } + + // ImplementationDependency + // + // + + void ImplementationDependency:: + traverse (Type& o) + { + pre (o); + requiredType (o); + post (o); + } + + void ImplementationDependency:: + traverse (Type const& o) + { + pre (o); + requiredType (o); + post (o); + } + + void ImplementationDependency:: + pre (Type&) + { + } + + void ImplementationDependency:: + pre (Type const&) + { + } + + void ImplementationDependency:: + requiredType (Type& o) + { + dispatch (o.requiredType ()); + } + + void ImplementationDependency:: + requiredType (Type const& o) + { + dispatch (o.requiredType ()); + } + + void ImplementationDependency:: + post (Type&) + { + } + + void ImplementationDependency:: + post (Type const&) + { + } + + // Capability + // + // + + void Capability:: + traverse (Type& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Capability:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Capability:: + pre (Type&) + { + } + + void Capability:: + pre (Type const&) + { + } + + void Capability:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Capability:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Capability:: + resourceType (Type& o) + { + // VC6 anathema strikes again + // + Capability::Type::resourceType_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Capability:: + resourceType (Type const& o) + { + // VC6 anathema strikes again + // + Capability::Type::resourceType_const_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Capability:: + resourceType_pre (Type&) + { + } + + void Capability:: + resourceType_pre (Type const&) + { + } + + void Capability:: + resourceType_next (Type&) + { + } + + void Capability:: + resourceType_next (Type const&) + { + } + + void Capability:: + resourceType_post (Type&) + { + } + + void Capability:: + resourceType_post (Type const&) + { + } + + void Capability:: + property (Type& o) + { + // VC6 anathema strikes again + // + Capability::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Capability:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Capability::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Capability:: + property_pre (Type&) + { + } + + void Capability:: + property_pre (Type const&) + { + } + + void Capability:: + property_next (Type&) + { + } + + void Capability:: + property_next (Type const&) + { + } + + void Capability:: + property_post (Type&) + { + } + + void Capability:: + property_post (Type const&) + { + } + + void Capability:: + property_none (Type&) + { + } + + void Capability:: + property_none (Type const&) + { + } + + void Capability:: + post (Type&) + { + } + + void Capability:: + post (Type const&) + { + } + + // ImplementationRequirement + // + // + + void ImplementationRequirement:: + traverse (Type& o) + { + pre (o); + if (o.resourceUsage_p ()) resourceUsage (o); + else resourceUsage_none (o); + if (o.resourcePort_p ()) resourcePort (o); + else resourcePort_none (o); + if (o.componentPort_p ()) componentPort (o); + else componentPort_none (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void ImplementationRequirement:: + traverse (Type const& o) + { + pre (o); + if (o.resourceUsage_p ()) resourceUsage (o); + else resourceUsage_none (o); + if (o.resourcePort_p ()) resourcePort (o); + else resourcePort_none (o); + if (o.componentPort_p ()) componentPort (o); + else componentPort_none (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void ImplementationRequirement:: + pre (Type&) + { + } + + void ImplementationRequirement:: + pre (Type const&) + { + } + + void ImplementationRequirement:: + resourceUsage (Type& o) + { + dispatch (o.resourceUsage ()); + } + + void ImplementationRequirement:: + resourceUsage (Type const& o) + { + dispatch (o.resourceUsage ()); + } + + void ImplementationRequirement:: + resourceUsage_none (Type&) + { + } + + void ImplementationRequirement:: + resourceUsage_none (Type const&) + { + } + + void ImplementationRequirement:: + resourcePort (Type& o) + { + dispatch (o.resourcePort ()); + } + + void ImplementationRequirement:: + resourcePort (Type const& o) + { + dispatch (o.resourcePort ()); + } + + void ImplementationRequirement:: + resourcePort_none (Type&) + { + } + + void ImplementationRequirement:: + resourcePort_none (Type const&) + { + } + + void ImplementationRequirement:: + componentPort (Type& o) + { + dispatch (o.componentPort ()); + } + + void ImplementationRequirement:: + componentPort (Type const& o) + { + dispatch (o.componentPort ()); + } + + void ImplementationRequirement:: + componentPort_none (Type&) + { + } + + void ImplementationRequirement:: + componentPort_none (Type const&) + { + } + + void ImplementationRequirement:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void ImplementationRequirement:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void ImplementationRequirement:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ImplementationRequirement:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ImplementationRequirement:: + property (Type& o) + { + // VC6 anathema strikes again + // + ImplementationRequirement::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ImplementationRequirement:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ImplementationRequirement::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ImplementationRequirement:: + property_pre (Type&) + { + } + + void ImplementationRequirement:: + property_pre (Type const&) + { + } + + void ImplementationRequirement:: + property_next (Type&) + { + } + + void ImplementationRequirement:: + property_next (Type const&) + { + } + + void ImplementationRequirement:: + property_post (Type&) + { + } + + void ImplementationRequirement:: + property_post (Type const&) + { + } + + void ImplementationRequirement:: + property_none (Type&) + { + } + + void ImplementationRequirement:: + property_none (Type const&) + { + } + + void ImplementationRequirement:: + post (Type&) + { + } + + void ImplementationRequirement:: + post (Type const&) + { + } + + // ComponentPackageReference + // + // + + void ComponentPackageReference:: + traverse (Type& o) + { + pre (o); + if (o.requiredUUID_p ()) requiredUUID (o); + else requiredUUID_none (o); + if (o.requiredName_p ()) requiredName (o); + else requiredName_none (o); + requiredType (o); + post (o); + } + + void ComponentPackageReference:: + traverse (Type const& o) + { + pre (o); + if (o.requiredUUID_p ()) requiredUUID (o); + else requiredUUID_none (o); + if (o.requiredName_p ()) requiredName (o); + else requiredName_none (o); + requiredType (o); + post (o); + } + + void ComponentPackageReference:: + pre (Type&) + { + } + + void ComponentPackageReference:: + pre (Type const&) + { + } + + void ComponentPackageReference:: + requiredUUID (Type& o) + { + dispatch (o.requiredUUID ()); + } + + void ComponentPackageReference:: + requiredUUID (Type const& o) + { + dispatch (o.requiredUUID ()); + } + + void ComponentPackageReference:: + requiredUUID_none (Type&) + { + } + + void ComponentPackageReference:: + requiredUUID_none (Type const&) + { + } + + void ComponentPackageReference:: + requiredName (Type& o) + { + dispatch (o.requiredName ()); + } + + void ComponentPackageReference:: + requiredName (Type const& o) + { + dispatch (o.requiredName ()); + } + + void ComponentPackageReference:: + requiredName_none (Type&) + { + } + + void ComponentPackageReference:: + requiredName_none (Type const&) + { + } + + void ComponentPackageReference:: + requiredType (Type& o) + { + dispatch (o.requiredType ()); + } + + void ComponentPackageReference:: + requiredType (Type const& o) + { + dispatch (o.requiredType ()); + } + + void ComponentPackageReference:: + post (Type&) + { + } + + void ComponentPackageReference:: + post (Type const&) + { + } + + // SubcomponentPortEndpoint + // + // + + void SubcomponentPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + instance (o); + post (o); + } + + void SubcomponentPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + instance (o); + post (o); + } + + void SubcomponentPortEndpoint:: + pre (Type&) + { + } + + void SubcomponentPortEndpoint:: + pre (Type const&) + { + } + + void SubcomponentPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void SubcomponentPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void SubcomponentPortEndpoint:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPortEndpoint:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPortEndpoint:: + post (Type&) + { + } + + void SubcomponentPortEndpoint:: + post (Type const&) + { + } + + // AssemblyConnectionDescription + // + // + + void AssemblyConnectionDescription:: + traverse (Type& o) + { + pre (o); + name (o); + deployRequirement (o); + internalEndpoint (o); + externalEndpoint (o); + externalReference (o); + post (o); + } + + void AssemblyConnectionDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + deployRequirement (o); + internalEndpoint (o); + externalEndpoint (o); + externalReference (o); + post (o); + } + + void AssemblyConnectionDescription:: + pre (Type&) + { + } + + void AssemblyConnectionDescription:: + pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void AssemblyConnectionDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void AssemblyConnectionDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void AssemblyConnectionDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_none (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::internalEndpoint_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::internalEndpoint_const_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_none (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalEndpoint_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalEndpoint_const_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_none (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalReference_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void AssemblyConnectionDescription:: + externalReference (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalReference_const_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_next (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_post (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_none (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + post (Type&) + { + } + + void AssemblyConnectionDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // TCKind + // + // + + TCKind:: + TCKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + TCKind:: + TCKind () + { + } + + void TCKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::TCKind::tk_null) s = "tk_null"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_void) s = "tk_void"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_short) s = "tk_short"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_long) s = "tk_long"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ushort) s = "tk_ushort"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulong) s = "tk_ulong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_float) s = "tk_float"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_double) s = "tk_double"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_boolean) s = "tk_boolean"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_char) s = "tk_char"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_octet) s = "tk_octet"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_any) s = "tk_any"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_TypeCode) s = "tk_TypeCode"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_Principal) s = "tk_Principal"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_objref) s = "tk_objref"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_struct) s = "tk_struct"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_union) s = "tk_union"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_enum) s = "tk_enum"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_string) s = "tk_string"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_sequence) s = "tk_sequence"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_array) s = "tk_array"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_alias) s = "tk_alias"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_except) s = "tk_except"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longlong) s = "tk_longlong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulonglong) s = "tk_ulonglong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longdouble) s = "tk_longdouble"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wchar) s = "tk_wchar"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wstring) s = "tk_wstring"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wfixed) s = "tk_wfixed"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value) s = "tk_value"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value_box) s = "tk_value_box"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_native) s = "tk_native"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_abstract_interface) s = "tk_abstract_interface"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_local_interface) s = "tk_local_interface"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_component) s = "tk_component"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_home) s = "tk_home"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_event) s = "tk_event"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // DataType + // + // + + DataType:: + DataType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + DataType:: + DataType () + { + } + + void DataType:: + traverse (Type const& o) + { + Traversal::DataType::traverse (o); + } + + void DataType:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::DataType::kind (o); + pop_ (); + } + + void DataType:: + enum_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("enum", top_ ())); + Traversal::DataType::enum_ (o); + pop_ (); + } + + void DataType:: + struct_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("struct", top_ ())); + Traversal::DataType::struct_ (o); + pop_ (); + } + + void DataType:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::DataType::value (o); + pop_ (); + } + + void DataType:: + sequence (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("sequence", top_ ())); + Traversal::DataType::sequence (o); + pop_ (); + } + + void DataType:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::DataType::id (o); + attr_ (0); + } + + // DataValue + // + // + + DataValue:: + DataValue (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + DataValue:: + DataValue () + { + } + + void DataValue:: + traverse (Type const& o) + { + Traversal::DataValue::traverse (o); + } + + void DataValue:: + short_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("short", top_ ())); + } + + void DataValue:: + short_next (Type const& o) + { + short_post (o); + short_pre (o); + } + + void DataValue:: + short_post (Type const&) + { + pop_ (); + } + + void DataValue:: + long_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("long", top_ ())); + } + + void DataValue:: + long_next (Type const& o) + { + long_post (o); + long_pre (o); + } + + void DataValue:: + long_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ushort_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ushort", top_ ())); + } + + void DataValue:: + ushort_next (Type const& o) + { + ushort_post (o); + ushort_pre (o); + } + + void DataValue:: + ushort_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ulong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ulong", top_ ())); + } + + void DataValue:: + ulong_next (Type const& o) + { + ulong_post (o); + ulong_pre (o); + } + + void DataValue:: + ulong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + float_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("float", top_ ())); + } + + void DataValue:: + float_next (Type const& o) + { + float_post (o); + float_pre (o); + } + + void DataValue:: + float_post (Type const&) + { + pop_ (); + } + + void DataValue:: + double_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("double", top_ ())); + } + + void DataValue:: + double_next (Type const& o) + { + double_post (o); + double_pre (o); + } + + void DataValue:: + double_post (Type const&) + { + pop_ (); + } + + void DataValue:: + boolean_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("boolean", top_ ())); + } + + void DataValue:: + boolean_next (Type const& o) + { + boolean_post (o); + boolean_pre (o); + } + + void DataValue:: + boolean_post (Type const&) + { + pop_ (); + } + + void DataValue:: + octet_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("octet", top_ ())); + } + + void DataValue:: + octet_next (Type const& o) + { + octet_post (o); + octet_pre (o); + } + + void DataValue:: + octet_post (Type const&) + { + pop_ (); + } + + void DataValue:: + enum_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("enum", top_ ())); + } + + void DataValue:: + enum_next (Type const& o) + { + enum_post (o); + enum_pre (o); + } + + void DataValue:: + enum_post (Type const&) + { + pop_ (); + } + + void DataValue:: + string_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("string", top_ ())); + } + + void DataValue:: + string_next (Type const& o) + { + string_post (o); + string_pre (o); + } + + void DataValue:: + string_post (Type const&) + { + pop_ (); + } + + void DataValue:: + longlong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("longlong", top_ ())); + } + + void DataValue:: + longlong_next (Type const& o) + { + longlong_post (o); + longlong_pre (o); + } + + void DataValue:: + longlong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ulonglong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ulonglong", top_ ())); + } + + void DataValue:: + ulonglong_next (Type const& o) + { + ulonglong_post (o); + ulonglong_pre (o); + } + + void DataValue:: + ulonglong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + longdouble_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("longdouble", top_ ())); + } + + void DataValue:: + longdouble_next (Type const& o) + { + longdouble_post (o); + longdouble_pre (o); + } + + void DataValue:: + longdouble_post (Type const&) + { + pop_ (); + } + + void DataValue:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void DataValue:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void DataValue:: + member_post (Type const&) + { + pop_ (); + } + + // EnumType + // + // + + EnumType:: + EnumType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + EnumType:: + EnumType () + { + } + + void EnumType:: + traverse (Type const& o) + { + Traversal::EnumType::traverse (o); + } + + void EnumType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::EnumType::name (o); + pop_ (); + } + + void EnumType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::EnumType::typeId (o); + pop_ (); + } + + void EnumType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void EnumType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void EnumType:: + member_post (Type const&) + { + pop_ (); + } + + // StructType + // + // + + StructType:: + StructType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + StructType:: + StructType () + { + } + + void StructType:: + traverse (Type const& o) + { + Traversal::StructType::traverse (o); + } + + void StructType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::StructType::name (o); + pop_ (); + } + + void StructType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::StructType::typeId (o); + pop_ (); + } + + void StructType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void StructType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void StructType:: + member_post (Type const&) + { + pop_ (); + } + + // StructMemberType + // + // + + StructMemberType:: + StructMemberType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + StructMemberType:: + StructMemberType () + { + } + + void StructMemberType:: + traverse (Type const& o) + { + Traversal::StructMemberType::traverse (o); + } + + void StructMemberType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::StructMemberType::name (o); + pop_ (); + } + + void StructMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::StructMemberType::type (o); + pop_ (); + } + + // ValueType + // + // + + ValueType:: + ValueType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ValueType:: + ValueType () + { + } + + void ValueType:: + traverse (Type const& o) + { + Traversal::ValueType::traverse (o); + } + + void ValueType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ValueType::name (o); + pop_ (); + } + + void ValueType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::ValueType::typeId (o); + pop_ (); + } + + void ValueType:: + modifier (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("modifier", top_ ())); + Traversal::ValueType::modifier (o); + pop_ (); + } + + void ValueType:: + baseType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("baseType", top_ ())); + Traversal::ValueType::baseType (o); + pop_ (); + } + + void ValueType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void ValueType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void ValueType:: + member_post (Type const&) + { + pop_ (); + } + + // ValueMemberType + // + // + + ValueMemberType:: + ValueMemberType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ValueMemberType:: + ValueMemberType () + { + } + + void ValueMemberType:: + traverse (Type const& o) + { + Traversal::ValueMemberType::traverse (o); + } + + void ValueMemberType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ValueMemberType::name (o); + pop_ (); + } + + void ValueMemberType:: + visibility (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("visibility", top_ ())); + Traversal::ValueMemberType::visibility (o); + pop_ (); + } + + void ValueMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::ValueMemberType::type (o); + pop_ (); + } + + // NamedValue + // + // + + NamedValue:: + NamedValue (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + NamedValue:: + NamedValue () + { + } + + void NamedValue:: + traverse (Type const& o) + { + Traversal::NamedValue::traverse (o); + } + + void NamedValue:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::NamedValue::name (o); + pop_ (); + } + + void NamedValue:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::NamedValue::value (o); + pop_ (); + } + + // SequenceType + // + // + + SequenceType:: + SequenceType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SequenceType:: + SequenceType () + { + } + + void SequenceType:: + traverse (Type const& o) + { + Traversal::SequenceType::traverse (o); + } + + void SequenceType:: + bound (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("bound", top_ ())); + Traversal::SequenceType::bound (o); + pop_ (); + } + + void SequenceType:: + elementType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("elementType", top_ ())); + Traversal::SequenceType::elementType (o); + pop_ (); + } + + // Any + // + // + + Any:: + Any (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Any:: + Any () + { + } + + void Any:: + traverse (Type const& o) + { + Traversal::Any::traverse (o); + } + + void Any:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::Any::type (o); + pop_ (); + } + + void Any:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::Any::value (o); + pop_ (); + } + + // Property + // + // + + Property:: + Property (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Property:: + Property () + { + } + + void Property:: + traverse (Type const& o) + { + Traversal::Property::traverse (o); + } + + void Property:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Property::name (o); + pop_ (); + } + + void Property:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::Property::value (o); + pop_ (); + } + + // SatisfierPropertyKind + // + // + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SatisfierPropertyKind:: + SatisfierPropertyKind () + { + } + + void SatisfierPropertyKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Quantity) s = "Quantity"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Capacity) s = "Capacity"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Minimum) s = "Minimum"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Maximum) s = "Maximum"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Attribute) s = "Attribute"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Selection) s = "Selection"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // SatisfierProperty + // + // + + SatisfierProperty:: + SatisfierProperty (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SatisfierProperty:: + SatisfierProperty () + { + } + + void SatisfierProperty:: + traverse (Type const& o) + { + Traversal::SatisfierProperty::traverse (o); + } + + void SatisfierProperty:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::SatisfierProperty::name (o); + pop_ (); + } + + void SatisfierProperty:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::SatisfierProperty::kind (o); + pop_ (); + } + + void SatisfierProperty:: + dynamic (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("dynamic", top_ ())); + Traversal::SatisfierProperty::dynamic (o); + pop_ (); + } + + void SatisfierProperty:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::SatisfierProperty::value (o); + pop_ (); + } + + // Resource + // + // + + Resource:: + Resource (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Resource:: + Resource () + { + } + + void Resource:: + traverse (Type const& o) + { + Traversal::Resource::traverse (o); + } + + void Resource:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Resource::name (o); + pop_ (); + } + + void Resource:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + } + + void Resource:: + resourceType_next (Type const& o) + { + resourceType_post (o); + resourceType_pre (o); + } + + void Resource:: + resourceType_post (Type const&) + { + pop_ (); + } + + void Resource:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Resource:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Resource:: + property_post (Type const&) + { + pop_ (); + } + + // Requirement + // + // + + Requirement:: + Requirement (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Requirement:: + Requirement () + { + } + + void Requirement:: + traverse (Type const& o) + { + Traversal::Requirement::traverse (o); + } + + void Requirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + Traversal::Requirement::resourceType (o); + pop_ (); + } + + void Requirement:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Requirement::name (o); + pop_ (); + } + + void Requirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Requirement:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Requirement:: + property_post (Type const&) + { + pop_ (); + } + + // ResourceDeploymentDescription + // + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ResourceDeploymentDescription:: + ResourceDeploymentDescription () + { + } + + void ResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ResourceDeploymentDescription::traverse (o); + } + + void ResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::ResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::ResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // ArtifactDeploymentDescription + // + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription () + { + } + + void ArtifactDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ArtifactDeploymentDescription::traverse (o); + } + + void ArtifactDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ArtifactDeploymentDescription::name (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + } + + void ArtifactDeploymentDescription:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void ArtifactDeploymentDescription:: + source_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::ArtifactDeploymentDescription::node (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("location", top_ ())); + } + + void ArtifactDeploymentDescription:: + location_next (Type const& o) + { + location_post (o); + location_pre (o); + } + + void ArtifactDeploymentDescription:: + location_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("execParameter", top_ ())); + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type const& o) + { + execParameter_post (o); + execParameter_pre (o); + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ArtifactDeploymentDescription::id (o); + attr_ (0); + } + + // MonolithicDeploymentDescription + // + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription () + { + } + + void MonolithicDeploymentDescription:: + traverse (Type const& o) + { + Traversal::MonolithicDeploymentDescription::traverse (o); + } + + void MonolithicDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::MonolithicDeploymentDescription::name (o); + pop_ (); + } + + void MonolithicDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + } + + void MonolithicDeploymentDescription:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void MonolithicDeploymentDescription:: + source_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("artifact", top_ ())); + } + + void MonolithicDeploymentDescription:: + artifact_next (Type const& o) + { + artifact_post (o); + artifact_pre (o); + } + + void MonolithicDeploymentDescription:: + artifact_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("execParameter", top_ ())); + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type const& o) + { + execParameter_post (o); + execParameter_pre (o); + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::MonolithicDeploymentDescription::id (o); + attr_ (0); + } + + // ResourceUsageKind + // + // + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ResourceUsageKind:: + ResourceUsageKind () + { + } + + void ResourceUsageKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::ResourceUsageKind::None) s = "None"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::InstanceUsesResource) s = "InstanceUsesResource"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesInstance) s = "ResourceUsesInstance"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::PortUsesResource) s = "PortUsesResource"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesPort) s = "ResourceUsesPort"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // InstanceResourceDeploymentDescription + // + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription () + { + } + + void InstanceResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::InstanceResourceDeploymentDescription::traverse (o); + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceUsage", top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceUsage (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::InstanceResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void InstanceResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void InstanceResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // InstanceDeploymentDescription + // + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + InstanceDeploymentDescription:: + InstanceDeploymentDescription () + { + } + + void InstanceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::InstanceDeploymentDescription::traverse (o); + } + + void InstanceDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::InstanceDeploymentDescription::name (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::InstanceDeploymentDescription::node (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + Traversal::InstanceDeploymentDescription::source (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + implementation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("implementation", top_ ())); + Traversal::InstanceDeploymentDescription::implementation (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("configProperty", top_ ())); + } + + void InstanceDeploymentDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void InstanceDeploymentDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedSharedResource", top_ ())); + Traversal::InstanceDeploymentDescription::deployedSharedResource (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::InstanceDeploymentDescription::id (o); + attr_ (0); + } + + // CCMComponentPortKind + // + // + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + CCMComponentPortKind:: + CCMComponentPortKind () + { + } + + void CCMComponentPortKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::Facet) s = "Facet"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::SimplexReceptacle) s = "SimplexReceptacle"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::MultiplexReceptacle) s = "MultiplexReceptacle"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventEmitter) s = "EventEmitter"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventPublisher) s = "EventPublisher"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventConsumer) s = "EventConsumer"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // ComponentPortDescription + // + // + + ComponentPortDescription:: + ComponentPortDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPortDescription:: + ComponentPortDescription () + { + } + + void ComponentPortDescription:: + traverse (Type const& o) + { + Traversal::ComponentPortDescription::traverse (o); + } + + void ComponentPortDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ComponentPortDescription::name (o); + pop_ (); + } + + void ComponentPortDescription:: + specificType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("specificType", top_ ())); + Traversal::ComponentPortDescription::specificType (o); + pop_ (); + } + + void ComponentPortDescription:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("supportedType", top_ ())); + } + + void ComponentPortDescription:: + supportedType_next (Type const& o) + { + supportedType_post (o); + supportedType_pre (o); + } + + void ComponentPortDescription:: + supportedType_post (Type const&) + { + pop_ (); + } + + void ComponentPortDescription:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("provider", top_ ())); + Traversal::ComponentPortDescription::provider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveProvider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("exclusiveProvider", top_ ())); + Traversal::ComponentPortDescription::exclusiveProvider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveUser (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("exclusiveUser", top_ ())); + Traversal::ComponentPortDescription::exclusiveUser (o); + pop_ (); + } + + void ComponentPortDescription:: + optional (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("optional", top_ ())); + Traversal::ComponentPortDescription::optional (o); + pop_ (); + } + + void ComponentPortDescription:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::ComponentPortDescription::kind (o); + pop_ (); + } + + // ComponentPropertyDescription + // + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPropertyDescription:: + ComponentPropertyDescription () + { + } + + void ComponentPropertyDescription:: + traverse (Type const& o) + { + Traversal::ComponentPropertyDescription::traverse (o); + } + + void ComponentPropertyDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ComponentPropertyDescription::name (o); + pop_ (); + } + + void ComponentPropertyDescription:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::ComponentPropertyDescription::type (o); + pop_ (); + } + + // ComponentExternalPortEndpoint + // + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint () + { + } + + void ComponentExternalPortEndpoint:: + traverse (Type const& o) + { + Traversal::ComponentExternalPortEndpoint::traverse (o); + } + + void ComponentExternalPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::ComponentExternalPortEndpoint::portName (o); + pop_ (); + } + + // PlanSubcomponentPortEndpoint + // + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint () + { + } + + void PlanSubcomponentPortEndpoint:: + traverse (Type const& o) + { + Traversal::PlanSubcomponentPortEndpoint::traverse (o); + } + + void PlanSubcomponentPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("provider", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::provider (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::kind (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("instance", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::instance (o); + pop_ (); + } + + // ExternalReferenceEndpoint + // + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint () + { + } + + void ExternalReferenceEndpoint:: + traverse (Type const& o) + { + Traversal::ExternalReferenceEndpoint::traverse (o); + } + + void ExternalReferenceEndpoint:: + location (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("location", top_ ())); + Traversal::ExternalReferenceEndpoint::location (o); + pop_ (); + } + + // ConnectionResourceDeploymentDescription + // + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription () + { + } + + void ConnectionResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ConnectionResourceDeploymentDescription::traverse (o); + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("targetName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::targetName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // PlanConnectionDescription + // + // + + PlanConnectionDescription:: + PlanConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanConnectionDescription:: + PlanConnectionDescription () + { + } + + void PlanConnectionDescription:: + traverse (Type const& o) + { + Traversal::PlanConnectionDescription::traverse (o); + } + + void PlanConnectionDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::PlanConnectionDescription::name (o); + pop_ (); + } + + void PlanConnectionDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + Traversal::PlanConnectionDescription::source (o); + pop_ (); + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void PlanConnectionDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void PlanConnectionDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalEndpoint", top_ ())); + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type const& o) + { + externalEndpoint_post (o); + externalEndpoint_pre (o); + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("internalEndpoint", top_ ())); + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type const& o) + { + internalEndpoint_post (o); + internalEndpoint_pre (o); + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + externalReference_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalReference", top_ ())); + } + + void PlanConnectionDescription:: + externalReference_next (Type const& o) + { + externalReference_post (o); + externalReference_pre (o); + } + + void PlanConnectionDescription:: + externalReference_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void PlanConnectionDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void PlanConnectionDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + // ImplementationDependency + // + // + + ImplementationDependency:: + ImplementationDependency (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ImplementationDependency:: + ImplementationDependency () + { + } + + void ImplementationDependency:: + traverse (Type const& o) + { + Traversal::ImplementationDependency::traverse (o); + } + + void ImplementationDependency:: + requiredType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredType", top_ ())); + Traversal::ImplementationDependency::requiredType (o); + pop_ (); + } + + // Capability + // + // + + Capability:: + Capability (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Capability:: + Capability () + { + } + + void Capability:: + traverse (Type const& o) + { + Traversal::Capability::traverse (o); + } + + void Capability:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Capability::name (o); + pop_ (); + } + + void Capability:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + } + + void Capability:: + resourceType_next (Type const& o) + { + resourceType_post (o); + resourceType_pre (o); + } + + void Capability:: + resourceType_post (Type const&) + { + pop_ (); + } + + void Capability:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Capability:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Capability:: + property_post (Type const&) + { + pop_ (); + } + + // ImplementationRequirement + // + // + + ImplementationRequirement:: + ImplementationRequirement (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ImplementationRequirement:: + ImplementationRequirement () + { + } + + void ImplementationRequirement:: + traverse (Type const& o) + { + Traversal::ImplementationRequirement::traverse (o); + } + + void ImplementationRequirement:: + resourceUsage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceUsage", top_ ())); + Traversal::ImplementationRequirement::resourceUsage (o); + pop_ (); + } + + void ImplementationRequirement:: + resourcePort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourcePort", top_ ())); + Traversal::ImplementationRequirement::resourcePort (o); + pop_ (); + } + + void ImplementationRequirement:: + componentPort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("componentPort", top_ ())); + Traversal::ImplementationRequirement::componentPort (o); + pop_ (); + } + + void ImplementationRequirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + Traversal::ImplementationRequirement::resourceType (o); + pop_ (); + } + + void ImplementationRequirement:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ImplementationRequirement::name (o); + pop_ (); + } + + void ImplementationRequirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ImplementationRequirement:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ImplementationRequirement:: + property_post (Type const&) + { + pop_ (); + } + + // ComponentPackageReference + // + // + + ComponentPackageReference:: + ComponentPackageReference (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPackageReference:: + ComponentPackageReference () + { + } + + void ComponentPackageReference:: + traverse (Type const& o) + { + Traversal::ComponentPackageReference::traverse (o); + } + + void ComponentPackageReference:: + requiredUUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredUUID", top_ ())); + Traversal::ComponentPackageReference::requiredUUID (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredName", top_ ())); + Traversal::ComponentPackageReference::requiredName (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredType", top_ ())); + Traversal::ComponentPackageReference::requiredType (o); + pop_ (); + } + + // SubcomponentPortEndpoint + // + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint () + { + } + + void SubcomponentPortEndpoint:: + traverse (Type const& o) + { + Traversal::SubcomponentPortEndpoint::traverse (o); + } + + void SubcomponentPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::SubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void SubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("instance", top_ ())); + Traversal::SubcomponentPortEndpoint::instance (o); + pop_ (); + } + + // AssemblyConnectionDescription + // + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + AssemblyConnectionDescription:: + AssemblyConnectionDescription () + { + } + + void AssemblyConnectionDescription:: + traverse (Type const& o) + { + Traversal::AssemblyConnectionDescription::traverse (o); + } + + void AssemblyConnectionDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::AssemblyConnectionDescription::name (o); + pop_ (); + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("internalEndpoint", top_ ())); + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type const& o) + { + internalEndpoint_post (o); + internalEndpoint_pre (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalEndpoint", top_ ())); + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type const& o) + { + externalEndpoint_post (o); + externalEndpoint_pre (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalReference", top_ ())); + } + + void AssemblyConnectionDescription:: + externalReference_next (Type const& o) + { + externalReference_post (o); + externalReference_pre (o); + } + + void AssemblyConnectionDescription:: + externalReference_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + |