diff options
Diffstat (limited to 'modules/CIAO/tools')
220 files changed, 85755 insertions, 0 deletions
diff --git a/modules/CIAO/tools/Config_Handlers/ADD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/ADD_Handler.cpp new file mode 100644 index 00000000000..e4106b4b70f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ADD_Handler.cpp @@ -0,0 +1,177 @@ +// $Id$ +#include "ADD_Handler.h" +#include "cdp.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Property_Handler.h" +#include "ace/UUID.h" + +ACE_RCSID (DAnCE, + ADD_Handler, + "$Id$") + +namespace CIAO +{ + namespace Config_Handlers + { + IDREF_Base<CORBA::ULong> ADD_Handler::IDREF; + + void + ADD_Handler::artifact_deployment_descrs (const deploymentPlan &src, + ::Deployment::ArtifactDeploymentDescriptions &dest) + { + CIAO_TRACE("ADD_Handler::atrifact_deployment_descrs"); + deploymentPlan::artifact_const_iterator aci_e = + src.end_artifact (); + dest.length (src.count_artifact ()); + CORBA::ULong pos = 0; + for (deploymentPlan::artifact_const_iterator aci_b = + src.begin_artifact (); + aci_e != aci_b; + ++aci_b) + { + ADD_Handler::artifact_deployment_descr (*(*aci_b), + dest[pos], + pos); + pos++; + } + } + + void + ADD_Handler::artifact_deployment_descr ( + const ArtifactDeploymentDescription &src, + Deployment::ArtifactDeploymentDescription &dest, + CORBA::ULong pos) + { + CIAO_TRACE("ADD_Handler::atrifact_deployment_descr"); + dest.name = ACE_TEXT_ALWAYS_CHAR ( src.name ().c_str ()); + + + dest.node = ACE_TEXT_ALWAYS_CHAR ( src.node ().c_str ()); + + ArtifactDeploymentDescription::location_const_iterator end = + src.end_location (); + + dest.location.length (src.count_location ()); + CORBA::ULong len = 0; + for (ArtifactDeploymentDescription::location_const_iterator + start = src.begin_location (); + start != end; + ++start) + { + dest.location[len++] = ACE_TEXT_ALWAYS_CHAR ( (*start)->c_str ()); + } + + ArtifactDeploymentDescription::source_const_iterator sce = + src.end_source (); + len = 0; + dest.source.length (src.count_source ()); + for (ArtifactDeploymentDescription::source_const_iterator + scb = src.begin_source (); + scb != sce; + ++scb) + { + dest.source[len++] = ACE_TEXT_ALWAYS_CHAR ( (*scb)->c_str ()); + } + + // @@TODO: See this loop is repeated + ArtifactDeploymentDescription::execParameter_const_iterator adce = + src.end_execParameter (); + len = 0; + dest.execParameter.length (src.count_execParameter ()); + for (ArtifactDeploymentDescription::execParameter_const_iterator adcb = + src.begin_execParameter (); + adcb != adce; + ++adcb) + { + Property_Handler::handle_property (*(*adcb), + dest.execParameter[len++]); + } + + if (src.id_p ()) + { + ACE_TString cstr (src.id ().c_str ()); + + ADD_Handler::IDREF.bind_ref (cstr,pos); + } + else + { + ACE_ERROR ((LM_ERROR, + "(%P|%t) Warning: ADD %s has no idref.\n", + ACE_TEXT_ALWAYS_CHAR ( src.name ().c_str ()))); + } + +#if 0 + // @@ MAJO: Don't know how to handle this. + if (src.deployRequirement_p ()) + { + Req_Handler handler; + add.deployRequirement.length ( + add.deployRequirement.length () + 1); + handler.get_Requirement ( + add.deployRequirement[add.deployRequirement.length () - 1], + src.deployRequirement ()); + } + + if (src.deployedResource_p ()) + { + RDD_Handler handler; + add.deployedResource.length ( + add.deployedResource.length () + 1); + handler.get_ResourceDeploymentDescription ( + add.deployedResource[add.deployedResource.length () - 1], + src.deployedResource ()); + } +#endif /* 0 */ + } + + ArtifactDeploymentDescription + ADD_Handler::artifact_deployment_descr ( + const Deployment::ArtifactDeploymentDescription &src) + { + CIAO_TRACE("ADD_Handler::atrifact_deployment_descr - reverse"); + //Get the name and node and store them in the add + XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + XMLSchema::string< ACE_TCHAR > node (ACE_TEXT_CHAR_TO_TCHAR (src.node)); + + ArtifactDeploymentDescription add (name,node); + + //Get the location(s) and store it/them in the add + size_t total = src.location.length (); + for (size_t i = 0; i < total; ++i) + { + XMLSchema::string< ACE_TCHAR > curr (ACE_TEXT_CHAR_TO_TCHAR (src.location[i])); + //add.add_location (curr); + } + + //As above, for the source(s) + total = src.source.length (); + for (size_t j = 0; j < total; ++j) + { + XMLSchema::string< ACE_TCHAR > curr (ACE_TEXT_CHAR_TO_TCHAR (src.source[j])); + //add.add_source (curr); + } + + //As above for the execParameter(s) + total = src.execParameter.length (); + for (size_t k = 0; k < total; ++k) + { + //add.add_execParameter (Property_Handler::get_property (src.execParameter[k])); + } + + // Generate a UUID to use for the IDREF. + ACE_Utils::UUID uuid; + ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); + ACE_TString add_id (ACE_TEXT ("_")); + add_id += ACE_TEXT_CHAR_TO_TCHAR (uuid.to_string ()->c_str ()); + + XMLSchema::ID< ACE_TCHAR > xml_id (add_id.c_str ()); + + // Bind the ref and set it in the IDD + ADD_Handler::IDREF.bind_next_available (add_id); + + add.id (xml_id); + + return add; + } + } + } diff --git a/modules/CIAO/tools/Config_Handlers/ADD_Handler.h b/modules/CIAO/tools/Config_Handlers/ADD_Handler.h new file mode 100644 index 00000000000..063093a7038 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ADD_Handler.h @@ -0,0 +1,71 @@ +//============================================================== +/** + * @file ADD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_ADD_Handler_H +#define CIAO_CONFIG_HANDLERS_ADD_Handler_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include "tao/Basic_Types.h" +#include "IDREF_Base.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace Deployment +{ + struct ArtifactDeploymentDescription; + class ArtifactDeploymentDescriptions; +} + + +namespace CIAO +{ + + namespace Config_Handlers + { + class deploymentPlan; + class ArtifactDeploymentDescription; + + /* + * @class ADD_Handler + * + * @brief Handler class for <ArtifactDeploymentDescription> types. + * + * This class defines handler methods to map values from XSC + * ArtifactDeploymentDescription objects, parsed from the + * // @@ Jules, why Any type? + * descriptor files, to the corresponding CORBA IDL Any type. + */ + class Config_Handlers_Export ADD_Handler + { + public: + static void artifact_deployment_descrs (const deploymentPlan &src, + ::Deployment::ArtifactDeploymentDescriptions &dest); + + static ArtifactDeploymentDescription + artifact_deployment_descr (const Deployment::ArtifactDeploymentDescription &src); + + /// The IDREF Table associated with this class + static IDREF_Base<CORBA::ULong> IDREF; + + private: + static void artifact_deployment_descr ( + const ArtifactDeploymentDescription& desc, + ::Deployment::ArtifactDeploymentDescription &dest, + CORBA::ULong l = 0); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ADD_Handler_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Any_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Any_Handler.cpp new file mode 100644 index 00000000000..e1b2bc4d0ec --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Any_Handler.cpp @@ -0,0 +1,59 @@ +// $Id$ + +#include /**/ "ace/pre.h" + +#include "Any_Handler.h" +#include "DataType_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "tao/AnyTypeCode/Any.h" +#include "ciao/Logger/Log_Macros.h" +#include "DynAny_Handler/DynAny_Handler.h" + +#include "ace/Null_Mutex.h" + +namespace CIAO +{ + namespace Config_Handlers + { + + Any_Handler::Any_Handler (void) + { + } + + Any_Handler::~Any_Handler (void) + { + } + + void + Any_Handler::extract_into_any (const Any& desc, + CORBA::Any& toconfig) + { + CIAO_TRACE("Any_Handler::extract_into_any"); + try + { + DynamicAny::DynAny_var dyn = DYNANY_HANDLER->extract_into_dynany (desc.type (), + desc.value ()); + + toconfig = *dyn->to_any (); + + dyn->destroy (); + } + catch (Config_Error &ex) + { + throw ex; + } + catch (...) + { + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Caught error whilst parsing XML into Any\n")); + } + } + + Any Any_Handler::get_any (const ::CORBA::Any& src) + { + CIAO_TRACE("Any_Handler::extract_into_any - reverse"); + + return DYNANY_HANDLER->extract_from_dynany (src); + } + } +} +#include /**/ "ace/post.h" diff --git a/modules/CIAO/tools/Config_Handlers/Any_Handler.h b/modules/CIAO/tools/Config_Handlers/Any_Handler.h new file mode 100644 index 00000000000..03f99722034 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Any_Handler.h @@ -0,0 +1,62 @@ +//============================================================== +/** + * @file Any_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_ANY_HANDLER_H +#define CIAO_CONFIG_HANDLERS_ANY_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "Config_Handlers/Common.h" +#include "tao/Versioned_Namespace.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL +namespace CORBA +{ + class Any; +} +TAO_END_VERSIONED_NAMESPACE_DECL + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + + /* + * @class Any_Handler + * + * @brief Handler class for <ComponentInterfaceDescription> types. + * + * This class defines handler methods to map values from + * XSC Any objects, parsed from the descriptor files, to the + * corresponding CORBA IDL Any type. + * + */ + class Config_Handlers_Common_Export Any_Handler + { + public: + Any_Handler (void); + virtual ~Any_Handler (void); + + static void extract_into_any (const Any& desc, + ::CORBA::Any& toconfig); + + static Any get_any (const CORBA::Any &src); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ANY_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp b/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp new file mode 100644 index 00000000000..1e07c6cbfa2 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp @@ -0,0 +1,17580 @@ +/* $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 + { + // IdRef + // + + IdRef:: + IdRef () + : + regulator__ () + { + } + + IdRef:: + IdRef (IdRef const& s) + : ::XSCRT::Type (), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + idref_ (s.idref_.get () ? new ::XMLSchema::IDREF< ACE_TCHAR > (*s.idref_) : 0), + regulator__ () + { + if (href_.get ()) href_->container (this); + if (idref_.get ()) idref_->container (this); + } + + IdRef& IdRef:: + operator= (IdRef const& s) + { + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.idref_.get ()) idref (*(s.idref_)); + else idref_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (0); + + return *this; + } + + + // IdRef + // + bool IdRef:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& IdRef:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& IdRef:: + href () + { + return *href_; + } + + void IdRef:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + + // IdRef + // + bool IdRef:: + idref_p () const + { + return idref_.get () != 0; + } + + ::XMLSchema::IDREF< ACE_TCHAR > const& IdRef:: + idref () const + { + return *idref_; + } + + ::XMLSchema::IDREF< ACE_TCHAR >& IdRef:: + idref () + { + return *idref_; + } + + ::XSCRT::Type* IdRef:: + idref_ptr () + { + std::basic_string<ACE_TCHAR> temp (idref().id()); + return this->get_idref(temp.c_str()); + } + + + void IdRef:: + idref (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + if (idref_.get ()) + { + *idref_ = e; + } + + else + { + idref_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + idref_->container (this); + } + } + + + // 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 (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), + alias_ (s.alias_.get () ? new ::CIAO::Config_Handlers::AliasType (*s.alias_) : 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 (alias_.get ()) alias_->container (this); + if (id_.get ()) id_->container (this); + } + + DataType& DataType:: + operator= (DataType const& s) + { + kind (*s.kind_); + + if (s.enum__.get ()) + enum_ (*(s.enum__)); + else + enum__.reset (0); + + if (s.struct__.get ()) + struct_ (*(s.struct__)); + else + struct__.reset (0); + + if (s.value_.get ()) + value (*(s.value_)); + else + value_.reset (0); + + if (s.sequence_.get ()) + sequence (*(s.sequence_)); + else + sequence_.reset (0); + + if (s.alias_.get ()) + alias (*(s.alias_)); + else + alias_.reset (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:: + alias_p () const + { + return alias_.get () != 0; + } + + ::CIAO::Config_Handlers::AliasType const& DataType:: + alias () const + { + return *alias_; + } + + void DataType:: + alias (::CIAO::Config_Handlers::AliasType const& e) + { + if (alias_.get ()) + { + *alias_ = e; + } + + else + { + alias_ = ::std::auto_ptr< ::CIAO::Config_Handlers::AliasType > (new ::CIAO::Config_Handlers::AliasType (e)); + alias_->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 () + : + regulator__ () + { + } + + DataValue:: + DataValue (DataValue const& s) + : + ::XSCRT::Type (), + short__ (s.short__), + long__ (s.long__), + ushort_ (s.ushort_), + ulong_ (s.ulong_), + float__ (s.float__), + double__ (s.double__), + boolean_ (s.boolean_), + octet_ (s.octet_), + enum__ (s.enum__), + string_ (s.string_), + longlong_ (s.longlong_), + ulonglong_ (s.ulonglong_), + longdouble_ (s.longdouble_), + element_ (s.element_), + member_ (s.member_), + regulator__ () + { + } + + DataValue& DataValue:: + operator= (DataValue const& s) + { + short__ = s.short__; + + long__ = s.long__; + + ushort_ = s.ushort_; + + ulong_ = s.ulong_; + + float__ = s.float__; + + double__ = s.double__; + + boolean_ = s.boolean_; + + octet_ = s.octet_; + + enum__ = s.enum__; + + string_ = s.string_; + + longlong_ = s.longlong_; + + ulonglong_ = s.ulonglong_; + + longdouble_ = s.longdouble_; + + element_ = s.element_; + + member_ = s.member_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > const& e) + { + longdouble_.push_back (e); + } + + size_t DataValue:: + count_longdouble(void) const + { + return longdouble_.size (); + } + + // DataValue + // + DataValue::element_iterator DataValue:: + begin_element () + { + return element_.begin (); + } + + DataValue::element_iterator DataValue:: + end_element () + { + return element_.end (); + } + + DataValue::element_const_iterator DataValue:: + begin_element () const + { + return element_.begin (); + } + + DataValue::element_const_iterator DataValue:: + end_element () const + { + return element_.end (); + } + + void DataValue:: + add_element (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > const& e) + { + element_.push_back (e); + } + + size_t DataValue:: + count_element(void) const + { + return element_.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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > const& e) + { + member_.push_back (e); + } + + size_t DataValue:: + count_member(void) const + { + return member_.size (); + } + + + // AliasType + // + + AliasType:: + AliasType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::CIAO::Config_Handlers::DataType const& elementType__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + elementType_ (new ::CIAO::Config_Handlers::DataType (elementType__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + elementType_->container (this); + } + + AliasType:: + AliasType (AliasType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + elementType_ (new ::CIAO::Config_Handlers::DataType (*s.elementType_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + elementType_->container (this); + } + + AliasType& AliasType:: + operator= (AliasType const& s) + { + name (*s.name_); + + typeId (*s.typeId_); + + elementType (*s.elementType_); + + return *this; + } + + + // AliasType + // + ::XMLSchema::string< ACE_TCHAR > const& AliasType:: + name () const + { + return *name_; + } + + void AliasType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AliasType + // + ::XMLSchema::string< ACE_TCHAR > const& AliasType:: + typeId () const + { + return *typeId_; + } + + void AliasType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // AliasType + // + ::CIAO::Config_Handlers::DataType const& AliasType:: + elementType () const + { + return *elementType_; + } + + void AliasType:: + elementType (::CIAO::Config_Handlers::DataType const& e) + { + *elementType_ = e; + } + + + // EnumType + // + + EnumType:: + EnumType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > const& member__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + member_ (member__), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + EnumType:: + EnumType (EnumType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + member_ (s.member_), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + EnumType& EnumType:: + operator= (EnumType const& s) + { + name (*s.name_); + + typeId (*s.typeId_); + + member_ = s.member_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + StructType:: + StructType (StructType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + member_ (s.member_), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + StructType& StructType:: + operator= (StructType const& s) + { + name (*s.name_); + + typeId (*s.typeId_); + + member_ = s.member_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > 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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + StructMemberType:: + StructMemberType (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); + } + + StructMemberType& StructMemberType:: + operator= (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__) + : + 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 (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_)), + member_ (s.member_), + regulator__ () + { + name_->container (this); + typeId_->container (this); + modifier_->container (this); + baseType_->container (this); + } + + ValueType& ValueType:: + operator= (ValueType const& s) + { + name (*s.name_); + + typeId (*s.typeId_); + + modifier (*s.modifier_); + + baseType (*s.baseType_); + + member_ = s.member_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > 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__) + : + 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 (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); + } + + ValueMemberType& ValueMemberType:: + operator= (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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + NamedValue:: + NamedValue (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); + } + + NamedValue& NamedValue:: + operator= (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__) + : + elementType_ (new ::CIAO::Config_Handlers::DataType (elementType__)), + regulator__ () + { + elementType_->container (this); + } + + SequenceType:: + SequenceType (SequenceType const& s) + : + ::XSCRT::Type (), + bound_ (s.bound_.get () ? new ::XMLSchema::unsignedInt (*s.bound_) : 0), + elementType_ (new ::CIAO::Config_Handlers::DataType (*s.elementType_)), + regulator__ () + { + if (bound_.get ()) bound_->container (this); + elementType_->container (this); + } + + SequenceType& SequenceType:: + operator= (SequenceType const& s) + { + if (s.bound_.get ()) + bound (*(s.bound_)); + else + bound_.reset (0); + + elementType (*s.elementType_); + + return *this; + } + + + // SequenceType + // + bool SequenceType:: + bound_p () const + { + return bound_.get () != 0; + } + + ::XMLSchema::unsignedInt const& SequenceType:: + bound () const + { + return *bound_; + } + + void SequenceType:: + bound (::XMLSchema::unsignedInt const& e) + { + if (bound_.get ()) + { + *bound_ = e; + } + + else + { + bound_ = ::std::auto_ptr< ::XMLSchema::unsignedInt > (new ::XMLSchema::unsignedInt (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__) + : + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + type_->container (this); + value_->container (this); + } + + Any:: + Any (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); + } + + Any& Any:: + operator= (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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::Any (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + Property:: + Property (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); + } + + Property& Property:: + operator= (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__) + : + 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 (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); + } + + SatisfierProperty& SatisfierProperty:: + operator= (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__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > const& resourceType__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + resourceType_ (resourceType__), + regulator__ () + { + name_->container (this); + } + + Resource:: + Resource (Resource const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + resourceType_ (s.resourceType_), + property_ (s.property_), + regulator__ () + { + name_->container (this); + } + + Resource& Resource:: + operator= (Resource const& s) + { + name (*s.name_); + + resourceType_ = s.resourceType_; + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > const& e) + { + property_.push_back (e); + } + + size_t Resource:: + count_property(void) const + { + return property_.size (); + } + + + // Requirement + // + + Requirement:: + Requirement (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& resourceType__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + regulator__ () + { + name_->container (this); + resourceType_->container (this); + } + + Requirement:: + Requirement (Requirement const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + property_ (s.property_), + regulator__ () + { + name_->container (this); + resourceType_->container (this); + } + + Requirement& Requirement:: + operator= (Requirement const& s) + { + name (*s.name_); + + resourceType (*s.resourceType_); + + property_ = s.property_; + + return *this; + } + + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + name () const + { + return *name_; + } + + void Requirement:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + resourceType () const + { + return *resourceType_; + } + + void Requirement:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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__) + : + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + } + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (ResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + property_ (s.property_), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + } + + ResourceDeploymentDescription& ResourceDeploymentDescription:: + operator= (ResourceDeploymentDescription const& s) + { + requirementName (*s.requirementName_); + + resourceName (*s.resourceName_); + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + regulator__ () + { + name_->container (this); + node_->container (this); + } + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (ArtifactDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + source_ (s.source_), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + location_ (s.location_), + execParameter_ (s.execParameter_), + deployRequirement_ (s.deployRequirement_), + deployedResource_ (s.deployedResource_), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + node_->container (this); + if (id_.get ()) id_->container (this); + } + + ArtifactDeploymentDescription& ArtifactDeploymentDescription:: + operator= (ArtifactDeploymentDescription const& s) + { + name (*s.name_); + + source_ = s.source_; + + node (*s.node_); + + location_ = s.location_; + + execParameter_ = s.execParameter_; + + deployRequirement_ = s.deployRequirement_; + + deployedResource_ = s.deployedResource_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > 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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (MonolithicDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + source_ (s.source_), + artifact_ (s.artifact_), + execParameter_ (s.execParameter_), + deployRequirement_ (s.deployRequirement_), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + if (id_.get ()) id_->container (this); + } + + MonolithicDeploymentDescription& MonolithicDeploymentDescription:: + operator= (MonolithicDeploymentDescription const& s) + { + name (*s.name_); + + source_ = s.source_; + + artifact_ = s.artifact_; + + execParameter_ = s.execParameter_; + + deployRequirement_ = s.deployRequirement_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > 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__) + : + 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 (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_)), + property_ (s.property_), + regulator__ () + { + resourceUsage_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + InstanceResourceDeploymentDescription& InstanceResourceDeploymentDescription:: + operator= (InstanceResourceDeploymentDescription const& s) + { + resourceUsage (*s.resourceUsage_); + + requirementName (*s.requirementName_); + + resourceName (*s.resourceName_); + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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__, + ::CIAO::Config_Handlers::IdRef const& implementation__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + source_ (new ::XMLSchema::string< ACE_TCHAR > (source__)), + implementation_ (new ::CIAO::Config_Handlers::IdRef (implementation__)), + regulator__ () + { + name_->container (this); + node_->container (this); + source_->container (this); + implementation_->container (this); + } + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (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 ::CIAO::Config_Handlers::IdRef (*s.implementation_)), + configProperty_ (s.configProperty_), + deployedResource_ (s.deployedResource_), + 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); + if (deployedSharedResource_.get ()) deployedSharedResource_->container (this); + if (id_.get ()) id_->container (this); + } + + InstanceDeploymentDescription& InstanceDeploymentDescription:: + operator= (InstanceDeploymentDescription const& s) + { + name (*s.name_); + + node (*s.node_); + + source (*s.source_); + + implementation (*s.implementation_); + + configProperty_ = s.configProperty_; + + deployedResource_ = s.deployedResource_; + + if (s.deployedSharedResource_.get ()) + deployedSharedResource (*(s.deployedSharedResource_)); + else + deployedSharedResource_.reset (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 + // + ::CIAO::Config_Handlers::IdRef const& InstanceDeploymentDescription:: + implementation () const + { + return *implementation_; + } + + void InstanceDeploymentDescription:: + implementation (::CIAO::Config_Handlers::IdRef 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > 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__) + : + 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 (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), + supportedType_ (s.supportedType_), + 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_)), + templateParam_ (s.templateParam_), + regulator__ () + { + name_->container (this); + if (specificType_.get ()) specificType_->container (this); + provider_->container (this); + exclusiveProvider_->container (this); + exclusiveUser_->container (this); + optional_->container (this); + kind_->container (this); + } + + ComponentPortDescription& ComponentPortDescription:: + operator= (ComponentPortDescription const& s) + { + name (*s.name_); + + if (s.specificType_.get ()) + specificType (*(s.specificType_)); + else + specificType_.reset (0); + + supportedType_ = s.supportedType_; + + provider (*s.provider_); + + exclusiveProvider (*s.exclusiveProvider_); + + exclusiveUser (*s.exclusiveUser_); + + optional (*s.optional_); + + kind (*s.kind_); + + templateParam_ = s.templateParam_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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; + } + + // ComponentPortDescription + // + ComponentPortDescription::templateParam_iterator ComponentPortDescription:: + begin_templateParam () + { + return templateParam_.begin (); + } + + ComponentPortDescription::templateParam_iterator ComponentPortDescription:: + end_templateParam () + { + return templateParam_.end (); + } + + ComponentPortDescription::templateParam_const_iterator ComponentPortDescription:: + begin_templateParam () const + { + return templateParam_.begin (); + } + + ComponentPortDescription::templateParam_const_iterator ComponentPortDescription:: + end_templateParam () const + { + return templateParam_.end (); + } + + void ComponentPortDescription:: + add_templateParam (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + templateParam_.push_back (e); + } + + size_t ComponentPortDescription:: + count_templateParam(void) const + { + return templateParam_.size (); + } + + + // ComponentPropertyDescription + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ComponentPropertyDescription:: + ComponentPropertyDescription (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); + } + + ComponentPropertyDescription& ComponentPropertyDescription:: + operator= (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__) + : + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + regulator__ () + { + portName_->container (this); + } + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (ComponentExternalPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + regulator__ () + { + portName_->container (this); + } + + ComponentExternalPortEndpoint& ComponentExternalPortEndpoint:: + operator= (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__, + ::CIAO::Config_Handlers::IdRef const& instance__) + : + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (kind__)), + instance_ (new ::CIAO::Config_Handlers::IdRef (instance__)), + regulator__ () + { + portName_->container (this); + kind_->container (this); + instance_->container (this); + } + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (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 ::CIAO::Config_Handlers::IdRef (*s.instance_)), + regulator__ () + { + portName_->container (this); + if (provider_.get ()) provider_->container (this); + kind_->container (this); + instance_->container (this); + } + + PlanSubcomponentPortEndpoint& PlanSubcomponentPortEndpoint:: + operator= (PlanSubcomponentPortEndpoint const& s) + { + portName (*s.portName_); + + if (s.provider_.get ()) + provider (*(s.provider_)); + else + provider_.reset (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 + // + ::CIAO::Config_Handlers::IdRef const& PlanSubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void PlanSubcomponentPortEndpoint:: + instance (::CIAO::Config_Handlers::IdRef const& e) + { + *instance_ = e; + } + + + // ExternalReferenceEndpoint + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XMLSchema::string< ACE_TCHAR > const& location__, + ::XMLSchema::boolean const& provider__) + : + location_ (new ::XMLSchema::string< ACE_TCHAR > (location__)), + provider_ (new ::XMLSchema::boolean (provider__)), + regulator__ () + { + location_->container (this); + provider_->container (this); + } + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (ExternalReferenceEndpoint const& s) + : + ::XSCRT::Type (), + location_ (new ::XMLSchema::string< ACE_TCHAR > (*s.location_)), + provider_ (new ::XMLSchema::boolean (*s.provider_)), + portName_ (s.portName_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.portName_) : 0), + supportedType_ (s.supportedType_), + regulator__ () + { + location_->container (this); + provider_->container (this); + if (portName_.get ()) portName_->container (this); + } + + ExternalReferenceEndpoint& ExternalReferenceEndpoint:: + operator= (ExternalReferenceEndpoint const& s) + { + location (*s.location_); + + provider (*s.provider_); + + if (s.portName_.get ()) + portName (*(s.portName_)); + else + portName_.reset (0); + + supportedType_ = s.supportedType_; + + return *this; + } + + + // ExternalReferenceEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& ExternalReferenceEndpoint:: + location () const + { + return *location_; + } + + void ExternalReferenceEndpoint:: + location (::XMLSchema::string< ACE_TCHAR > const& e) + { + *location_ = e; + } + + // ExternalReferenceEndpoint + // + ::XMLSchema::boolean const& ExternalReferenceEndpoint:: + provider () const + { + return *provider_; + } + + void ExternalReferenceEndpoint:: + provider (::XMLSchema::boolean const& e) + { + *provider_ = e; + } + + // ExternalReferenceEndpoint + // + bool ExternalReferenceEndpoint:: + portName_p () const + { + return portName_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ExternalReferenceEndpoint:: + portName () const + { + return *portName_; + } + + void ExternalReferenceEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (portName_.get ()) + { + *portName_ = e; + } + + else + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + } + + // ExternalReferenceEndpoint + // + ExternalReferenceEndpoint::supportedType_iterator ExternalReferenceEndpoint:: + begin_supportedType () + { + return supportedType_.begin (); + } + + ExternalReferenceEndpoint::supportedType_iterator ExternalReferenceEndpoint:: + end_supportedType () + { + return supportedType_.end (); + } + + ExternalReferenceEndpoint::supportedType_const_iterator ExternalReferenceEndpoint:: + begin_supportedType () const + { + return supportedType_.begin (); + } + + ExternalReferenceEndpoint::supportedType_const_iterator ExternalReferenceEndpoint:: + end_supportedType () const + { + return supportedType_.end (); + } + + void ExternalReferenceEndpoint:: + add_supportedType (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + supportedType_.push_back (e); + } + + size_t ExternalReferenceEndpoint:: + count_supportedType(void) const + { + return supportedType_.size (); + } + + + // ConnectionResourceDeploymentDescription + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& targetName__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + 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 (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_)), + property_ (s.property_), + regulator__ () + { + targetName_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + ConnectionResourceDeploymentDescription& ConnectionResourceDeploymentDescription:: + operator= (ConnectionResourceDeploymentDescription const& s) + { + targetName (*s.targetName_); + + requirementName (*s.requirementName_); + + resourceName (*s.resourceName_); + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > 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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + PlanConnectionDescription:: + PlanConnectionDescription (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), + deployRequirement_ (s.deployRequirement_), + externalEndpoint_ (s.externalEndpoint_), + internalEndpoint_ (s.internalEndpoint_), + externalReference_ (s.externalReference_), + deployedResource_ (s.deployedResource_), + regulator__ () + { + name_->container (this); + if (source_.get ()) source_->container (this); + } + + PlanConnectionDescription& PlanConnectionDescription:: + operator= (PlanConnectionDescription const& s) + { + name (*s.name_); + + if (s.source_.get ()) + source (*(s.source_)); + else + source_.reset (0); + + deployRequirement_ = s.deployRequirement_; + + externalEndpoint_ = s.externalEndpoint_; + + internalEndpoint_ = s.internalEndpoint_; + + externalReference_ = s.externalReference_; + + deployedResource_ = s.deployedResource_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > 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__) + : + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ImplementationDependency:: + ImplementationDependency (ImplementationDependency const& s) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requiredType_)), + regulator__ () + { + requiredType_->container (this); + } + + ImplementationDependency& ImplementationDependency:: + operator= (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__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Capability:: + Capability (Capability const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + resourceType_ (s.resourceType_), + property_ (s.property_), + regulator__ () + { + name_->container (this); + } + + Capability& Capability:: + operator= (Capability const& s) + { + name (*s.name_); + + resourceType_ = s.resourceType_; + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > 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__) + : + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + } + + ImplementationRequirement:: + ImplementationRequirement (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_)), + property_ (s.property_), + 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); + } + + ImplementationRequirement& ImplementationRequirement:: + operator= (ImplementationRequirement const& s) + { + if (s.resourceUsage_.get ()) + resourceUsage (*(s.resourceUsage_)); + else + resourceUsage_.reset (0); + + if (s.resourcePort_.get ()) + resourcePort (*(s.resourcePort_)); + else + resourcePort_.reset (0); + + if (s.componentPort_.get ()) + componentPort (*(s.componentPort_)); + else + componentPort_.reset (0); + + resourceType (*s.resourceType_); + + name (*s.name_); + + property_ = s.property_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + property_.push_back (e); + } + + size_t ImplementationRequirement:: + count_property(void) const + { + return property_.size (); + } + + + // SubcomponentPortEndpoint + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::IdRef const& instance__) + : + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + instance_ (new ::CIAO::Config_Handlers::IdRef (instance__)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (SubcomponentPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + instance_ (new ::CIAO::Config_Handlers::IdRef (*s.instance_)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + SubcomponentPortEndpoint& SubcomponentPortEndpoint:: + operator= (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 + // + ::CIAO::Config_Handlers::IdRef const& SubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void SubcomponentPortEndpoint:: + instance (::CIAO::Config_Handlers::IdRef const& e) + { + *instance_ = e; + } + + + // AssemblyConnectionDescription + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (AssemblyConnectionDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + deployRequirement_ (s.deployRequirement_), + internalEndpoint_ (s.internalEndpoint_), + externalEndpoint_ (s.externalEndpoint_), + externalReference_ (s.externalReference_), + regulator__ () + { + name_->container (this); + } + + AssemblyConnectionDescription& AssemblyConnectionDescription:: + operator= (AssemblyConnectionDescription const& s) + { + name (*s.name_); + + deployRequirement_ = s.deployRequirement_; + + internalEndpoint_ = s.internalEndpoint_; + + externalEndpoint_ = s.externalEndpoint_; + + externalReference_ = s.externalReference_; + + 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > 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 (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > const& e) + { + externalReference_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_externalReference(void) const + { + return externalReference_.size (); + } + + + // PlanLocalityKind + // + + PlanLocalityKind::Value PlanLocalityKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::PlanLocalityKind const& a, ::CIAO::Config_Handlers::PlanLocalityKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::PlanLocalityKind const& a, ::CIAO::Config_Handlers::PlanLocalityKind const& b) + { + return a.v_ != b.v_; + } + + PlanLocalityKind:: + PlanLocalityKind (PlanLocalityKind::Value v) + : v_ (v) + { + } + + // PlanLocality + // + + PlanLocality:: + PlanLocality (::CIAO::Config_Handlers::PlanLocalityKind const& constraint__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > > const& constrainedInstance__) + : + constraint_ (new ::CIAO::Config_Handlers::PlanLocalityKind (constraint__)), + constrainedInstance_ (constrainedInstance__), + regulator__ () + { + constraint_->container (this); + } + + PlanLocality:: + PlanLocality (PlanLocality const& s) + : + ::XSCRT::Type (), + constraint_ (new ::CIAO::Config_Handlers::PlanLocalityKind (*s.constraint_)), + constrainedInstance_ (s.constrainedInstance_), + regulator__ () + { + constraint_->container (this); + } + + PlanLocality& PlanLocality:: + operator= (PlanLocality const& s) + { + constraint (*s.constraint_); + + constrainedInstance_ = s.constrainedInstance_; + + return *this; + } + + + // PlanLocality + // + ::CIAO::Config_Handlers::PlanLocalityKind const& PlanLocality:: + constraint () const + { + return *constraint_; + } + + void PlanLocality:: + constraint (::CIAO::Config_Handlers::PlanLocalityKind const& e) + { + *constraint_ = e; + } + + // PlanLocality + // + PlanLocality::constrainedInstance_iterator PlanLocality:: + begin_constrainedInstance () + { + return constrainedInstance_.begin (); + } + + PlanLocality::constrainedInstance_iterator PlanLocality:: + end_constrainedInstance () + { + return constrainedInstance_.end (); + } + + PlanLocality::constrainedInstance_const_iterator PlanLocality:: + begin_constrainedInstance () const + { + return constrainedInstance_.begin (); + } + + PlanLocality::constrainedInstance_const_iterator PlanLocality:: + end_constrainedInstance () const + { + return constrainedInstance_.end (); + } + + void PlanLocality:: + add_constrainedInstance (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > const& e) + { + constrainedInstance_.push_back (e); + } + + size_t PlanLocality:: + count_constrainedInstance(void) const + { + return constrainedInstance_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // IdRef + // + + IdRef:: + IdRef (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + 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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (t); + } + + else if (n == ACE_TEXT ("idref")) + { + ::XMLSchema::IDREF< ACE_TCHAR > t (a); + idref (t); + std::basic_string<ACE_TCHAR> temp ((*idref_).id().c_str()); + + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_idref(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else + { + } + } + } + + // TCKind + // + + TCKind:: + TCKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == ACE_TEXT ("tk_null")) v_ = tk_null_l; + else if (v == ACE_TEXT ("tk_void")) v_ = tk_void_l; + else if (v == ACE_TEXT ("tk_short")) v_ = tk_short_l; + else if (v == ACE_TEXT ("tk_long")) v_ = tk_long_l; + else if (v == ACE_TEXT ("tk_ushort")) v_ = tk_ushort_l; + else if (v == ACE_TEXT ("tk_ulong")) v_ = tk_ulong_l; + else if (v == ACE_TEXT ("tk_float")) v_ = tk_float_l; + else if (v == ACE_TEXT ("tk_double")) v_ = tk_double_l; + else if (v == ACE_TEXT ("tk_boolean")) v_ = tk_boolean_l; + else if (v == ACE_TEXT ("tk_char")) v_ = tk_char_l; + else if (v == ACE_TEXT ("tk_octet")) v_ = tk_octet_l; + else if (v == ACE_TEXT ("tk_any")) v_ = tk_any_l; + else if (v == ACE_TEXT ("tk_TypeCode")) v_ = tk_TypeCode_l; + else if (v == ACE_TEXT ("tk_Principal")) v_ = tk_Principal_l; + else if (v == ACE_TEXT ("tk_objref")) v_ = tk_objref_l; + else if (v == ACE_TEXT ("tk_struct")) v_ = tk_struct_l; + else if (v == ACE_TEXT ("tk_union")) v_ = tk_union_l; + else if (v == ACE_TEXT ("tk_enum")) v_ = tk_enum_l; + else if (v == ACE_TEXT ("tk_string")) v_ = tk_string_l; + else if (v == ACE_TEXT ("tk_sequence")) v_ = tk_sequence_l; + else if (v == ACE_TEXT ("tk_array")) v_ = tk_array_l; + else if (v == ACE_TEXT ("tk_alias")) v_ = tk_alias_l; + else if (v == ACE_TEXT ("tk_except")) v_ = tk_except_l; + else if (v == ACE_TEXT ("tk_longlong")) v_ = tk_longlong_l; + else if (v == ACE_TEXT ("tk_ulonglong")) v_ = tk_ulonglong_l; + else if (v == ACE_TEXT ("tk_longdouble")) v_ = tk_longdouble_l; + else if (v == ACE_TEXT ("tk_wchar")) v_ = tk_wchar_l; + else if (v == ACE_TEXT ("tk_wstring")) v_ = tk_wstring_l; + else if (v == ACE_TEXT ("tk_fixed")) v_ = tk_fixed_l; + else if (v == ACE_TEXT ("tk_value")) v_ = tk_value_l; + else if (v == ACE_TEXT ("tk_value_box")) v_ = tk_value_box_l; + else if (v == ACE_TEXT ("tk_native")) v_ = tk_native_l; + else if (v == ACE_TEXT ("tk_abstract_interface")) v_ = tk_abstract_interface_l; + else if (v == ACE_TEXT ("tk_local_interface")) v_ = tk_local_interface_l; + else if (v == ACE_TEXT ("tk_component")) v_ = tk_component_l; + else if (v == ACE_TEXT ("tk_home")) v_ = tk_home_l; + else if (v == ACE_TEXT ("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 == ACE_TEXT ("tk_null")) v_ = tk_null_l; + else if (v == ACE_TEXT ("tk_void")) v_ = tk_void_l; + else if (v == ACE_TEXT ("tk_short")) v_ = tk_short_l; + else if (v == ACE_TEXT ("tk_long")) v_ = tk_long_l; + else if (v == ACE_TEXT ("tk_ushort")) v_ = tk_ushort_l; + else if (v == ACE_TEXT ("tk_ulong")) v_ = tk_ulong_l; + else if (v == ACE_TEXT ("tk_float")) v_ = tk_float_l; + else if (v == ACE_TEXT ("tk_double")) v_ = tk_double_l; + else if (v == ACE_TEXT ("tk_boolean")) v_ = tk_boolean_l; + else if (v == ACE_TEXT ("tk_char")) v_ = tk_char_l; + else if (v == ACE_TEXT ("tk_octet")) v_ = tk_octet_l; + else if (v == ACE_TEXT ("tk_any")) v_ = tk_any_l; + else if (v == ACE_TEXT ("tk_TypeCode")) v_ = tk_TypeCode_l; + else if (v == ACE_TEXT ("tk_Principal")) v_ = tk_Principal_l; + else if (v == ACE_TEXT ("tk_objref")) v_ = tk_objref_l; + else if (v == ACE_TEXT ("tk_struct")) v_ = tk_struct_l; + else if (v == ACE_TEXT ("tk_union")) v_ = tk_union_l; + else if (v == ACE_TEXT ("tk_enum")) v_ = tk_enum_l; + else if (v == ACE_TEXT ("tk_string")) v_ = tk_string_l; + else if (v == ACE_TEXT ("tk_sequence")) v_ = tk_sequence_l; + else if (v == ACE_TEXT ("tk_array")) v_ = tk_array_l; + else if (v == ACE_TEXT ("tk_alias")) v_ = tk_alias_l; + else if (v == ACE_TEXT ("tk_except")) v_ = tk_except_l; + else if (v == ACE_TEXT ("tk_longlong")) v_ = tk_longlong_l; + else if (v == ACE_TEXT ("tk_ulonglong")) v_ = tk_ulonglong_l; + else if (v == ACE_TEXT ("tk_longdouble")) v_ = tk_longdouble_l; + else if (v == ACE_TEXT ("tk_wchar")) v_ = tk_wchar_l; + else if (v == ACE_TEXT ("tk_wstring")) v_ = tk_wstring_l; + else if (v == ACE_TEXT ("tk_fixed")) v_ = tk_fixed_l; + else if (v == ACE_TEXT ("tk_value")) v_ = tk_value_l; + else if (v == ACE_TEXT ("tk_value_box")) v_ = tk_value_box_l; + else if (v == ACE_TEXT ("tk_native")) v_ = tk_native_l; + else if (v == ACE_TEXT ("tk_abstract_interface")) v_ = tk_abstract_interface_l; + else if (v == ACE_TEXT ("tk_local_interface")) v_ = tk_local_interface_l; + else if (v == ACE_TEXT ("tk_component")) v_ = tk_component_l; + else if (v == ACE_TEXT ("tk_home")) v_ = tk_home_l; + else if (v == ACE_TEXT ("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_fixed (TCKind::tk_fixed_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 == ACE_TEXT("kind")) + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > (new ::CIAO::Config_Handlers::TCKind (e)); + kind_->container (this); + } + + else if (n == ACE_TEXT("enum")) + { + ::CIAO::Config_Handlers::EnumType t (e); + enum_ (t); + } + + else if (n == ACE_TEXT("struct")) + { + ::CIAO::Config_Handlers::StructType t (e); + struct_ (t); + } + + else if (n == ACE_TEXT("value")) + { + ::CIAO::Config_Handlers::ValueType t (e); + value (t); + } + + else if (n == ACE_TEXT("sequence")) + { + ::CIAO::Config_Handlers::SequenceType t (e); + sequence (t); + } + + else if (n == ACE_TEXT("alias")) + { + ::CIAO::Config_Handlers::AliasType t (e); + alias (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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + 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 == ACE_TEXT("short")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > t (new ::XMLSchema::short_ (e)); + add_short (t); + } + + else if (n == ACE_TEXT("long")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > t (new ::XMLSchema::int_ (e)); + add_long (t); + } + + else if (n == ACE_TEXT("ushort")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > t (new ::XMLSchema::unsignedShort (e)); + add_ushort (t); + } + + else if (n == ACE_TEXT("ulong")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > t (new ::XMLSchema::unsignedInt (e)); + add_ulong (t); + } + + else if (n == ACE_TEXT("float")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > t (new ::XMLSchema::float_ (e)); + add_float (t); + } + + else if (n == ACE_TEXT("double")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > t (new ::XMLSchema::double_ (e)); + add_double (t); + } + + else if (n == ACE_TEXT("boolean")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > t (new ::XMLSchema::boolean (e)); + add_boolean (t); + } + + else if (n == ACE_TEXT("octet")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > t (new ::XMLSchema::unsignedByte (e)); + add_octet (t); + } + + else if (n == ACE_TEXT("enum")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_enum (t); + } + + else if (n == ACE_TEXT("string")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_string (t); + } + + else if (n == ACE_TEXT("longlong")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > t (new ::XMLSchema::long_ (e)); + add_longlong (t); + } + + else if (n == ACE_TEXT("ulonglong")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > t (new ::XMLSchema::unsignedLong (e)); + add_ulonglong (t); + } + + else if (n == ACE_TEXT("longdouble")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > t (new ::XMLSchema::double_ (e)); + add_longdouble (t); + } + + else if (n == ACE_TEXT("element")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::DataValue (e)); + add_element (t); + } + + else if (n == ACE_TEXT("member")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::NamedValue (e)); + add_member (t); + } + + else + { + } + } + } + + // AliasType + // + + AliasType:: + AliasType (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("typeId")) + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == ACE_TEXT("elementType")) + { + elementType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + elementType_->container (this); + } + + 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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("typeId")) + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == ACE_TEXT("member")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("typeId")) + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == ACE_TEXT("member")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::StructMemberType (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("typeId")) + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == ACE_TEXT("modifier")) + { + modifier_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + modifier_->container (this); + } + + else if (n == ACE_TEXT("baseType")) + { + baseType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + baseType_->container (this); + } + + else if (n == ACE_TEXT("member")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ValueMemberType (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("visibility")) + { + visibility_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + visibility_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("bound")) + { + ::XMLSchema::unsignedInt t (e); + bound (t); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("type")) + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT ("Quantity")) v_ = Quantity_l; + else if (v == ACE_TEXT ("Capacity")) v_ = Capacity_l; + else if (v == ACE_TEXT ("Minimum")) v_ = Minimum_l; + else if (v == ACE_TEXT ("Maximum")) v_ = Maximum_l; + else if (v == ACE_TEXT ("Attribute")) v_ = Attribute_l; + else if (v == ACE_TEXT ("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 == ACE_TEXT ("Quantity")) v_ = Quantity_l; + else if (v == ACE_TEXT ("Capacity")) v_ = Capacity_l; + else if (v == ACE_TEXT ("Minimum")) v_ = Minimum_l; + else if (v == ACE_TEXT ("Maximum")) v_ = Maximum_l; + else if (v == ACE_TEXT ("Attribute")) v_ = Attribute_l; + else if (v == ACE_TEXT ("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("kind")) + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierPropertyKind > (new ::CIAO::Config_Handlers::SatisfierPropertyKind (e)); + kind_->container (this); + } + + else if (n == ACE_TEXT("dynamic")) + { + dynamic_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + dynamic_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("resourceType")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_resourceType (t); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SatisfierProperty (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("resourceType")) + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (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 == ACE_TEXT("requirementName")) + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == ACE_TEXT("resourceName")) + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("source")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_source (t); + } + + else if (n == ACE_TEXT("node")) + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == ACE_TEXT("location")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_location (t); + } + + else if (n == ACE_TEXT("execParameter")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_execParameter (t); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_deployRequirement (t); + } + + else if (n == ACE_TEXT("deployedResource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ResourceDeploymentDescription (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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + 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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("source")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_source (t); + } + + else if (n == ACE_TEXT("artifact")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::IdRef (e)); + add_artifact (t); + } + + else if (n == ACE_TEXT("execParameter")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_execParameter (t); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else + { + } + } + } + + // ResourceUsageKind + // + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == ACE_TEXT ("None")) v_ = None_l; + else if (v == ACE_TEXT ("InstanceUsesResource")) v_ = InstanceUsesResource_l; + else if (v == ACE_TEXT ("ResourceUsesInstance")) v_ = ResourceUsesInstance_l; + else if (v == ACE_TEXT ("PortUsesResource")) v_ = PortUsesResource_l; + else if (v == ACE_TEXT ("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 == ACE_TEXT ("None")) v_ = None_l; + else if (v == ACE_TEXT ("InstanceUsesResource")) v_ = InstanceUsesResource_l; + else if (v == ACE_TEXT ("ResourceUsesInstance")) v_ = ResourceUsesInstance_l; + else if (v == ACE_TEXT ("PortUsesResource")) v_ = PortUsesResource_l; + else if (v == ACE_TEXT ("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 == ACE_TEXT("resourceUsage")) + { + resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (new ::CIAO::Config_Handlers::ResourceUsageKind (e)); + resourceUsage_->container (this); + } + + else if (n == ACE_TEXT("requirementName")) + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == ACE_TEXT("resourceName")) + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("node")) + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == ACE_TEXT("source")) + { + source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + source_->container (this); + } + + else if (n == ACE_TEXT("implementation")) + { + implementation_ = ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > (new ::CIAO::Config_Handlers::IdRef (e)); + implementation_->container (this); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("deployedResource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (e)); + add_deployedResource (t); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else + { + } + } + } + + // CCMComponentPortKind + // + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == ACE_TEXT ("Facet")) v_ = Facet_l; + else if (v == ACE_TEXT ("SimplexReceptacle")) v_ = SimplexReceptacle_l; + else if (v == ACE_TEXT ("MultiplexReceptacle")) v_ = MultiplexReceptacle_l; + else if (v == ACE_TEXT ("EventEmitter")) v_ = EventEmitter_l; + else if (v == ACE_TEXT ("EventPublisher")) v_ = EventPublisher_l; + else if (v == ACE_TEXT ("EventConsumer")) v_ = EventConsumer_l; + else if (v == ACE_TEXT ("ExtendedPort")) v_ = ExtendedPort_l; + else if (v == ACE_TEXT ("MirrorPort")) v_ = MirrorPort_l; + else + { + } + } + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == ACE_TEXT ("Facet")) v_ = Facet_l; + else if (v == ACE_TEXT ("SimplexReceptacle")) v_ = SimplexReceptacle_l; + else if (v == ACE_TEXT ("MultiplexReceptacle")) v_ = MultiplexReceptacle_l; + else if (v == ACE_TEXT ("EventEmitter")) v_ = EventEmitter_l; + else if (v == ACE_TEXT ("EventPublisher")) v_ = EventPublisher_l; + else if (v == ACE_TEXT ("EventConsumer")) v_ = EventConsumer_l; + else if (v == ACE_TEXT ("ExtendedPort")) v_ = ExtendedPort_l; + else if (v == ACE_TEXT ("MirrorPort")) v_ = MirrorPort_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); + CCMComponentPortKind const CCMComponentPortKind::ExtendedPort (CCMComponentPortKind::ExtendedPort_l); + CCMComponentPortKind const CCMComponentPortKind::MirrorPort (CCMComponentPortKind::MirrorPort_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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("specificType")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + specificType (t); + } + + else if (n == ACE_TEXT("supportedType")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_supportedType (t); + } + + else if (n == ACE_TEXT("provider")) + { + provider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + provider_->container (this); + } + + else if (n == ACE_TEXT("exclusiveProvider")) + { + exclusiveProvider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveProvider_->container (this); + } + + else if (n == ACE_TEXT("exclusiveUser")) + { + exclusiveUser_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveUser_->container (this); + } + + else if (n == ACE_TEXT("optional")) + { + optional_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + optional_->container (this); + } + + else if (n == ACE_TEXT("kind")) + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else if (n == ACE_TEXT("templateParam")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_templateParam (t); + } + + 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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("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 == ACE_TEXT("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 == ACE_TEXT("portName")) + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == ACE_TEXT("provider")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + provider (t); + } + + else if (n == ACE_TEXT("kind")) + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else if (n == ACE_TEXT("instance")) + { + instance_ = ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > (new ::CIAO::Config_Handlers::IdRef (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 == ACE_TEXT("location")) + { + location_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + location_->container (this); + } + + else if (n == ACE_TEXT("provider")) + { + provider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + provider_->container (this); + } + + else if (n == ACE_TEXT("portName")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + portName (t); + } + + else if (n == ACE_TEXT("supportedType")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_supportedType (t); + } + + 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 == ACE_TEXT("targetName")) + { + targetName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + targetName_->container (this); + } + + else if (n == ACE_TEXT("requirementName")) + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == ACE_TEXT("resourceName")) + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("source")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + source (t); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_deployRequirement (t); + } + + else if (n == ACE_TEXT("externalEndpoint")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ComponentExternalPortEndpoint (e)); + add_externalEndpoint (t); + } + + else if (n == ACE_TEXT("internalEndpoint")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint (e)); + add_internalEndpoint (t); + } + + else if (n == ACE_TEXT("externalReference")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ExternalReferenceEndpoint (e)); + add_externalReference (t); + } + + else if (n == ACE_TEXT("deployedResource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription (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 == ACE_TEXT("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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("resourceType")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_resourceType (t); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SatisfierProperty (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 == ACE_TEXT("resourceUsage")) + { + ::CIAO::Config_Handlers::ResourceUsageKind t (e); + resourceUsage (t); + } + + else if (n == ACE_TEXT("resourcePort")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + resourcePort (t); + } + + else if (n == ACE_TEXT("componentPort")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + componentPort (t); + } + + else if (n == ACE_TEXT("resourceType")) + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_property (t); + } + + 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 == ACE_TEXT("portName")) + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == ACE_TEXT("instance")) + { + instance_ = ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > (new ::CIAO::Config_Handlers::IdRef (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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_deployRequirement (t); + } + + else if (n == ACE_TEXT("internalEndpoint")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SubcomponentPortEndpoint (e)); + add_internalEndpoint (t); + } + + else if (n == ACE_TEXT("externalEndpoint")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ComponentExternalPortEndpoint (e)); + add_externalEndpoint (t); + } + + else if (n == ACE_TEXT("externalReference")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ExternalReferenceEndpoint (e)); + add_externalReference (t); + } + + else + { + } + } + } + + // PlanLocalityKind + // + + PlanLocalityKind:: + PlanLocalityKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == ACE_TEXT ("SameProcess")) v_ = SameProcess_l; + else if (v == ACE_TEXT ("DifferentProcess")) v_ = DifferentProcess_l; + else if (v == ACE_TEXT ("NoConstraint")) v_ = NoConstraint_l; + else + { + } + } + + PlanLocalityKind:: + PlanLocalityKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == ACE_TEXT ("SameProcess")) v_ = SameProcess_l; + else if (v == ACE_TEXT ("DifferentProcess")) v_ = DifferentProcess_l; + else if (v == ACE_TEXT ("NoConstraint")) v_ = NoConstraint_l; + else + { + } + } + + PlanLocalityKind const PlanLocalityKind::SameProcess (PlanLocalityKind::SameProcess_l); + PlanLocalityKind const PlanLocalityKind::DifferentProcess (PlanLocalityKind::DifferentProcess_l); + PlanLocalityKind const PlanLocalityKind::NoConstraint (PlanLocalityKind::NoConstraint_l); + + // PlanLocality + // + + PlanLocality:: + PlanLocality (::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 == ACE_TEXT("constraint")) + { + constraint_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PlanLocalityKind > (new ::CIAO::Config_Handlers::PlanLocalityKind (e)); + constraint_->container (this); + } + + else if (n == ACE_TEXT("constrainedInstance")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::IdRef (e)); + add_constrainedInstance (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 IdRefTypeInfoInitializer + { + IdRefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::IdRef)); + ::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)); + } + }; + + IdRefTypeInfoInitializer IdRefTypeInfoInitializer_; + + 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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 AliasTypeTypeInfoInitializer + { + AliasTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::AliasType)); + ::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)); + } + }; + + AliasTypeTypeInfoInitializer AliasTypeTypeInfoInitializer_; + + struct EnumTypeTypeInfoInitializer + { + EnumTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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 SubcomponentPortEndpointTypeInfoInitializer + { + SubcomponentPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::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 (::CIAO::Config_Handlers::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_; + + struct PlanLocalityKindTypeInfoInitializer + { + PlanLocalityKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PlanLocalityKind)); + ::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)); + } + }; + + PlanLocalityKindTypeInfoInitializer PlanLocalityKindTypeInfoInitializer_; + + struct PlanLocalityTypeInfoInitializer + { + PlanLocalityTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::PlanLocality)); + ::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)); + } + }; + + PlanLocalityTypeInfoInitializer PlanLocalityTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // IdRef + // + // + + void IdRef:: + traverse (Type& o) + { + pre (o); + if (o.href_p ()) href (o); + else href_none (o); + if (o.idref_p ()) idref (o); + else idref_none (o); + post (o); + } + + void IdRef:: + traverse (Type const& o) + { + pre (o); + if (o.href_p ()) href (o); + else href_none (o); + if (o.idref_p ()) idref (o); + else idref_none (o); + post (o); + } + + void IdRef:: + pre (Type&) + { + } + + void IdRef:: + pre (Type const&) + { + } + + void IdRef:: + href (Type& o) + { + dispatch (o.href ()); + } + + void IdRef:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void IdRef:: + href_none (Type&) + { + } + + void IdRef:: + href_none (Type const&) + { + } + + void IdRef:: + idref (Type& o) + { + dispatch (o.idref ()); + } + + void IdRef:: + idref (Type const& o) + { + dispatch (o.idref ()); + } + + void IdRef:: + idref_none (Type&) + { + } + + void IdRef:: + idref_none (Type const&) + { + } + + void IdRef:: + post (Type&) + { + } + + void IdRef:: + post (Type const&) + { + } + + // 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.alias_p ()) alias (o); + else alias_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.alias_p ()) alias (o); + else alias_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:: + alias (Type& o) + { + dispatch (o.alias ()); + } + + void DataType:: + alias (Type const& o) + { + dispatch (o.alias ()); + } + + void DataType:: + alias_none (Type&) + { + } + + void DataType:: + alias_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); + element (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); + element (o); + member (o); + post (o); + } + + void DataValue:: + pre (Type&) + { + } + + void DataValue:: + pre (Type const&) + { + } + + void DataValue:: + short_ (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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:: + element (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::DataValue::element_iterator b (o.begin_element()), e (o.end_element()); + + if (b != e) + { + element_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) element_next (o); + } + + element_post (o); + } + + else element_none (o); + } + + void DataValue:: + element (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::DataValue::element_const_iterator b (o.begin_element()), e (o.end_element()); + + if (b != e) + { + element_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) element_next (o); + } + + element_post (o); + } + + else element_none (o); + } + + void DataValue:: + element_pre (Type&) + { + } + + void DataValue:: + element_pre (Type const&) + { + } + + void DataValue:: + element_next (Type&) + { + } + + void DataValue:: + element_next (Type const&) + { + } + + void DataValue:: + element_post (Type&) + { + } + + void DataValue:: + element_post (Type const&) + { + } + + void DataValue:: + element_none (Type&) + { + } + + void DataValue:: + element_none (Type const&) + { + } + + void DataValue:: + member (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::DataValue::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 + // + ::CIAO::Config_Handlers::DataValue::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&) + { + } + + // AliasType + // + // + + void AliasType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + elementType (o); + post (o); + } + + void AliasType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + elementType (o); + post (o); + } + + void AliasType:: + pre (Type&) + { + } + + void AliasType:: + pre (Type const&) + { + } + + void AliasType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void AliasType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void AliasType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void AliasType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void AliasType:: + elementType (Type& o) + { + dispatch (o.elementType ()); + } + + void AliasType:: + elementType (Type const& o) + { + dispatch (o.elementType ()); + } + + void AliasType:: + post (Type&) + { + } + + void AliasType:: + 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 + // + ::CIAO::Config_Handlers::EnumType::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 + // + ::CIAO::Config_Handlers::EnumType::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 + // + ::CIAO::Config_Handlers::StructType::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 + // + ::CIAO::Config_Handlers::StructType::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 + // + ::CIAO::Config_Handlers::ValueType::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 + // + ::CIAO::Config_Handlers::ValueType::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 + // + ::CIAO::Config_Handlers::Resource::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 + // + ::CIAO::Config_Handlers::Resource::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 + // + ::CIAO::Config_Handlers::Resource::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 + // + ::CIAO::Config_Handlers::Resource::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); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Requirement:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Requirement:: + pre (Type&) + { + } + + void Requirement:: + pre (Type const&) + { + } + + void Requirement:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Requirement:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Requirement:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + property (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Requirement::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 + // + ::CIAO::Config_Handlers::Requirement::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 + // + ::CIAO::Config_Handlers::ResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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); + } + + else source_none (o); + } + + void ArtifactDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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); + } + + else source_none (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:: + source_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_none (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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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); + } + + else location_none (o); + } + + void ArtifactDeploymentDescription:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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); + } + + else location_none (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:: + location_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ArtifactDeploymentDescription::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 + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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); + } + + else source_none (o); + } + + void MonolithicDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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); + } + + else source_none (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:: + source_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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); + } + + else artifact_none (o); + } + + void MonolithicDeploymentDescription:: + artifact (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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); + } + + else artifact_none (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:: + artifact_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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 + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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 + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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 + // + ::CIAO::Config_Handlers::MonolithicDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::InstanceDeploymentDescription::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); + templateParam (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); + templateParam (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 + // + ::CIAO::Config_Handlers::ComponentPortDescription::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 + // + ::CIAO::Config_Handlers::ComponentPortDescription::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:: + templateParam (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPortDescription::templateParam_iterator b (o.begin_templateParam()), e (o.end_templateParam()); + + if (b != e) + { + templateParam_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) templateParam_next (o); + } + + templateParam_post (o); + } + + else templateParam_none (o); + } + + void ComponentPortDescription:: + templateParam (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPortDescription::templateParam_const_iterator b (o.begin_templateParam()), e (o.end_templateParam()); + + if (b != e) + { + templateParam_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) templateParam_next (o); + } + + templateParam_post (o); + } + + else templateParam_none (o); + } + + void ComponentPortDescription:: + templateParam_pre (Type&) + { + } + + void ComponentPortDescription:: + templateParam_pre (Type const&) + { + } + + void ComponentPortDescription:: + templateParam_next (Type&) + { + } + + void ComponentPortDescription:: + templateParam_next (Type const&) + { + } + + void ComponentPortDescription:: + templateParam_post (Type&) + { + } + + void ComponentPortDescription:: + templateParam_post (Type const&) + { + } + + void ComponentPortDescription:: + templateParam_none (Type&) + { + } + + void ComponentPortDescription:: + templateParam_none (Type const&) + { + } + + 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); + provider (o); + if (o.portName_p ()) portName (o); + else portName_none (o); + supportedType (o); + post (o); + } + + void ExternalReferenceEndpoint:: + traverse (Type const& o) + { + pre (o); + location (o); + provider (o); + if (o.portName_p ()) portName (o); + else portName_none (o); + supportedType (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:: + provider (Type& o) + { + dispatch (o.provider ()); + } + + void ExternalReferenceEndpoint:: + provider (Type const& o) + { + dispatch (o.provider ()); + } + + void ExternalReferenceEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void ExternalReferenceEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void ExternalReferenceEndpoint:: + portName_none (Type&) + { + } + + void ExternalReferenceEndpoint:: + portName_none (Type const&) + { + } + + void ExternalReferenceEndpoint:: + supportedType (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ExternalReferenceEndpoint::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 ExternalReferenceEndpoint:: + supportedType (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ExternalReferenceEndpoint::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 ExternalReferenceEndpoint:: + supportedType_pre (Type&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_pre (Type const&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_next (Type&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_next (Type const&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_post (Type&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_post (Type const&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_none (Type&) + { + } + + void ExternalReferenceEndpoint:: + supportedType_none (Type const&) + { + } + + 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 + // + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::PlanConnectionDescription::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 + // + ::CIAO::Config_Handlers::Capability::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); + } + + else resourceType_none (o); + } + + void Capability:: + resourceType (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Capability::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); + } + + else resourceType_none (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:: + resourceType_none (Type&) + { + } + + void Capability:: + resourceType_none (Type const&) + { + } + + void Capability:: + property (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Capability::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 + // + ::CIAO::Config_Handlers::Capability::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 + // + ::CIAO::Config_Handlers::ImplementationRequirement::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 + // + ::CIAO::Config_Handlers::ImplementationRequirement::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&) + { + } + + // 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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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 + // + ::CIAO::Config_Handlers::AssemblyConnectionDescription::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&) + { + } + + // PlanLocality + // + // + + void PlanLocality:: + traverse (Type& o) + { + pre (o); + constraint (o); + constrainedInstance (o); + post (o); + } + + void PlanLocality:: + traverse (Type const& o) + { + pre (o); + constraint (o); + constrainedInstance (o); + post (o); + } + + void PlanLocality:: + pre (Type&) + { + } + + void PlanLocality:: + pre (Type const&) + { + } + + void PlanLocality:: + constraint (Type& o) + { + dispatch (o.constraint ()); + } + + void PlanLocality:: + constraint (Type const& o) + { + dispatch (o.constraint ()); + } + + void PlanLocality:: + constrainedInstance (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanLocality::constrainedInstance_iterator b (o.begin_constrainedInstance()), e (o.end_constrainedInstance()); + + if (b != e) + { + constrainedInstance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) constrainedInstance_next (o); + } + + constrainedInstance_post (o); + } + } + + void PlanLocality:: + constrainedInstance (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanLocality::constrainedInstance_const_iterator b (o.begin_constrainedInstance()), e (o.end_constrainedInstance()); + + if (b != e) + { + constrainedInstance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) constrainedInstance_next (o); + } + + constrainedInstance_post (o); + } + } + + void PlanLocality:: + constrainedInstance_pre (Type&) + { + } + + void PlanLocality:: + constrainedInstance_pre (Type const&) + { + } + + void PlanLocality:: + constrainedInstance_next (Type&) + { + } + + void PlanLocality:: + constrainedInstance_next (Type const&) + { + } + + void PlanLocality:: + constrainedInstance_post (Type&) + { + } + + void PlanLocality:: + constrainedInstance_post (Type const&) + { + } + + void PlanLocality:: + post (Type&) + { + } + + void PlanLocality:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // IdRef + // + // + + IdRef:: + IdRef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + IdRef:: + IdRef () + { + } + + void IdRef:: + traverse (Type const& o) + { + Traversal::IdRef::traverse (o); + } + + void IdRef:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::IdRef::href (o); + attr_ (0); + } + + void IdRef:: + idref (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("idref"), ACE_TEXT ("http://www.omg.org/Deployment"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::IdRef::idref (o); + attr_ (0); + } + + // 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 = ACE_TEXT ("tk_null"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_void) s = ACE_TEXT ("tk_void"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_short) s = ACE_TEXT ("tk_short"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_long) s = ACE_TEXT ("tk_long"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ushort) s = ACE_TEXT ("tk_ushort"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulong) s = ACE_TEXT ("tk_ulong"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_float) s = ACE_TEXT ("tk_float"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_double) s = ACE_TEXT ("tk_double"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_boolean) s = ACE_TEXT ("tk_boolean"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_char) s = ACE_TEXT ("tk_char"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_octet) s = ACE_TEXT ("tk_octet"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_any) s = ACE_TEXT ("tk_any"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_TypeCode) s = ACE_TEXT ("tk_TypeCode"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_Principal) s = ACE_TEXT ("tk_Principal"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_objref) s = ACE_TEXT ("tk_objref"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_struct) s = ACE_TEXT ("tk_struct"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_union) s = ACE_TEXT ("tk_union"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_enum) s = ACE_TEXT ("tk_enum"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_string) s = ACE_TEXT ("tk_string"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_sequence) s = ACE_TEXT ("tk_sequence"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_array) s = ACE_TEXT ("tk_array"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_alias) s = ACE_TEXT ("tk_alias"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_except) s = ACE_TEXT ("tk_except"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longlong) s = ACE_TEXT ("tk_longlong"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulonglong) s = ACE_TEXT ("tk_ulonglong"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longdouble) s = ACE_TEXT ("tk_longdouble"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wchar) s = ACE_TEXT ("tk_wchar"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wstring) s = ACE_TEXT ("tk_wstring"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_fixed) s = ACE_TEXT ("tk_fixed"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value) s = ACE_TEXT ("tk_value"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value_box) s = ACE_TEXT ("tk_value_box"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_native) s = ACE_TEXT ("tk_native"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_abstract_interface) s = ACE_TEXT ("tk_abstract_interface"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_local_interface) s = ACE_TEXT ("tk_local_interface"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_component) s = ACE_TEXT ("tk_component"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_home) s = ACE_TEXT ("tk_home"); + else if (o == ::CIAO::Config_Handlers::TCKind::tk_event) s = ACE_TEXT ("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 > (ACE_TEXT ("kind"), top_ ())); + Traversal::DataType::kind (o); + pop_ (); + } + + void DataType:: + enum_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("enum"), top_ ())); + Traversal::DataType::enum_ (o); + pop_ (); + } + + void DataType:: + struct_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("struct"), top_ ())); + Traversal::DataType::struct_ (o); + pop_ (); + } + + void DataType:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("value"), top_ ())); + Traversal::DataType::value (o); + pop_ (); + } + + void DataType:: + sequence (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("sequence"), top_ ())); + Traversal::DataType::sequence (o); + pop_ (); + } + + void DataType:: + alias (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("alias"), top_ ())); + Traversal::DataType::alias (o); + pop_ (); + } + + void DataType:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("id"), ACE_TEXT ("http://www.omg.org/Deployment"), ACE_TEXT (""), 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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("longdouble"), top_ ())); + } + + void DataValue:: + longdouble_next (Type const& o) + { + longdouble_post (o); + longdouble_pre (o); + } + + void DataValue:: + longdouble_post (Type const&) + { + pop_ (); + } + + void DataValue:: + element_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("element"), top_ ())); + } + + void DataValue:: + element_next (Type const& o) + { + element_post (o); + element_pre (o); + } + + void DataValue:: + element_post (Type const&) + { + pop_ (); + } + + void DataValue:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("member"), top_ ())); + } + + void DataValue:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void DataValue:: + member_post (Type const&) + { + pop_ (); + } + + // AliasType + // + // + + AliasType:: + AliasType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + AliasType:: + AliasType () + { + } + + void AliasType:: + traverse (Type const& o) + { + Traversal::AliasType::traverse (o); + } + + void AliasType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::AliasType::name (o); + pop_ (); + } + + void AliasType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("typeId"), top_ ())); + Traversal::AliasType::typeId (o); + pop_ (); + } + + void AliasType:: + elementType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("elementType"), top_ ())); + Traversal::AliasType::elementType (o); + 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 > (ACE_TEXT ("name"), top_ ())); + Traversal::EnumType::name (o); + pop_ (); + } + + void EnumType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("typeId"), top_ ())); + Traversal::EnumType::typeId (o); + pop_ (); + } + + void EnumType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::StructType::name (o); + pop_ (); + } + + void StructType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("typeId"), top_ ())); + Traversal::StructType::typeId (o); + pop_ (); + } + + void StructType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::StructMemberType::name (o); + pop_ (); + } + + void StructMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::ValueType::name (o); + pop_ (); + } + + void ValueType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("typeId"), top_ ())); + Traversal::ValueType::typeId (o); + pop_ (); + } + + void ValueType:: + modifier (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("modifier"), top_ ())); + Traversal::ValueType::modifier (o); + pop_ (); + } + + void ValueType:: + baseType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("baseType"), top_ ())); + Traversal::ValueType::baseType (o); + pop_ (); + } + + void ValueType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::ValueMemberType::name (o); + pop_ (); + } + + void ValueMemberType:: + visibility (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("visibility"), top_ ())); + Traversal::ValueMemberType::visibility (o); + pop_ (); + } + + void ValueMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::NamedValue::name (o); + pop_ (); + } + + void NamedValue:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("bound"), top_ ())); + Traversal::SequenceType::bound (o); + pop_ (); + } + + void SequenceType:: + elementType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("type"), top_ ())); + Traversal::Any::type (o); + pop_ (); + } + + void Any:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::Property::name (o); + pop_ (); + } + + void Property:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 = ACE_TEXT ("Quantity"); + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Capacity) s = ACE_TEXT ("Capacity"); + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Minimum) s = ACE_TEXT ("Minimum"); + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Maximum) s = ACE_TEXT ("Maximum"); + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Attribute) s = ACE_TEXT ("Attribute"); + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Selection) s = ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::SatisfierProperty::name (o); + pop_ (); + } + + void SatisfierProperty:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("kind"), top_ ())); + Traversal::SatisfierProperty::kind (o); + pop_ (); + } + + void SatisfierProperty:: + dynamic (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("dynamic"), top_ ())); + Traversal::SatisfierProperty::dynamic (o); + pop_ (); + } + + void SatisfierProperty:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::Resource::name (o); + pop_ (); + } + + void Resource:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::Requirement::name (o); + pop_ (); + } + + void Requirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceType"), top_ ())); + Traversal::Requirement::resourceType (o); + pop_ (); + } + + void Requirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("requirementName"), top_ ())); + Traversal::ResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceName"), top_ ())); + Traversal::ResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::ArtifactDeploymentDescription::name (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("node"), top_ ())); + Traversal::ArtifactDeploymentDescription::node (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 (ACE_TEXT ("id"), ACE_TEXT ("http://www.omg.org/Deployment"), ACE_TEXT (""), 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 > (ACE_TEXT ("name"), top_ ())); + Traversal::MonolithicDeploymentDescription::name (o); + pop_ (); + } + + void MonolithicDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 (ACE_TEXT ("id"), ACE_TEXT ("http://www.omg.org/Deployment"), ACE_TEXT (""), 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 = ACE_TEXT ("None"); + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::InstanceUsesResource) s = ACE_TEXT ("InstanceUsesResource"); + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesInstance) s = ACE_TEXT ("ResourceUsesInstance"); + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::PortUsesResource) s = ACE_TEXT ("PortUsesResource"); + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesPort) s = ACE_TEXT ("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 > (ACE_TEXT ("resourceUsage"), top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceUsage (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("requirementName"), top_ ())); + Traversal::InstanceResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceName"), top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::InstanceDeploymentDescription::name (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("node"), top_ ())); + Traversal::InstanceDeploymentDescription::node (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("source"), top_ ())); + Traversal::InstanceDeploymentDescription::source (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + implementation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implementation"), top_ ())); + Traversal::InstanceDeploymentDescription::implementation (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("deployedSharedResource"), top_ ())); + Traversal::InstanceDeploymentDescription::deployedSharedResource (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("id"), ACE_TEXT ("http://www.omg.org/Deployment"), ACE_TEXT (""), 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 = ACE_TEXT ("Facet"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::SimplexReceptacle) s = ACE_TEXT ("SimplexReceptacle"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::MultiplexReceptacle) s = ACE_TEXT ("MultiplexReceptacle"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventEmitter) s = ACE_TEXT ("EventEmitter"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventPublisher) s = ACE_TEXT ("EventPublisher"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventConsumer) s = ACE_TEXT ("EventConsumer"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::ExtendedPort) s = ACE_TEXT ("ExtendedPort"); + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::MirrorPort) s = ACE_TEXT ("MirrorPort"); + 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 > (ACE_TEXT ("name"), top_ ())); + Traversal::ComponentPortDescription::name (o); + pop_ (); + } + + void ComponentPortDescription:: + specificType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("specificType"), top_ ())); + Traversal::ComponentPortDescription::specificType (o); + pop_ (); + } + + void ComponentPortDescription:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("provider"), top_ ())); + Traversal::ComponentPortDescription::provider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveProvider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("exclusiveProvider"), top_ ())); + Traversal::ComponentPortDescription::exclusiveProvider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveUser (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("exclusiveUser"), top_ ())); + Traversal::ComponentPortDescription::exclusiveUser (o); + pop_ (); + } + + void ComponentPortDescription:: + optional (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("optional"), top_ ())); + Traversal::ComponentPortDescription::optional (o); + pop_ (); + } + + void ComponentPortDescription:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("kind"), top_ ())); + Traversal::ComponentPortDescription::kind (o); + pop_ (); + } + + void ComponentPortDescription:: + templateParam_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("templateParam"), top_ ())); + } + + void ComponentPortDescription:: + templateParam_next (Type const& o) + { + templateParam_post (o); + templateParam_pre (o); + } + + void ComponentPortDescription:: + templateParam_post (Type const&) + { + 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 > (ACE_TEXT ("name"), top_ ())); + Traversal::ComponentPropertyDescription::name (o); + pop_ (); + } + + void ComponentPropertyDescription:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("portName"), top_ ())); + Traversal::PlanSubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("provider"), top_ ())); + Traversal::PlanSubcomponentPortEndpoint::provider (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("kind"), top_ ())); + Traversal::PlanSubcomponentPortEndpoint::kind (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("location"), top_ ())); + Traversal::ExternalReferenceEndpoint::location (o); + pop_ (); + } + + void ExternalReferenceEndpoint:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("provider"), top_ ())); + Traversal::ExternalReferenceEndpoint::provider (o); + pop_ (); + } + + void ExternalReferenceEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("portName"), top_ ())); + Traversal::ExternalReferenceEndpoint::portName (o); + pop_ (); + } + + void ExternalReferenceEndpoint:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("supportedType"), top_ ())); + } + + void ExternalReferenceEndpoint:: + supportedType_next (Type const& o) + { + supportedType_post (o); + supportedType_pre (o); + } + + void ExternalReferenceEndpoint:: + supportedType_post (Type const&) + { + 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 > (ACE_TEXT ("targetName"), top_ ())); + Traversal::ConnectionResourceDeploymentDescription::targetName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("requirementName"), top_ ())); + Traversal::ConnectionResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceName"), top_ ())); + Traversal::ConnectionResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::PlanConnectionDescription::name (o); + pop_ (); + } + + void PlanConnectionDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("source"), top_ ())); + Traversal::PlanConnectionDescription::source (o); + pop_ (); + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::Capability::name (o); + pop_ (); + } + + void Capability:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("resourceUsage"), top_ ())); + Traversal::ImplementationRequirement::resourceUsage (o); + pop_ (); + } + + void ImplementationRequirement:: + resourcePort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourcePort"), top_ ())); + Traversal::ImplementationRequirement::resourcePort (o); + pop_ (); + } + + void ImplementationRequirement:: + componentPort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("componentPort"), top_ ())); + Traversal::ImplementationRequirement::componentPort (o); + pop_ (); + } + + void ImplementationRequirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceType"), top_ ())); + Traversal::ImplementationRequirement::resourceType (o); + pop_ (); + } + + void ImplementationRequirement:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::ImplementationRequirement::name (o); + pop_ (); + } + + void ImplementationRequirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("property"), top_ ())); + } + + void ImplementationRequirement:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ImplementationRequirement:: + property_post (Type const&) + { + 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 > (ACE_TEXT ("portName"), top_ ())); + Traversal::SubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void SubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("name"), top_ ())); + Traversal::AssemblyConnectionDescription::name (o); + pop_ (); + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("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 > (ACE_TEXT ("externalReference"), top_ ())); + } + + void AssemblyConnectionDescription:: + externalReference_next (Type const& o) + { + externalReference_post (o); + externalReference_pre (o); + } + + void AssemblyConnectionDescription:: + externalReference_post (Type const&) + { + pop_ (); + } + + // PlanLocalityKind + // + // + + PlanLocalityKind:: + PlanLocalityKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanLocalityKind:: + PlanLocalityKind () + { + } + + void PlanLocalityKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::PlanLocalityKind::SameProcess) s = ACE_TEXT ("SameProcess"); + else if (o == ::CIAO::Config_Handlers::PlanLocalityKind::DifferentProcess) s = ACE_TEXT ("DifferentProcess"); + else if (o == ::CIAO::Config_Handlers::PlanLocalityKind::NoConstraint) s = ACE_TEXT ("NoConstraint"); + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // PlanLocality + // + // + + PlanLocality:: + PlanLocality (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanLocality:: + PlanLocality () + { + } + + void PlanLocality:: + traverse (Type const& o) + { + Traversal::PlanLocality::traverse (o); + } + + void PlanLocality:: + constraint (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("constraint"), top_ ())); + Traversal::PlanLocality::constraint (o); + pop_ (); + } + + void PlanLocality:: + constrainedInstance_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("constrainedInstance"), top_ ())); + } + + void PlanLocality:: + constrainedInstance_next (Type const& o) + { + constrainedInstance_post (o); + constrainedInstance_pre (o); + } + + void PlanLocality:: + constrainedInstance_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp b/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp new file mode 100644 index 00000000000..50b1ec3283a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp @@ -0,0 +1,8561 @@ +/* $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 + +#ifndef BASIC_DEPLOYMENT_DATA_HPP +#define BASIC_DEPLOYMENT_DATA_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class IdRef; + class TCKind; + class DataType; + class DataValue; + class AliasType; + class EnumType; + class StructType; + class StructMemberType; + class ValueType; + class ValueMemberType; + class NamedValue; + class SequenceType; + class Any; + class Property; + class SatisfierPropertyKind; + class SatisfierProperty; + class Resource; + class Requirement; + class ResourceDeploymentDescription; + class ArtifactDeploymentDescription; + class MonolithicDeploymentDescription; + class ResourceUsageKind; + class InstanceResourceDeploymentDescription; + class InstanceDeploymentDescription; + class CCMComponentPortKind; + class ComponentPortDescription; + class ComponentPropertyDescription; + class ComponentExternalPortEndpoint; + class PlanSubcomponentPortEndpoint; + class ExternalReferenceEndpoint; + class ConnectionResourceDeploymentDescription; + class PlanConnectionDescription; + class ImplementationDependency; + class Capability; + class ImplementationRequirement; + class SubcomponentPortEndpoint; + class AssemblyConnectionDescription; + class PlanLocalityKind; + class PlanLocality; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "XMI.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export IdRef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < IdRef, ACE_Null_Mutex > _ptr; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + // idref + // + public: + bool idref_p () const; + ::XMLSchema::IDREF< ACE_TCHAR > const& idref () const; + ::XMLSchema::IDREF< ACE_TCHAR >& idref (); + void idref (::XMLSchema::IDREF< ACE_TCHAR > const& ); + ::XSCRT::Type* idref_ptr (); + + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > idref_; + + public: + IdRef (); + + IdRef (::XSCRT::XML::Element< ACE_TCHAR > const&); + IdRef (IdRef const& s); + + IdRef& + operator= (IdRef const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export TCKind : public ::XSCRT::Type + { + public: + TCKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + TCKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static TCKind const tk_null; + static TCKind const tk_void; + static TCKind const tk_short; + static TCKind const tk_long; + static TCKind const tk_ushort; + static TCKind const tk_ulong; + static TCKind const tk_float; + static TCKind const tk_double; + static TCKind const tk_boolean; + static TCKind const tk_char; + static TCKind const tk_octet; + static TCKind const tk_any; + static TCKind const tk_TypeCode; + static TCKind const tk_Principal; + static TCKind const tk_objref; + static TCKind const tk_struct; + static TCKind const tk_union; + static TCKind const tk_enum; + static TCKind const tk_string; + static TCKind const tk_sequence; + static TCKind const tk_array; + static TCKind const tk_alias; + static TCKind const tk_except; + static TCKind const tk_longlong; + static TCKind const tk_ulonglong; + static TCKind const tk_longdouble; + static TCKind const tk_wchar; + static TCKind const tk_wstring; + static TCKind const tk_fixed; + static TCKind const tk_value; + static TCKind const tk_value_box; + static TCKind const tk_native; + static TCKind const tk_abstract_interface; + static TCKind const tk_local_interface; + static TCKind const tk_component; + static TCKind const tk_home; + static TCKind const tk_event; + + enum Value + { + tk_null_l, tk_void_l, tk_short_l, tk_long_l, tk_ushort_l, tk_ulong_l, tk_float_l, tk_double_l, tk_boolean_l, tk_char_l, tk_octet_l, tk_any_l, tk_TypeCode_l, tk_Principal_l, tk_objref_l, tk_struct_l, tk_union_l, tk_enum_l, tk_string_l, tk_sequence_l, tk_array_l, tk_alias_l, tk_except_l, tk_longlong_l, tk_ulonglong_l, tk_longdouble_l, tk_wchar_l, tk_wstring_l, tk_fixed_l, tk_value_l, tk_value_box_l, tk_native_l, tk_abstract_interface_l, tk_local_interface_l, tk_component_l, tk_home_l, tk_event_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (TCKind const& a, TCKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (TCKind const& a, TCKind const& b); + + private: + TCKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (TCKind const &a, TCKind const &b); + + bool XSC_XML_Handlers_Export operator!= (TCKind const &a, TCKind const &b); + + + class XSC_XML_Handlers_Export DataType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < DataType, ACE_Null_Mutex > _ptr; + + // kind + // + public: + ::CIAO::Config_Handlers::TCKind const& kind () const; + void kind (::CIAO::Config_Handlers::TCKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > kind_; + + // enum + // + public: + bool enum_p () const; + ::CIAO::Config_Handlers::EnumType const& enum_ () const; + void enum_ (::CIAO::Config_Handlers::EnumType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::EnumType > enum__; + + // struct + // + public: + bool struct_p () const; + ::CIAO::Config_Handlers::StructType const& struct_ () const; + void struct_ (::CIAO::Config_Handlers::StructType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::StructType > struct__; + + // value + // + public: + bool value_p () const; + ::CIAO::Config_Handlers::ValueType const& value () const; + void value (::CIAO::Config_Handlers::ValueType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ValueType > value_; + + // sequence + // + public: + bool sequence_p () const; + ::CIAO::Config_Handlers::SequenceType const& sequence () const; + void sequence (::CIAO::Config_Handlers::SequenceType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::SequenceType > sequence_; + + // alias + // + public: + bool alias_p () const; + ::CIAO::Config_Handlers::AliasType const& alias () const; + void alias (::CIAO::Config_Handlers::AliasType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::AliasType > alias_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + DataType (::CIAO::Config_Handlers::TCKind const& kind__); + + DataType (::XSCRT::XML::Element< ACE_TCHAR > const&); + DataType (DataType const& s); + + DataType& + operator= (DataType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export DataValue : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < DataValue, ACE_Null_Mutex > _ptr; + + // short + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > >::iterator short_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > >::const_iterator short_const_iterator; + short_iterator begin_short (); + short_iterator end_short (); + short_const_iterator begin_short () const; + short_const_iterator end_short () const; + void add_short ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > const& ); + XSCRT::Type* short_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_short (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::short_, ACE_Null_Mutex > > short__; + + // long + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > >::iterator long_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > >::const_iterator long_const_iterator; + long_iterator begin_long (); + long_iterator end_long (); + long_const_iterator begin_long () const; + long_const_iterator end_long () const; + void add_long ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > const& ); + XSCRT::Type* long_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_long (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::int_, ACE_Null_Mutex > > long__; + + // ushort + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > >::iterator ushort_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > >::const_iterator ushort_const_iterator; + ushort_iterator begin_ushort (); + ushort_iterator end_ushort (); + ushort_const_iterator begin_ushort () const; + ushort_const_iterator end_ushort () const; + void add_ushort ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > const& ); + XSCRT::Type* ushort_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_ushort (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedShort, ACE_Null_Mutex > > ushort_; + + // ulong + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > >::iterator ulong_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > >::const_iterator ulong_const_iterator; + ulong_iterator begin_ulong (); + ulong_iterator end_ulong (); + ulong_const_iterator begin_ulong () const; + ulong_const_iterator end_ulong () const; + void add_ulong ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > const& ); + XSCRT::Type* ulong_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_ulong (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedInt, ACE_Null_Mutex > > ulong_; + + // float + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > >::iterator float_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > >::const_iterator float_const_iterator; + float_iterator begin_float (); + float_iterator end_float (); + float_const_iterator begin_float () const; + float_const_iterator end_float () const; + void add_float ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > const& ); + XSCRT::Type* float_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_float (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::float_, ACE_Null_Mutex > > float__; + + // double + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > >::iterator double_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > >::const_iterator double_const_iterator; + double_iterator begin_double (); + double_iterator end_double (); + double_const_iterator begin_double () const; + double_const_iterator end_double () const; + void add_double ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > const& ); + XSCRT::Type* double_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_double (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > > double__; + + // boolean + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > >::iterator boolean_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > >::const_iterator boolean_const_iterator; + boolean_iterator begin_boolean (); + boolean_iterator end_boolean (); + boolean_const_iterator begin_boolean () const; + boolean_const_iterator end_boolean () const; + void add_boolean ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > const& ); + XSCRT::Type* boolean_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_boolean (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::boolean, ACE_Null_Mutex > > boolean_; + + // octet + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > >::iterator octet_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > >::const_iterator octet_const_iterator; + octet_iterator begin_octet (); + octet_iterator end_octet (); + octet_const_iterator begin_octet () const; + octet_const_iterator end_octet () const; + void add_octet ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > const& ); + XSCRT::Type* octet_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_octet (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedByte, ACE_Null_Mutex > > octet_; + + // enum + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator enum_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator enum_const_iterator; + enum_iterator begin_enum (); + enum_iterator end_enum (); + enum_const_iterator begin_enum () const; + enum_const_iterator end_enum () const; + void add_enum ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* enum_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_enum (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > enum__; + + // string + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator string_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator string_const_iterator; + string_iterator begin_string (); + string_iterator end_string (); + string_const_iterator begin_string () const; + string_const_iterator end_string () const; + void add_string ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* string_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_string (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > string_; + + // longlong + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > >::iterator longlong_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > >::const_iterator longlong_const_iterator; + longlong_iterator begin_longlong (); + longlong_iterator end_longlong (); + longlong_const_iterator begin_longlong () const; + longlong_const_iterator end_longlong () const; + void add_longlong ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > const& ); + XSCRT::Type* longlong_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_longlong (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::long_, ACE_Null_Mutex > > longlong_; + + // ulonglong + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > >::iterator ulonglong_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > >::const_iterator ulonglong_const_iterator; + ulonglong_iterator begin_ulonglong (); + ulonglong_iterator end_ulonglong (); + ulonglong_const_iterator begin_ulonglong () const; + ulonglong_const_iterator end_ulonglong () const; + void add_ulonglong ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > const& ); + XSCRT::Type* ulonglong_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_ulonglong (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::unsignedLong, ACE_Null_Mutex > > ulonglong_; + + // longdouble + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > >::iterator longdouble_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > >::const_iterator longdouble_const_iterator; + longdouble_iterator begin_longdouble (); + longdouble_iterator end_longdouble (); + longdouble_const_iterator begin_longdouble () const; + longdouble_const_iterator end_longdouble () const; + void add_longdouble ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > const& ); + XSCRT::Type* longdouble_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_longdouble (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::double_, ACE_Null_Mutex > > longdouble_; + + // element + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > >::iterator element_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > >::const_iterator element_const_iterator; + element_iterator begin_element (); + element_iterator end_element (); + element_const_iterator begin_element () const; + element_const_iterator end_element () const; + void add_element ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > const& ); + XSCRT::Type* element_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_element (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::DataValue, ACE_Null_Mutex > > element_; + + // member + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > >::iterator member_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > >::const_iterator member_const_iterator; + member_iterator begin_member (); + member_iterator end_member (); + member_const_iterator begin_member () const; + member_const_iterator end_member () const; + void add_member ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > const& ); + XSCRT::Type* member_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_member (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedValue, ACE_Null_Mutex > > member_; + + public: + DataValue (); + + DataValue (::XSCRT::XML::Element< ACE_TCHAR > const&); + DataValue (DataValue const& s); + + DataValue& + operator= (DataValue const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export AliasType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < AliasType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // typeId + // + public: + ::XMLSchema::string< ACE_TCHAR > const& typeId () const; + void typeId (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > typeId_; + + // elementType + // + public: + ::CIAO::Config_Handlers::DataType const& elementType () const; + void elementType (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > elementType_; + + public: + AliasType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::CIAO::Config_Handlers::DataType const& elementType__); + + AliasType (::XSCRT::XML::Element< ACE_TCHAR > const&); + AliasType (AliasType const& s); + + AliasType& + operator= (AliasType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export EnumType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < EnumType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // typeId + // + public: + ::XMLSchema::string< ACE_TCHAR > const& typeId () const; + void typeId (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > typeId_; + + // member + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator member_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator member_const_iterator; + member_iterator begin_member (); + member_iterator end_member (); + member_const_iterator begin_member () const; + member_const_iterator end_member () const; + void add_member ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* member_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_member (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > member_; + + public: + EnumType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > const& member__); + + EnumType (::XSCRT::XML::Element< ACE_TCHAR > const&); + EnumType (EnumType const& s); + + EnumType& + operator= (EnumType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export StructType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < StructType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // typeId + // + public: + ::XMLSchema::string< ACE_TCHAR > const& typeId () const; + void typeId (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > typeId_; + + // member + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > >::iterator member_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > >::const_iterator member_const_iterator; + member_iterator begin_member (); + member_iterator end_member (); + member_const_iterator begin_member () const; + member_const_iterator end_member () const; + void add_member ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > const& ); + XSCRT::Type* member_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_member (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::StructMemberType, ACE_Null_Mutex > > member_; + + public: + StructType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__); + + StructType (::XSCRT::XML::Element< ACE_TCHAR > const&); + StructType (StructType const& s); + + StructType& + operator= (StructType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export StructMemberType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < StructMemberType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // type + // + public: + ::CIAO::Config_Handlers::DataType const& type () const; + void type (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > type_; + + public: + StructMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__); + + StructMemberType (::XSCRT::XML::Element< ACE_TCHAR > const&); + StructMemberType (StructMemberType const& s); + + StructMemberType& + operator= (StructMemberType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ValueType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ValueType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // typeId + // + public: + ::XMLSchema::string< ACE_TCHAR > const& typeId () const; + void typeId (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > typeId_; + + // modifier + // + public: + ::XMLSchema::string< ACE_TCHAR > const& modifier () const; + void modifier (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > modifier_; + + // baseType + // + public: + ::CIAO::Config_Handlers::DataType const& baseType () const; + void baseType (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > baseType_; + + // member + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > >::iterator member_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > >::const_iterator member_const_iterator; + member_iterator begin_member (); + member_iterator end_member (); + member_const_iterator begin_member () const; + member_const_iterator end_member () const; + void add_member ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > const& ); + XSCRT::Type* member_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_member (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ValueMemberType, ACE_Null_Mutex > > member_; + + public: + 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__); + + ValueType (::XSCRT::XML::Element< ACE_TCHAR > const&); + ValueType (ValueType const& s); + + ValueType& + operator= (ValueType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ValueMemberType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ValueMemberType, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // visibility + // + public: + ::XMLSchema::string< ACE_TCHAR > const& visibility () const; + void visibility (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > visibility_; + + // type + // + public: + ::CIAO::Config_Handlers::DataType const& type () const; + void type (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > type_; + + public: + ValueMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& visibility__, + ::CIAO::Config_Handlers::DataType const& type__); + + ValueMemberType (::XSCRT::XML::Element< ACE_TCHAR > const&); + ValueMemberType (ValueMemberType const& s); + + ValueMemberType& + operator= (ValueMemberType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export NamedValue : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < NamedValue, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // value + // + public: + ::CIAO::Config_Handlers::DataValue const& value () const; + void value (::CIAO::Config_Handlers::DataValue const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > value_; + + public: + NamedValue (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataValue const& value__); + + NamedValue (::XSCRT::XML::Element< ACE_TCHAR > const&); + NamedValue (NamedValue const& s); + + NamedValue& + operator= (NamedValue const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SequenceType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SequenceType, ACE_Null_Mutex > _ptr; + + // bound + // + public: + bool bound_p () const; + ::XMLSchema::unsignedInt const& bound () const; + void bound (::XMLSchema::unsignedInt const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedInt > bound_; + + // elementType + // + public: + ::CIAO::Config_Handlers::DataType const& elementType () const; + void elementType (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > elementType_; + + public: + SequenceType (::CIAO::Config_Handlers::DataType const& elementType__); + + SequenceType (::XSCRT::XML::Element< ACE_TCHAR > const&); + SequenceType (SequenceType const& s); + + SequenceType& + operator= (SequenceType const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Any : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Any, ACE_Null_Mutex > _ptr; + + // type + // + public: + ::CIAO::Config_Handlers::DataType const& type () const; + void type (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > type_; + + // value + // + public: + ::CIAO::Config_Handlers::DataValue const& value () const; + void value (::CIAO::Config_Handlers::DataValue const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > value_; + + public: + Any (::CIAO::Config_Handlers::DataType const& type__, + ::CIAO::Config_Handlers::DataValue const& value__); + + Any (::XSCRT::XML::Element< ACE_TCHAR > const&); + Any (Any const& s); + + Any& + operator= (Any const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Property : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Property, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // value + // + public: + ::CIAO::Config_Handlers::Any const& value () const; + void value (::CIAO::Config_Handlers::Any const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::Any > value_; + + public: + Property (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::Any const& value__); + + Property (::XSCRT::XML::Element< ACE_TCHAR > const&); + Property (Property const& s); + + Property& + operator= (Property const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SatisfierPropertyKind : public ::XSCRT::Type + { + public: + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + SatisfierPropertyKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static SatisfierPropertyKind const Quantity; + static SatisfierPropertyKind const Capacity; + static SatisfierPropertyKind const Minimum; + static SatisfierPropertyKind const Maximum; + static SatisfierPropertyKind const Attribute; + static SatisfierPropertyKind const Selection; + + enum Value + { + Quantity_l, Capacity_l, Minimum_l, Maximum_l, Attribute_l, Selection_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (SatisfierPropertyKind const& a, SatisfierPropertyKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (SatisfierPropertyKind const& a, SatisfierPropertyKind const& b); + + private: + SatisfierPropertyKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (SatisfierPropertyKind const &a, SatisfierPropertyKind const &b); + + bool XSC_XML_Handlers_Export operator!= (SatisfierPropertyKind const &a, SatisfierPropertyKind const &b); + + + class XSC_XML_Handlers_Export SatisfierProperty : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SatisfierProperty, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // kind + // + public: + ::CIAO::Config_Handlers::SatisfierPropertyKind const& kind () const; + void kind (::CIAO::Config_Handlers::SatisfierPropertyKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierPropertyKind > kind_; + + // dynamic + // + public: + ::XMLSchema::boolean const& dynamic () const; + void dynamic (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > dynamic_; + + // value + // + public: + ::CIAO::Config_Handlers::Any const& value () const; + void value (::CIAO::Config_Handlers::Any const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::Any > value_; + + public: + SatisfierProperty (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::SatisfierPropertyKind const& kind__, + ::XMLSchema::boolean const& dynamic__, + ::CIAO::Config_Handlers::Any const& value__); + + SatisfierProperty (::XSCRT::XML::Element< ACE_TCHAR > const&); + SatisfierProperty (SatisfierProperty const& s); + + SatisfierProperty& + operator= (SatisfierProperty const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Resource : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Resource, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // resourceType + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator resourceType_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator resourceType_const_iterator; + resourceType_iterator begin_resourceType (); + resourceType_iterator end_resourceType (); + resourceType_const_iterator begin_resourceType () const; + resourceType_const_iterator end_resourceType () const; + void add_resourceType ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* resourceType_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_resourceType (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > resourceType_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > > property_; + + public: + Resource (::XMLSchema::string< ACE_TCHAR > const& name__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > const& resourceType__); + + Resource (::XSCRT::XML::Element< ACE_TCHAR > const&); + Resource (Resource const& s); + + Resource& + operator= (Resource const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Requirement : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Requirement, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // resourceType + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceType () const; + void resourceType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceType_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > property_; + + public: + Requirement (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& resourceType__); + + Requirement (::XSCRT::XML::Element< ACE_TCHAR > const&); + Requirement (Requirement const& s); + + Requirement& + operator= (Requirement const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ResourceDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ResourceDeploymentDescription, ACE_Null_Mutex > _ptr; + + // requirementName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& requirementName () const; + void requirementName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requirementName_; + + // resourceName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceName () const; + void resourceName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceName_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > property_; + + public: + ResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__); + + ResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ResourceDeploymentDescription (ResourceDeploymentDescription const& s); + + ResourceDeploymentDescription& + operator= (ResourceDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ArtifactDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ArtifactDeploymentDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // source + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator source_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* source_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_source (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > source_; + + // node + // + public: + ::XMLSchema::string< ACE_TCHAR > const& node () const; + void node (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > node_; + + // location + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator location_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator location_const_iterator; + location_iterator begin_location (); + location_iterator end_location (); + location_const_iterator begin_location () const; + location_const_iterator end_location () const; + void add_location ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* location_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_location (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > location_; + + // execParameter + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator execParameter_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator execParameter_const_iterator; + execParameter_iterator begin_execParameter (); + execParameter_iterator end_execParameter (); + execParameter_const_iterator begin_execParameter () const; + execParameter_const_iterator end_execParameter () const; + void add_execParameter ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* execParameter_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > execParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > deployRequirement_; + + // deployedResource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > >::iterator deployedResource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > >::const_iterator deployedResource_const_iterator; + deployedResource_iterator begin_deployedResource (); + deployedResource_iterator end_deployedResource (); + deployedResource_const_iterator begin_deployedResource () const; + deployedResource_const_iterator end_deployedResource () const; + void add_deployedResource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* deployedResource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ResourceDeploymentDescription, ACE_Null_Mutex > > deployedResource_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + ArtifactDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__); + + ArtifactDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ArtifactDeploymentDescription (ArtifactDeploymentDescription const& s); + + ArtifactDeploymentDescription& + operator= (ArtifactDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export MonolithicDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < MonolithicDeploymentDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // source + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator source_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* source_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_source (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > source_; + + // artifact + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > >::iterator artifact_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > >::const_iterator artifact_const_iterator; + artifact_iterator begin_artifact (); + artifact_iterator end_artifact (); + artifact_const_iterator begin_artifact () const; + artifact_const_iterator end_artifact () const; + void add_artifact ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > const& ); + XSCRT::Type* artifact_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_artifact (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > > artifact_; + + // execParameter + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator execParameter_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator execParameter_const_iterator; + execParameter_iterator begin_execParameter (); + execParameter_iterator end_execParameter (); + execParameter_const_iterator begin_execParameter () const; + execParameter_const_iterator end_execParameter () const; + void add_execParameter ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* execParameter_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > execParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > deployRequirement_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + MonolithicDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__); + + MonolithicDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + MonolithicDeploymentDescription (MonolithicDeploymentDescription const& s); + + MonolithicDeploymentDescription& + operator= (MonolithicDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ResourceUsageKind : public ::XSCRT::Type + { + public: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + ResourceUsageKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static ResourceUsageKind const None; + static ResourceUsageKind const InstanceUsesResource; + static ResourceUsageKind const ResourceUsesInstance; + static ResourceUsageKind const PortUsesResource; + static ResourceUsageKind const ResourceUsesPort; + + enum Value + { + None_l, InstanceUsesResource_l, ResourceUsesInstance_l, PortUsesResource_l, ResourceUsesPort_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (ResourceUsageKind const& a, ResourceUsageKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (ResourceUsageKind const& a, ResourceUsageKind const& b); + + private: + ResourceUsageKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (ResourceUsageKind const &a, ResourceUsageKind const &b); + + bool XSC_XML_Handlers_Export operator!= (ResourceUsageKind const &a, ResourceUsageKind const &b); + + + class XSC_XML_Handlers_Export InstanceResourceDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < InstanceResourceDeploymentDescription, ACE_Null_Mutex > _ptr; + + // resourceUsage + // + public: + ::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage () const; + void resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > resourceUsage_; + + // requirementName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& requirementName () const; + void requirementName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requirementName_; + + // resourceName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceName () const; + void resourceName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceName_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > property_; + + public: + InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__); + + InstanceResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + InstanceResourceDeploymentDescription (InstanceResourceDeploymentDescription const& s); + + InstanceResourceDeploymentDescription& + operator= (InstanceResourceDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export InstanceDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < InstanceDeploymentDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // node + // + public: + ::XMLSchema::string< ACE_TCHAR > const& node () const; + void node (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > node_; + + // source + // + public: + ::XMLSchema::string< ACE_TCHAR > const& source () const; + void source (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > source_; + + // implementation + // + public: + ::CIAO::Config_Handlers::IdRef const& implementation () const; + void implementation (::CIAO::Config_Handlers::IdRef const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > implementation_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // deployedResource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > >::iterator deployedResource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > >::const_iterator deployedResource_const_iterator; + deployedResource_iterator begin_deployedResource (); + deployedResource_iterator end_deployedResource (); + deployedResource_const_iterator begin_deployedResource () const; + deployedResource_const_iterator end_deployedResource () const; + void add_deployedResource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* deployedResource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription, ACE_Null_Mutex > > deployedResource_; + + // deployedSharedResource + // + public: + bool deployedSharedResource_p () const; + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& deployedSharedResource () const; + void deployedSharedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > deployedSharedResource_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + InstanceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::XMLSchema::string< ACE_TCHAR > const& source__, + ::CIAO::Config_Handlers::IdRef const& implementation__); + + InstanceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + InstanceDeploymentDescription (InstanceDeploymentDescription const& s); + + InstanceDeploymentDescription& + operator= (InstanceDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export CCMComponentPortKind : public ::XSCRT::Type + { + public: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + CCMComponentPortKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static CCMComponentPortKind const Facet; + static CCMComponentPortKind const SimplexReceptacle; + static CCMComponentPortKind const MultiplexReceptacle; + static CCMComponentPortKind const EventEmitter; + static CCMComponentPortKind const EventPublisher; + static CCMComponentPortKind const EventConsumer; + static CCMComponentPortKind const ExtendedPort; + static CCMComponentPortKind const MirrorPort; + + enum Value + { + Facet_l, SimplexReceptacle_l, MultiplexReceptacle_l, EventEmitter_l, EventPublisher_l, EventConsumer_l, ExtendedPort_l, MirrorPort_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (CCMComponentPortKind const& a, CCMComponentPortKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (CCMComponentPortKind const& a, CCMComponentPortKind const& b); + + private: + CCMComponentPortKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (CCMComponentPortKind const &a, CCMComponentPortKind const &b); + + bool XSC_XML_Handlers_Export operator!= (CCMComponentPortKind const &a, CCMComponentPortKind const &b); + + + class XSC_XML_Handlers_Export ComponentPortDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentPortDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // specificType + // + public: + bool specificType_p () const; + ::XMLSchema::string< ACE_TCHAR > const& specificType () const; + void specificType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > specificType_; + + // supportedType + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator supportedType_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator supportedType_const_iterator; + supportedType_iterator begin_supportedType (); + supportedType_iterator end_supportedType (); + supportedType_const_iterator begin_supportedType () const; + supportedType_const_iterator end_supportedType () const; + void add_supportedType ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* supportedType_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_supportedType (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > supportedType_; + + // provider + // + public: + ::XMLSchema::boolean const& provider () const; + void provider (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > provider_; + + // exclusiveProvider + // + public: + ::XMLSchema::boolean const& exclusiveProvider () const; + void exclusiveProvider (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > exclusiveProvider_; + + // exclusiveUser + // + public: + ::XMLSchema::boolean const& exclusiveUser () const; + void exclusiveUser (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > exclusiveUser_; + + // optional + // + public: + ::XMLSchema::boolean const& optional () const; + void optional (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > optional_; + + // kind + // + public: + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind () const; + void kind (::CIAO::Config_Handlers::CCMComponentPortKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > kind_; + + // templateParam + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator templateParam_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator templateParam_const_iterator; + templateParam_iterator begin_templateParam (); + templateParam_iterator end_templateParam (); + templateParam_const_iterator begin_templateParam () const; + templateParam_const_iterator end_templateParam () const; + void add_templateParam ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* templateParam_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_templateParam (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > templateParam_; + + public: + 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__); + + ComponentPortDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPortDescription (ComponentPortDescription const& s); + + ComponentPortDescription& + operator= (ComponentPortDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ComponentPropertyDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentPropertyDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // type + // + public: + ::CIAO::Config_Handlers::DataType const& type () const; + void type (::CIAO::Config_Handlers::DataType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > type_; + + public: + ComponentPropertyDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__); + + ComponentPropertyDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPropertyDescription (ComponentPropertyDescription const& s); + + ComponentPropertyDescription& + operator= (ComponentPropertyDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ComponentExternalPortEndpoint : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentExternalPortEndpoint, ACE_Null_Mutex > _ptr; + + // portName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& portName () const; + void portName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > portName_; + + public: + ComponentExternalPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__); + + ComponentExternalPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentExternalPortEndpoint (ComponentExternalPortEndpoint const& s); + + ComponentExternalPortEndpoint& + operator= (ComponentExternalPortEndpoint const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export PlanSubcomponentPortEndpoint : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PlanSubcomponentPortEndpoint, ACE_Null_Mutex > _ptr; + + // portName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& portName () const; + void portName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > portName_; + + // provider + // + public: + bool provider_p () const; + ::XMLSchema::string< ACE_TCHAR > const& provider () const; + void provider (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > provider_; + + // kind + // + public: + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind () const; + void kind (::CIAO::Config_Handlers::CCMComponentPortKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > kind_; + + // instance + // + public: + ::CIAO::Config_Handlers::IdRef const& instance () const; + void instance (::CIAO::Config_Handlers::IdRef const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > instance_; + + public: + PlanSubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__, + ::CIAO::Config_Handlers::IdRef const& instance__); + + PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanSubcomponentPortEndpoint (PlanSubcomponentPortEndpoint const& s); + + PlanSubcomponentPortEndpoint& + operator= (PlanSubcomponentPortEndpoint const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ExternalReferenceEndpoint : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ExternalReferenceEndpoint, ACE_Null_Mutex > _ptr; + + // location + // + public: + ::XMLSchema::string< ACE_TCHAR > const& location () const; + void location (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > location_; + + // provider + // + public: + ::XMLSchema::boolean const& provider () const; + void provider (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > provider_; + + // portName + // + public: + bool portName_p () const; + ::XMLSchema::string< ACE_TCHAR > const& portName () const; + void portName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > portName_; + + // supportedType + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator supportedType_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator supportedType_const_iterator; + supportedType_iterator begin_supportedType (); + supportedType_iterator end_supportedType (); + supportedType_const_iterator begin_supportedType () const; + supportedType_const_iterator end_supportedType () const; + void add_supportedType ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* supportedType_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_supportedType (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > supportedType_; + + public: + ExternalReferenceEndpoint (::XMLSchema::string< ACE_TCHAR > const& location__, + ::XMLSchema::boolean const& provider__); + + ExternalReferenceEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const&); + ExternalReferenceEndpoint (ExternalReferenceEndpoint const& s); + + ExternalReferenceEndpoint& + operator= (ExternalReferenceEndpoint const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ConnectionResourceDeploymentDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ConnectionResourceDeploymentDescription, ACE_Null_Mutex > _ptr; + + // targetName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& targetName () const; + void targetName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > targetName_; + + // requirementName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& requirementName () const; + void requirementName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requirementName_; + + // resourceName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceName () const; + void resourceName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceName_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > property_; + + public: + ConnectionResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& targetName__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__); + + ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ConnectionResourceDeploymentDescription (ConnectionResourceDeploymentDescription const& s); + + ConnectionResourceDeploymentDescription& + operator= (ConnectionResourceDeploymentDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export PlanConnectionDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PlanConnectionDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // source + // + public: + bool source_p () const; + ::XMLSchema::string< ACE_TCHAR > const& source () const; + void source (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > source_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > deployRequirement_; + + // externalEndpoint + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > >::iterator externalEndpoint_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > >::const_iterator externalEndpoint_const_iterator; + externalEndpoint_iterator begin_externalEndpoint (); + externalEndpoint_iterator end_externalEndpoint (); + externalEndpoint_const_iterator begin_externalEndpoint () const; + externalEndpoint_const_iterator end_externalEndpoint () const; + void add_externalEndpoint ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* externalEndpoint_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalEndpoint (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > > externalEndpoint_; + + // internalEndpoint + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > >::iterator internalEndpoint_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > >::const_iterator internalEndpoint_const_iterator; + internalEndpoint_iterator begin_internalEndpoint (); + internalEndpoint_iterator end_internalEndpoint (); + internalEndpoint_const_iterator begin_internalEndpoint () const; + internalEndpoint_const_iterator end_internalEndpoint () const; + void add_internalEndpoint ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* internalEndpoint_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_internalEndpoint (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint, ACE_Null_Mutex > > internalEndpoint_; + + // externalReference + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > >::iterator externalReference_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > >::const_iterator externalReference_const_iterator; + externalReference_iterator begin_externalReference (); + externalReference_iterator end_externalReference (); + externalReference_const_iterator begin_externalReference () const; + externalReference_const_iterator end_externalReference () const; + void add_externalReference ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* externalReference_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalReference (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > > externalReference_; + + // deployedResource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > >::iterator deployedResource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > >::const_iterator deployedResource_const_iterator; + deployedResource_iterator begin_deployedResource (); + deployedResource_iterator end_deployedResource (); + deployedResource_const_iterator begin_deployedResource () const; + deployedResource_const_iterator end_deployedResource () const; + void add_deployedResource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* deployedResource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription, ACE_Null_Mutex > > deployedResource_; + + public: + PlanConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__); + + PlanConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanConnectionDescription (PlanConnectionDescription const& s); + + PlanConnectionDescription& + operator= (PlanConnectionDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ImplementationDependency : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ImplementationDependency, ACE_Null_Mutex > _ptr; + + // requiredType + // + public: + ::XMLSchema::string< ACE_TCHAR > const& requiredType () const; + void requiredType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requiredType_; + + public: + ImplementationDependency (::XMLSchema::string< ACE_TCHAR > const& requiredType__); + + ImplementationDependency (::XSCRT::XML::Element< ACE_TCHAR > const&); + ImplementationDependency (ImplementationDependency const& s); + + ImplementationDependency& + operator= (ImplementationDependency const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Capability : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Capability, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // resourceType + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator resourceType_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator resourceType_const_iterator; + resourceType_iterator begin_resourceType (); + resourceType_iterator end_resourceType (); + resourceType_const_iterator begin_resourceType () const; + resourceType_const_iterator end_resourceType () const; + void add_resourceType ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* resourceType_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_resourceType (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > resourceType_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SatisfierProperty, ACE_Null_Mutex > > property_; + + public: + Capability (::XMLSchema::string< ACE_TCHAR > const& name__); + + Capability (::XSCRT::XML::Element< ACE_TCHAR > const&); + Capability (Capability const& s); + + Capability& + operator= (Capability const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ImplementationRequirement : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ImplementationRequirement, ACE_Null_Mutex > _ptr; + + // resourceUsage + // + public: + bool resourceUsage_p () const; + ::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage () const; + void resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > resourceUsage_; + + // resourcePort + // + public: + bool resourcePort_p () const; + ::XMLSchema::string< ACE_TCHAR > const& resourcePort () const; + void resourcePort (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourcePort_; + + // componentPort + // + public: + bool componentPort_p () const; + ::XMLSchema::string< ACE_TCHAR > const& componentPort () const; + void componentPort (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > componentPort_; + + // resourceType + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceType () const; + void resourceType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceType_; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > property_; + + public: + ImplementationRequirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__); + + ImplementationRequirement (::XSCRT::XML::Element< ACE_TCHAR > const&); + ImplementationRequirement (ImplementationRequirement const& s); + + ImplementationRequirement& + operator= (ImplementationRequirement const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SubcomponentPortEndpoint : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SubcomponentPortEndpoint, ACE_Null_Mutex > _ptr; + + // portName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& portName () const; + void portName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > portName_; + + // instance + // + public: + ::CIAO::Config_Handlers::IdRef const& instance () const; + void instance (::CIAO::Config_Handlers::IdRef const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > instance_; + + public: + SubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::IdRef const& instance__); + + SubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const&); + SubcomponentPortEndpoint (SubcomponentPortEndpoint const& s); + + SubcomponentPortEndpoint& + operator= (SubcomponentPortEndpoint const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export AssemblyConnectionDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < AssemblyConnectionDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > deployRequirement_; + + // internalEndpoint + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > >::iterator internalEndpoint_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > >::const_iterator internalEndpoint_const_iterator; + internalEndpoint_iterator begin_internalEndpoint (); + internalEndpoint_iterator end_internalEndpoint (); + internalEndpoint_const_iterator begin_internalEndpoint () const; + internalEndpoint_const_iterator end_internalEndpoint () const; + void add_internalEndpoint ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* internalEndpoint_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_internalEndpoint (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPortEndpoint, ACE_Null_Mutex > > internalEndpoint_; + + // externalEndpoint + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > >::iterator externalEndpoint_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > >::const_iterator externalEndpoint_const_iterator; + externalEndpoint_iterator begin_externalEndpoint (); + externalEndpoint_iterator end_externalEndpoint (); + externalEndpoint_const_iterator begin_externalEndpoint () const; + externalEndpoint_const_iterator end_externalEndpoint () const; + void add_externalEndpoint ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* externalEndpoint_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalEndpoint (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentExternalPortEndpoint, ACE_Null_Mutex > > externalEndpoint_; + + // externalReference + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > >::iterator externalReference_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > >::const_iterator externalReference_const_iterator; + externalReference_iterator begin_externalReference (); + externalReference_iterator end_externalReference (); + externalReference_const_iterator begin_externalReference () const; + externalReference_const_iterator end_externalReference () const; + void add_externalReference ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > const& ); + XSCRT::Type* externalReference_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalReference (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ExternalReferenceEndpoint, ACE_Null_Mutex > > externalReference_; + + public: + AssemblyConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__); + + AssemblyConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + AssemblyConnectionDescription (AssemblyConnectionDescription const& s); + + AssemblyConnectionDescription& + operator= (AssemblyConnectionDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export PlanLocalityKind : public ::XSCRT::Type + { + public: + PlanLocalityKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanLocalityKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static PlanLocalityKind const SameProcess; + static PlanLocalityKind const DifferentProcess; + static PlanLocalityKind const NoConstraint; + + enum Value + { + SameProcess_l, DifferentProcess_l, NoConstraint_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (PlanLocalityKind const& a, PlanLocalityKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (PlanLocalityKind const& a, PlanLocalityKind const& b); + + private: + PlanLocalityKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (PlanLocalityKind const &a, PlanLocalityKind const &b); + + bool XSC_XML_Handlers_Export operator!= (PlanLocalityKind const &a, PlanLocalityKind const &b); + + + class XSC_XML_Handlers_Export PlanLocality : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PlanLocality, ACE_Null_Mutex > _ptr; + + // constraint + // + public: + ::CIAO::Config_Handlers::PlanLocalityKind const& constraint () const; + void constraint (::CIAO::Config_Handlers::PlanLocalityKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::PlanLocalityKind > constraint_; + + // constrainedInstance + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > >::iterator constrainedInstance_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > >::const_iterator constrainedInstance_const_iterator; + constrainedInstance_iterator begin_constrainedInstance (); + constrainedInstance_iterator end_constrainedInstance (); + constrainedInstance_const_iterator begin_constrainedInstance () const; + constrainedInstance_const_iterator end_constrainedInstance () const; + void add_constrainedInstance ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > const& ); + XSCRT::Type* constrainedInstance_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_constrainedInstance (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > > constrainedInstance_; + + public: + PlanLocality (::CIAO::Config_Handlers::PlanLocalityKind const& constraint__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::IdRef, ACE_Null_Mutex > > const& constrainedInstance__); + + PlanLocality (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanLocality (PlanLocality const& s); + + PlanLocality& + operator= (PlanLocality const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export IdRef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::IdRef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + idref (Type&); + + virtual void + idref (Type const&); + + virtual void + idref_none (Type&); + + virtual void + idref_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::TCKind > + TCKind; + + struct XSC_XML_Handlers_Export DataType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::DataType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + kind (Type&); + + virtual void + kind (Type const&); + + virtual void + enum_ (Type&); + + virtual void + enum_ (Type const&); + + virtual void + enum_none (Type&); + + virtual void + enum_none (Type const&); + + virtual void + struct_ (Type&); + + virtual void + struct_ (Type const&); + + virtual void + struct_none (Type&); + + virtual void + struct_none (Type const&); + + virtual void + value (Type&); + + virtual void + value (Type const&); + + virtual void + value_none (Type&); + + virtual void + value_none (Type const&); + + virtual void + sequence (Type&); + + virtual void + sequence (Type const&); + + virtual void + sequence_none (Type&); + + virtual void + sequence_none (Type const&); + + virtual void + alias (Type&); + + virtual void + alias (Type const&); + + virtual void + alias_none (Type&); + + virtual void + alias_none (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export DataValue : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::DataValue > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + short_ (Type&); + + virtual void + short_ (Type const&); + + virtual void + short_pre (Type&); + + virtual void + short_pre (Type const&); + + virtual void + short_next (Type&); + + virtual void + short_next (Type const&); + + virtual void + short_post (Type&); + + virtual void + short_post (Type const&); + + virtual void + short_none (Type&); + + virtual void + short_none (Type const&); + + virtual void + long_ (Type&); + + virtual void + long_ (Type const&); + + virtual void + long_pre (Type&); + + virtual void + long_pre (Type const&); + + virtual void + long_next (Type&); + + virtual void + long_next (Type const&); + + virtual void + long_post (Type&); + + virtual void + long_post (Type const&); + + virtual void + long_none (Type&); + + virtual void + long_none (Type const&); + + virtual void + ushort (Type&); + + virtual void + ushort (Type const&); + + virtual void + ushort_pre (Type&); + + virtual void + ushort_pre (Type const&); + + virtual void + ushort_next (Type&); + + virtual void + ushort_next (Type const&); + + virtual void + ushort_post (Type&); + + virtual void + ushort_post (Type const&); + + virtual void + ushort_none (Type&); + + virtual void + ushort_none (Type const&); + + virtual void + ulong (Type&); + + virtual void + ulong (Type const&); + + virtual void + ulong_pre (Type&); + + virtual void + ulong_pre (Type const&); + + virtual void + ulong_next (Type&); + + virtual void + ulong_next (Type const&); + + virtual void + ulong_post (Type&); + + virtual void + ulong_post (Type const&); + + virtual void + ulong_none (Type&); + + virtual void + ulong_none (Type const&); + + virtual void + float_ (Type&); + + virtual void + float_ (Type const&); + + virtual void + float_pre (Type&); + + virtual void + float_pre (Type const&); + + virtual void + float_next (Type&); + + virtual void + float_next (Type const&); + + virtual void + float_post (Type&); + + virtual void + float_post (Type const&); + + virtual void + float_none (Type&); + + virtual void + float_none (Type const&); + + virtual void + double_ (Type&); + + virtual void + double_ (Type const&); + + virtual void + double_pre (Type&); + + virtual void + double_pre (Type const&); + + virtual void + double_next (Type&); + + virtual void + double_next (Type const&); + + virtual void + double_post (Type&); + + virtual void + double_post (Type const&); + + virtual void + double_none (Type&); + + virtual void + double_none (Type const&); + + virtual void + boolean (Type&); + + virtual void + boolean (Type const&); + + virtual void + boolean_pre (Type&); + + virtual void + boolean_pre (Type const&); + + virtual void + boolean_next (Type&); + + virtual void + boolean_next (Type const&); + + virtual void + boolean_post (Type&); + + virtual void + boolean_post (Type const&); + + virtual void + boolean_none (Type&); + + virtual void + boolean_none (Type const&); + + virtual void + octet (Type&); + + virtual void + octet (Type const&); + + virtual void + octet_pre (Type&); + + virtual void + octet_pre (Type const&); + + virtual void + octet_next (Type&); + + virtual void + octet_next (Type const&); + + virtual void + octet_post (Type&); + + virtual void + octet_post (Type const&); + + virtual void + octet_none (Type&); + + virtual void + octet_none (Type const&); + + virtual void + enum_ (Type&); + + virtual void + enum_ (Type const&); + + virtual void + enum_pre (Type&); + + virtual void + enum_pre (Type const&); + + virtual void + enum_next (Type&); + + virtual void + enum_next (Type const&); + + virtual void + enum_post (Type&); + + virtual void + enum_post (Type const&); + + virtual void + enum_none (Type&); + + virtual void + enum_none (Type const&); + + virtual void + string (Type&); + + virtual void + string (Type const&); + + virtual void + string_pre (Type&); + + virtual void + string_pre (Type const&); + + virtual void + string_next (Type&); + + virtual void + string_next (Type const&); + + virtual void + string_post (Type&); + + virtual void + string_post (Type const&); + + virtual void + string_none (Type&); + + virtual void + string_none (Type const&); + + virtual void + longlong (Type&); + + virtual void + longlong (Type const&); + + virtual void + longlong_pre (Type&); + + virtual void + longlong_pre (Type const&); + + virtual void + longlong_next (Type&); + + virtual void + longlong_next (Type const&); + + virtual void + longlong_post (Type&); + + virtual void + longlong_post (Type const&); + + virtual void + longlong_none (Type&); + + virtual void + longlong_none (Type const&); + + virtual void + ulonglong (Type&); + + virtual void + ulonglong (Type const&); + + virtual void + ulonglong_pre (Type&); + + virtual void + ulonglong_pre (Type const&); + + virtual void + ulonglong_next (Type&); + + virtual void + ulonglong_next (Type const&); + + virtual void + ulonglong_post (Type&); + + virtual void + ulonglong_post (Type const&); + + virtual void + ulonglong_none (Type&); + + virtual void + ulonglong_none (Type const&); + + virtual void + longdouble (Type&); + + virtual void + longdouble (Type const&); + + virtual void + longdouble_pre (Type&); + + virtual void + longdouble_pre (Type const&); + + virtual void + longdouble_next (Type&); + + virtual void + longdouble_next (Type const&); + + virtual void + longdouble_post (Type&); + + virtual void + longdouble_post (Type const&); + + virtual void + longdouble_none (Type&); + + virtual void + longdouble_none (Type const&); + + virtual void + element (Type&); + + virtual void + element (Type const&); + + virtual void + element_pre (Type&); + + virtual void + element_pre (Type const&); + + virtual void + element_next (Type&); + + virtual void + element_next (Type const&); + + virtual void + element_post (Type&); + + virtual void + element_post (Type const&); + + virtual void + element_none (Type&); + + virtual void + element_none (Type const&); + + virtual void + member (Type&); + + virtual void + member (Type const&); + + virtual void + member_pre (Type&); + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type&); + + virtual void + member_next (Type const&); + + virtual void + member_post (Type&); + + virtual void + member_post (Type const&); + + virtual void + member_none (Type&); + + virtual void + member_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export AliasType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::AliasType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + typeId (Type&); + + virtual void + typeId (Type const&); + + virtual void + elementType (Type&); + + virtual void + elementType (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export EnumType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::EnumType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + typeId (Type&); + + virtual void + typeId (Type const&); + + virtual void + member (Type&); + + virtual void + member (Type const&); + + virtual void + member_pre (Type&); + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type&); + + virtual void + member_next (Type const&); + + virtual void + member_post (Type&); + + virtual void + member_post (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export StructType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::StructType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + typeId (Type&); + + virtual void + typeId (Type const&); + + virtual void + member (Type&); + + virtual void + member (Type const&); + + virtual void + member_pre (Type&); + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type&); + + virtual void + member_next (Type const&); + + virtual void + member_post (Type&); + + virtual void + member_post (Type const&); + + virtual void + member_none (Type&); + + virtual void + member_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export StructMemberType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::StructMemberType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + type (Type&); + + virtual void + type (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ValueType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ValueType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + typeId (Type&); + + virtual void + typeId (Type const&); + + virtual void + modifier (Type&); + + virtual void + modifier (Type const&); + + virtual void + baseType (Type&); + + virtual void + baseType (Type const&); + + virtual void + member (Type&); + + virtual void + member (Type const&); + + virtual void + member_pre (Type&); + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type&); + + virtual void + member_next (Type const&); + + virtual void + member_post (Type&); + + virtual void + member_post (Type const&); + + virtual void + member_none (Type&); + + virtual void + member_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ValueMemberType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ValueMemberType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + visibility (Type&); + + virtual void + visibility (Type const&); + + virtual void + type (Type&); + + virtual void + type (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export NamedValue : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::NamedValue > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + value (Type&); + + virtual void + value (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export SequenceType : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SequenceType > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + bound (Type&); + + virtual void + bound (Type const&); + + virtual void + bound_none (Type&); + + virtual void + bound_none (Type const&); + + virtual void + elementType (Type&); + + virtual void + elementType (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Any : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Any > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + type (Type&); + + virtual void + type (Type const&); + + virtual void + value (Type&); + + virtual void + value (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Property : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Property > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + value (Type&); + + virtual void + value (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SatisfierPropertyKind > + SatisfierPropertyKind; + + struct XSC_XML_Handlers_Export SatisfierProperty : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SatisfierProperty > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + kind (Type&); + + virtual void + kind (Type const&); + + virtual void + dynamic (Type&); + + virtual void + dynamic (Type const&); + + virtual void + value (Type&); + + virtual void + value (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Resource : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Resource > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + resourceType (Type&); + + virtual void + resourceType (Type const&); + + virtual void + resourceType_pre (Type&); + + virtual void + resourceType_pre (Type const&); + + virtual void + resourceType_next (Type&); + + virtual void + resourceType_next (Type const&); + + virtual void + resourceType_post (Type&); + + virtual void + resourceType_post (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Requirement : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Requirement > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + resourceType (Type&); + + virtual void + resourceType (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ResourceDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ResourceDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + requirementName (Type&); + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type&); + + virtual void + resourceName (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ArtifactDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ArtifactDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + source (Type&); + + virtual void + source (Type const&); + + virtual void + source_pre (Type&); + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type&); + + virtual void + source_next (Type const&); + + virtual void + source_post (Type&); + + virtual void + source_post (Type const&); + + virtual void + source_none (Type&); + + virtual void + source_none (Type const&); + + virtual void + node (Type&); + + virtual void + node (Type const&); + + virtual void + location (Type&); + + virtual void + location (Type const&); + + virtual void + location_pre (Type&); + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type&); + + virtual void + location_next (Type const&); + + virtual void + location_post (Type&); + + virtual void + location_post (Type const&); + + virtual void + location_none (Type&); + + virtual void + location_none (Type const&); + + virtual void + execParameter (Type&); + + virtual void + execParameter (Type const&); + + virtual void + execParameter_pre (Type&); + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type&); + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type&); + + virtual void + execParameter_post (Type const&); + + virtual void + execParameter_none (Type&); + + virtual void + execParameter_none (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + deployedResource (Type&); + + virtual void + deployedResource (Type const&); + + virtual void + deployedResource_pre (Type&); + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type&); + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type&); + + virtual void + deployedResource_post (Type const&); + + virtual void + deployedResource_none (Type&); + + virtual void + deployedResource_none (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export MonolithicDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::MonolithicDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + source (Type&); + + virtual void + source (Type const&); + + virtual void + source_pre (Type&); + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type&); + + virtual void + source_next (Type const&); + + virtual void + source_post (Type&); + + virtual void + source_post (Type const&); + + virtual void + source_none (Type&); + + virtual void + source_none (Type const&); + + virtual void + artifact (Type&); + + virtual void + artifact (Type const&); + + virtual void + artifact_pre (Type&); + + virtual void + artifact_pre (Type const&); + + virtual void + artifact_next (Type&); + + virtual void + artifact_next (Type const&); + + virtual void + artifact_post (Type&); + + virtual void + artifact_post (Type const&); + + virtual void + artifact_none (Type&); + + virtual void + artifact_none (Type const&); + + virtual void + execParameter (Type&); + + virtual void + execParameter (Type const&); + + virtual void + execParameter_pre (Type&); + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type&); + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type&); + + virtual void + execParameter_post (Type const&); + + virtual void + execParameter_none (Type&); + + virtual void + execParameter_none (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ResourceUsageKind > + ResourceUsageKind; + + struct XSC_XML_Handlers_Export InstanceResourceDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + resourceUsage (Type&); + + virtual void + resourceUsage (Type const&); + + virtual void + requirementName (Type&); + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type&); + + virtual void + resourceName (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export InstanceDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::InstanceDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + node (Type&); + + virtual void + node (Type const&); + + virtual void + source (Type&); + + virtual void + source (Type const&); + + virtual void + implementation (Type&); + + virtual void + implementation (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + deployedResource (Type&); + + virtual void + deployedResource (Type const&); + + virtual void + deployedResource_pre (Type&); + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type&); + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type&); + + virtual void + deployedResource_post (Type const&); + + virtual void + deployedResource_none (Type&); + + virtual void + deployedResource_none (Type const&); + + virtual void + deployedSharedResource (Type&); + + virtual void + deployedSharedResource (Type const&); + + virtual void + deployedSharedResource_none (Type&); + + virtual void + deployedSharedResource_none (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::CCMComponentPortKind > + CCMComponentPortKind; + + struct XSC_XML_Handlers_Export ComponentPortDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentPortDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + specificType (Type&); + + virtual void + specificType (Type const&); + + virtual void + specificType_none (Type&); + + virtual void + specificType_none (Type const&); + + virtual void + supportedType (Type&); + + virtual void + supportedType (Type const&); + + virtual void + supportedType_pre (Type&); + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type&); + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type&); + + virtual void + supportedType_post (Type const&); + + virtual void + supportedType_none (Type&); + + virtual void + supportedType_none (Type const&); + + virtual void + provider (Type&); + + virtual void + provider (Type const&); + + virtual void + exclusiveProvider (Type&); + + virtual void + exclusiveProvider (Type const&); + + virtual void + exclusiveUser (Type&); + + virtual void + exclusiveUser (Type const&); + + virtual void + optional (Type&); + + virtual void + optional (Type const&); + + virtual void + kind (Type&); + + virtual void + kind (Type const&); + + virtual void + templateParam (Type&); + + virtual void + templateParam (Type const&); + + virtual void + templateParam_pre (Type&); + + virtual void + templateParam_pre (Type const&); + + virtual void + templateParam_next (Type&); + + virtual void + templateParam_next (Type const&); + + virtual void + templateParam_post (Type&); + + virtual void + templateParam_post (Type const&); + + virtual void + templateParam_none (Type&); + + virtual void + templateParam_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ComponentPropertyDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentPropertyDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + type (Type&); + + virtual void + type (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ComponentExternalPortEndpoint : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + portName (Type&); + + virtual void + portName (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export PlanSubcomponentPortEndpoint : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + portName (Type&); + + virtual void + portName (Type const&); + + virtual void + provider (Type&); + + virtual void + provider (Type const&); + + virtual void + provider_none (Type&); + + virtual void + provider_none (Type const&); + + virtual void + kind (Type&); + + virtual void + kind (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ExternalReferenceEndpoint : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + location (Type&); + + virtual void + location (Type const&); + + virtual void + provider (Type&); + + virtual void + provider (Type const&); + + virtual void + portName (Type&); + + virtual void + portName (Type const&); + + virtual void + portName_none (Type&); + + virtual void + portName_none (Type const&); + + virtual void + supportedType (Type&); + + virtual void + supportedType (Type const&); + + virtual void + supportedType_pre (Type&); + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type&); + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type&); + + virtual void + supportedType_post (Type const&); + + virtual void + supportedType_none (Type&); + + virtual void + supportedType_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ConnectionResourceDeploymentDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + targetName (Type&); + + virtual void + targetName (Type const&); + + virtual void + requirementName (Type&); + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type&); + + virtual void + resourceName (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export PlanConnectionDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanConnectionDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + source (Type&); + + virtual void + source (Type const&); + + virtual void + source_none (Type&); + + virtual void + source_none (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + externalEndpoint (Type&); + + virtual void + externalEndpoint (Type const&); + + virtual void + externalEndpoint_pre (Type&); + + virtual void + externalEndpoint_pre (Type const&); + + virtual void + externalEndpoint_next (Type&); + + virtual void + externalEndpoint_next (Type const&); + + virtual void + externalEndpoint_post (Type&); + + virtual void + externalEndpoint_post (Type const&); + + virtual void + externalEndpoint_none (Type&); + + virtual void + externalEndpoint_none (Type const&); + + virtual void + internalEndpoint (Type&); + + virtual void + internalEndpoint (Type const&); + + virtual void + internalEndpoint_pre (Type&); + + virtual void + internalEndpoint_pre (Type const&); + + virtual void + internalEndpoint_next (Type&); + + virtual void + internalEndpoint_next (Type const&); + + virtual void + internalEndpoint_post (Type&); + + virtual void + internalEndpoint_post (Type const&); + + virtual void + internalEndpoint_none (Type&); + + virtual void + internalEndpoint_none (Type const&); + + virtual void + externalReference (Type&); + + virtual void + externalReference (Type const&); + + virtual void + externalReference_pre (Type&); + + virtual void + externalReference_pre (Type const&); + + virtual void + externalReference_next (Type&); + + virtual void + externalReference_next (Type const&); + + virtual void + externalReference_post (Type&); + + virtual void + externalReference_post (Type const&); + + virtual void + externalReference_none (Type&); + + virtual void + externalReference_none (Type const&); + + virtual void + deployedResource (Type&); + + virtual void + deployedResource (Type const&); + + virtual void + deployedResource_pre (Type&); + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type&); + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type&); + + virtual void + deployedResource_post (Type const&); + + virtual void + deployedResource_none (Type&); + + virtual void + deployedResource_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ImplementationDependency : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ImplementationDependency > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + requiredType (Type&); + + virtual void + requiredType (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Capability : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Capability > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + resourceType (Type&); + + virtual void + resourceType (Type const&); + + virtual void + resourceType_pre (Type&); + + virtual void + resourceType_pre (Type const&); + + virtual void + resourceType_next (Type&); + + virtual void + resourceType_next (Type const&); + + virtual void + resourceType_post (Type&); + + virtual void + resourceType_post (Type const&); + + virtual void + resourceType_none (Type&); + + virtual void + resourceType_none (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ImplementationRequirement : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ImplementationRequirement > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + resourceUsage (Type&); + + virtual void + resourceUsage (Type const&); + + virtual void + resourceUsage_none (Type&); + + virtual void + resourceUsage_none (Type const&); + + virtual void + resourcePort (Type&); + + virtual void + resourcePort (Type const&); + + virtual void + resourcePort_none (Type&); + + virtual void + resourcePort_none (Type const&); + + virtual void + componentPort (Type&); + + virtual void + componentPort (Type const&); + + virtual void + componentPort_none (Type&); + + virtual void + componentPort_none (Type const&); + + virtual void + resourceType (Type&); + + virtual void + resourceType (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export SubcomponentPortEndpoint : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SubcomponentPortEndpoint > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + portName (Type&); + + virtual void + portName (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export AssemblyConnectionDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::AssemblyConnectionDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + internalEndpoint (Type&); + + virtual void + internalEndpoint (Type const&); + + virtual void + internalEndpoint_pre (Type&); + + virtual void + internalEndpoint_pre (Type const&); + + virtual void + internalEndpoint_next (Type&); + + virtual void + internalEndpoint_next (Type const&); + + virtual void + internalEndpoint_post (Type&); + + virtual void + internalEndpoint_post (Type const&); + + virtual void + internalEndpoint_none (Type&); + + virtual void + internalEndpoint_none (Type const&); + + virtual void + externalEndpoint (Type&); + + virtual void + externalEndpoint (Type const&); + + virtual void + externalEndpoint_pre (Type&); + + virtual void + externalEndpoint_pre (Type const&); + + virtual void + externalEndpoint_next (Type&); + + virtual void + externalEndpoint_next (Type const&); + + virtual void + externalEndpoint_post (Type&); + + virtual void + externalEndpoint_post (Type const&); + + virtual void + externalEndpoint_none (Type&); + + virtual void + externalEndpoint_none (Type const&); + + virtual void + externalReference (Type&); + + virtual void + externalReference (Type const&); + + virtual void + externalReference_pre (Type&); + + virtual void + externalReference_pre (Type const&); + + virtual void + externalReference_next (Type&); + + virtual void + externalReference_next (Type const&); + + virtual void + externalReference_post (Type&); + + virtual void + externalReference_post (Type const&); + + virtual void + externalReference_none (Type&); + + virtual void + externalReference_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanLocalityKind > + PlanLocalityKind; + + struct XSC_XML_Handlers_Export PlanLocality : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanLocality > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + constraint (Type&); + + virtual void + constraint (Type const&); + + virtual void + constrainedInstance (Type&); + + virtual void + constrainedInstance (Type const&); + + virtual void + constrainedInstance_pre (Type&); + + virtual void + constrainedInstance_pre (Type const&); + + virtual void + constrainedInstance_next (Type&); + + virtual void + constrainedInstance_next (Type const&); + + virtual void + constrainedInstance_post (Type&); + + virtual void + constrainedInstance_post (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct IdRef : Traversal::IdRef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::IdRef Type; + IdRef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + virtual void + idref (Type &o) + { + this->idref (const_cast <Type const &> (o)); + } + + virtual void + idref (Type const&); + + protected: + IdRef (); + }; + + struct TCKind : Traversal::TCKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + TCKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + TCKind (); + }; + + struct DataType : Traversal::DataType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::DataType Type; + DataType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + kind (Type &o) + { + this->kind (const_cast <Type const &> (o)); + } + + virtual void + kind (Type const&); + + virtual void + enum_ (Type &o) + { + this->enum_ (const_cast <Type const &> (o)); + } + + virtual void + enum_ (Type const&); + + virtual void + struct_ (Type &o) + { + this->struct_ (const_cast <Type const &> (o)); + } + + virtual void + struct_ (Type const&); + + virtual void + value (Type &o) + { + this->value (const_cast <Type const &> (o)); + } + + virtual void + value (Type const&); + + virtual void + sequence (Type &o) + { + this->sequence (const_cast <Type const &> (o)); + } + + virtual void + sequence (Type const&); + + virtual void + alias (Type &o) + { + this->alias (const_cast <Type const &> (o)); + } + + virtual void + alias (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + protected: + DataType (); + }; + + struct DataValue : Traversal::DataValue, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::DataValue Type; + DataValue (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + short_pre (Type &o) + { + this->short_pre (const_cast <Type const &> (o)); + } + + virtual void + short_pre (Type const&); + + virtual void + short_next (Type &o) + { + this->short_next (const_cast <Type const &> (o)); + } + + virtual void + short_next (Type const&); + + virtual void + short_post (Type &o) + { + this->short_post (const_cast <Type const &> (o)); + } + + virtual void + short_post (Type const&); + + virtual void + long_pre (Type &o) + { + this->long_pre (const_cast <Type const &> (o)); + } + + virtual void + long_pre (Type const&); + + virtual void + long_next (Type &o) + { + this->long_next (const_cast <Type const &> (o)); + } + + virtual void + long_next (Type const&); + + virtual void + long_post (Type &o) + { + this->long_post (const_cast <Type const &> (o)); + } + + virtual void + long_post (Type const&); + + virtual void + ushort_pre (Type &o) + { + this->ushort_pre (const_cast <Type const &> (o)); + } + + virtual void + ushort_pre (Type const&); + + virtual void + ushort_next (Type &o) + { + this->ushort_next (const_cast <Type const &> (o)); + } + + virtual void + ushort_next (Type const&); + + virtual void + ushort_post (Type &o) + { + this->ushort_post (const_cast <Type const &> (o)); + } + + virtual void + ushort_post (Type const&); + + virtual void + ulong_pre (Type &o) + { + this->ulong_pre (const_cast <Type const &> (o)); + } + + virtual void + ulong_pre (Type const&); + + virtual void + ulong_next (Type &o) + { + this->ulong_next (const_cast <Type const &> (o)); + } + + virtual void + ulong_next (Type const&); + + virtual void + ulong_post (Type &o) + { + this->ulong_post (const_cast <Type const &> (o)); + } + + virtual void + ulong_post (Type const&); + + virtual void + float_pre (Type &o) + { + this->float_pre (const_cast <Type const &> (o)); + } + + virtual void + float_pre (Type const&); + + virtual void + float_next (Type &o) + { + this->float_next (const_cast <Type const &> (o)); + } + + virtual void + float_next (Type const&); + + virtual void + float_post (Type &o) + { + this->float_post (const_cast <Type const &> (o)); + } + + virtual void + float_post (Type const&); + + virtual void + double_pre (Type &o) + { + this->double_pre (const_cast <Type const &> (o)); + } + + virtual void + double_pre (Type const&); + + virtual void + double_next (Type &o) + { + this->double_next (const_cast <Type const &> (o)); + } + + virtual void + double_next (Type const&); + + virtual void + double_post (Type &o) + { + this->double_post (const_cast <Type const &> (o)); + } + + virtual void + double_post (Type const&); + + virtual void + boolean_pre (Type &o) + { + this->boolean_pre (const_cast <Type const &> (o)); + } + + virtual void + boolean_pre (Type const&); + + virtual void + boolean_next (Type &o) + { + this->boolean_next (const_cast <Type const &> (o)); + } + + virtual void + boolean_next (Type const&); + + virtual void + boolean_post (Type &o) + { + this->boolean_post (const_cast <Type const &> (o)); + } + + virtual void + boolean_post (Type const&); + + virtual void + octet_pre (Type &o) + { + this->octet_pre (const_cast <Type const &> (o)); + } + + virtual void + octet_pre (Type const&); + + virtual void + octet_next (Type &o) + { + this->octet_next (const_cast <Type const &> (o)); + } + + virtual void + octet_next (Type const&); + + virtual void + octet_post (Type &o) + { + this->octet_post (const_cast <Type const &> (o)); + } + + virtual void + octet_post (Type const&); + + virtual void + enum_pre (Type &o) + { + this->enum_pre (const_cast <Type const &> (o)); + } + + virtual void + enum_pre (Type const&); + + virtual void + enum_next (Type &o) + { + this->enum_next (const_cast <Type const &> (o)); + } + + virtual void + enum_next (Type const&); + + virtual void + enum_post (Type &o) + { + this->enum_post (const_cast <Type const &> (o)); + } + + virtual void + enum_post (Type const&); + + virtual void + string_pre (Type &o) + { + this->string_pre (const_cast <Type const &> (o)); + } + + virtual void + string_pre (Type const&); + + virtual void + string_next (Type &o) + { + this->string_next (const_cast <Type const &> (o)); + } + + virtual void + string_next (Type const&); + + virtual void + string_post (Type &o) + { + this->string_post (const_cast <Type const &> (o)); + } + + virtual void + string_post (Type const&); + + virtual void + longlong_pre (Type &o) + { + this->longlong_pre (const_cast <Type const &> (o)); + } + + virtual void + longlong_pre (Type const&); + + virtual void + longlong_next (Type &o) + { + this->longlong_next (const_cast <Type const &> (o)); + } + + virtual void + longlong_next (Type const&); + + virtual void + longlong_post (Type &o) + { + this->longlong_post (const_cast <Type const &> (o)); + } + + virtual void + longlong_post (Type const&); + + virtual void + ulonglong_pre (Type &o) + { + this->ulonglong_pre (const_cast <Type const &> (o)); + } + + virtual void + ulonglong_pre (Type const&); + + virtual void + ulonglong_next (Type &o) + { + this->ulonglong_next (const_cast <Type const &> (o)); + } + + virtual void + ulonglong_next (Type const&); + + virtual void + ulonglong_post (Type &o) + { + this->ulonglong_post (const_cast <Type const &> (o)); + } + + virtual void + ulonglong_post (Type const&); + + virtual void + longdouble_pre (Type &o) + { + this->longdouble_pre (const_cast <Type const &> (o)); + } + + virtual void + longdouble_pre (Type const&); + + virtual void + longdouble_next (Type &o) + { + this->longdouble_next (const_cast <Type const &> (o)); + } + + virtual void + longdouble_next (Type const&); + + virtual void + longdouble_post (Type &o) + { + this->longdouble_post (const_cast <Type const &> (o)); + } + + virtual void + longdouble_post (Type const&); + + virtual void + element_pre (Type &o) + { + this->element_pre (const_cast <Type const &> (o)); + } + + virtual void + element_pre (Type const&); + + virtual void + element_next (Type &o) + { + this->element_next (const_cast <Type const &> (o)); + } + + virtual void + element_next (Type const&); + + virtual void + element_post (Type &o) + { + this->element_post (const_cast <Type const &> (o)); + } + + virtual void + element_post (Type const&); + + virtual void + member_pre (Type &o) + { + this->member_pre (const_cast <Type const &> (o)); + } + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type &o) + { + this->member_next (const_cast <Type const &> (o)); + } + + virtual void + member_next (Type const&); + + virtual void + member_post (Type &o) + { + this->member_post (const_cast <Type const &> (o)); + } + + virtual void + member_post (Type const&); + + protected: + DataValue (); + }; + + struct AliasType : Traversal::AliasType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::AliasType Type; + AliasType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + typeId (Type &o) + { + this->typeId (const_cast <Type const &> (o)); + } + + virtual void + typeId (Type const&); + + virtual void + elementType (Type &o) + { + this->elementType (const_cast <Type const &> (o)); + } + + virtual void + elementType (Type const&); + + protected: + AliasType (); + }; + + struct EnumType : Traversal::EnumType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::EnumType Type; + EnumType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + typeId (Type &o) + { + this->typeId (const_cast <Type const &> (o)); + } + + virtual void + typeId (Type const&); + + virtual void + member_pre (Type &o) + { + this->member_pre (const_cast <Type const &> (o)); + } + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type &o) + { + this->member_next (const_cast <Type const &> (o)); + } + + virtual void + member_next (Type const&); + + virtual void + member_post (Type &o) + { + this->member_post (const_cast <Type const &> (o)); + } + + virtual void + member_post (Type const&); + + protected: + EnumType (); + }; + + struct StructType : Traversal::StructType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::StructType Type; + StructType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + typeId (Type &o) + { + this->typeId (const_cast <Type const &> (o)); + } + + virtual void + typeId (Type const&); + + virtual void + member_pre (Type &o) + { + this->member_pre (const_cast <Type const &> (o)); + } + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type &o) + { + this->member_next (const_cast <Type const &> (o)); + } + + virtual void + member_next (Type const&); + + virtual void + member_post (Type &o) + { + this->member_post (const_cast <Type const &> (o)); + } + + virtual void + member_post (Type const&); + + protected: + StructType (); + }; + + struct StructMemberType : Traversal::StructMemberType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::StructMemberType Type; + StructMemberType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + type (Type &o) + { + this->type (const_cast <Type const &> (o)); + } + + virtual void + type (Type const&); + + protected: + StructMemberType (); + }; + + struct ValueType : Traversal::ValueType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ValueType Type; + ValueType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + typeId (Type &o) + { + this->typeId (const_cast <Type const &> (o)); + } + + virtual void + typeId (Type const&); + + virtual void + modifier (Type &o) + { + this->modifier (const_cast <Type const &> (o)); + } + + virtual void + modifier (Type const&); + + virtual void + baseType (Type &o) + { + this->baseType (const_cast <Type const &> (o)); + } + + virtual void + baseType (Type const&); + + virtual void + member_pre (Type &o) + { + this->member_pre (const_cast <Type const &> (o)); + } + + virtual void + member_pre (Type const&); + + virtual void + member_next (Type &o) + { + this->member_next (const_cast <Type const &> (o)); + } + + virtual void + member_next (Type const&); + + virtual void + member_post (Type &o) + { + this->member_post (const_cast <Type const &> (o)); + } + + virtual void + member_post (Type const&); + + protected: + ValueType (); + }; + + struct ValueMemberType : Traversal::ValueMemberType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ValueMemberType Type; + ValueMemberType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + visibility (Type &o) + { + this->visibility (const_cast <Type const &> (o)); + } + + virtual void + visibility (Type const&); + + virtual void + type (Type &o) + { + this->type (const_cast <Type const &> (o)); + } + + virtual void + type (Type const&); + + protected: + ValueMemberType (); + }; + + struct NamedValue : Traversal::NamedValue, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::NamedValue Type; + NamedValue (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + value (Type &o) + { + this->value (const_cast <Type const &> (o)); + } + + virtual void + value (Type const&); + + protected: + NamedValue (); + }; + + struct SequenceType : Traversal::SequenceType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SequenceType Type; + SequenceType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + bound (Type &o) + { + this->bound (const_cast <Type const &> (o)); + } + + virtual void + bound (Type const&); + + virtual void + elementType (Type &o) + { + this->elementType (const_cast <Type const &> (o)); + } + + virtual void + elementType (Type const&); + + protected: + SequenceType (); + }; + + struct Any : Traversal::Any, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Any Type; + Any (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + type (Type &o) + { + this->type (const_cast <Type const &> (o)); + } + + virtual void + type (Type const&); + + virtual void + value (Type &o) + { + this->value (const_cast <Type const &> (o)); + } + + virtual void + value (Type const&); + + protected: + Any (); + }; + + struct Property : Traversal::Property, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Property Type; + Property (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + value (Type &o) + { + this->value (const_cast <Type const &> (o)); + } + + virtual void + value (Type const&); + + protected: + Property (); + }; + + struct SatisfierPropertyKind : Traversal::SatisfierPropertyKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + SatisfierPropertyKind (); + }; + + struct SatisfierProperty : Traversal::SatisfierProperty, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SatisfierProperty Type; + SatisfierProperty (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + kind (Type &o) + { + this->kind (const_cast <Type const &> (o)); + } + + virtual void + kind (Type const&); + + virtual void + dynamic (Type &o) + { + this->dynamic (const_cast <Type const &> (o)); + } + + virtual void + dynamic (Type const&); + + virtual void + value (Type &o) + { + this->value (const_cast <Type const &> (o)); + } + + virtual void + value (Type const&); + + protected: + SatisfierProperty (); + }; + + struct Resource : Traversal::Resource, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Resource Type; + Resource (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + resourceType_pre (Type &o) + { + this->resourceType_pre (const_cast <Type const &> (o)); + } + + virtual void + resourceType_pre (Type const&); + + virtual void + resourceType_next (Type &o) + { + this->resourceType_next (const_cast <Type const &> (o)); + } + + virtual void + resourceType_next (Type const&); + + virtual void + resourceType_post (Type &o) + { + this->resourceType_post (const_cast <Type const &> (o)); + } + + virtual void + resourceType_post (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + Resource (); + }; + + struct Requirement : Traversal::Requirement, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Requirement Type; + Requirement (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + resourceType (Type &o) + { + this->resourceType (const_cast <Type const &> (o)); + } + + virtual void + resourceType (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + Requirement (); + }; + + struct ResourceDeploymentDescription : Traversal::ResourceDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ResourceDeploymentDescription Type; + ResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + requirementName (Type &o) + { + this->requirementName (const_cast <Type const &> (o)); + } + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type &o) + { + this->resourceName (const_cast <Type const &> (o)); + } + + virtual void + resourceName (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + ResourceDeploymentDescription (); + }; + + struct ArtifactDeploymentDescription : Traversal::ArtifactDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ArtifactDeploymentDescription Type; + ArtifactDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + source_pre (Type &o) + { + this->source_pre (const_cast <Type const &> (o)); + } + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type &o) + { + this->source_next (const_cast <Type const &> (o)); + } + + virtual void + source_next (Type const&); + + virtual void + source_post (Type &o) + { + this->source_post (const_cast <Type const &> (o)); + } + + virtual void + source_post (Type const&); + + virtual void + node (Type &o) + { + this->node (const_cast <Type const &> (o)); + } + + virtual void + node (Type const&); + + virtual void + location_pre (Type &o) + { + this->location_pre (const_cast <Type const &> (o)); + } + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type &o) + { + this->location_next (const_cast <Type const &> (o)); + } + + virtual void + location_next (Type const&); + + virtual void + location_post (Type &o) + { + this->location_post (const_cast <Type const &> (o)); + } + + virtual void + location_post (Type const&); + + virtual void + execParameter_pre (Type &o) + { + this->execParameter_pre (const_cast <Type const &> (o)); + } + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type &o) + { + this->execParameter_next (const_cast <Type const &> (o)); + } + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type &o) + { + this->execParameter_post (const_cast <Type const &> (o)); + } + + virtual void + execParameter_post (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployedResource_pre (Type &o) + { + this->deployedResource_pre (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type &o) + { + this->deployedResource_next (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type &o) + { + this->deployedResource_post (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_post (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + protected: + ArtifactDeploymentDescription (); + }; + + struct MonolithicDeploymentDescription : Traversal::MonolithicDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::MonolithicDeploymentDescription Type; + MonolithicDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + source_pre (Type &o) + { + this->source_pre (const_cast <Type const &> (o)); + } + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type &o) + { + this->source_next (const_cast <Type const &> (o)); + } + + virtual void + source_next (Type const&); + + virtual void + source_post (Type &o) + { + this->source_post (const_cast <Type const &> (o)); + } + + virtual void + source_post (Type const&); + + virtual void + artifact_pre (Type &o) + { + this->artifact_pre (const_cast <Type const &> (o)); + } + + virtual void + artifact_pre (Type const&); + + virtual void + artifact_next (Type &o) + { + this->artifact_next (const_cast <Type const &> (o)); + } + + virtual void + artifact_next (Type const&); + + virtual void + artifact_post (Type &o) + { + this->artifact_post (const_cast <Type const &> (o)); + } + + virtual void + artifact_post (Type const&); + + virtual void + execParameter_pre (Type &o) + { + this->execParameter_pre (const_cast <Type const &> (o)); + } + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type &o) + { + this->execParameter_next (const_cast <Type const &> (o)); + } + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type &o) + { + this->execParameter_post (const_cast <Type const &> (o)); + } + + virtual void + execParameter_post (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + protected: + MonolithicDeploymentDescription (); + }; + + struct ResourceUsageKind : Traversal::ResourceUsageKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + ResourceUsageKind (); + }; + + struct InstanceResourceDeploymentDescription : Traversal::InstanceResourceDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription Type; + InstanceResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + resourceUsage (Type &o) + { + this->resourceUsage (const_cast <Type const &> (o)); + } + + virtual void + resourceUsage (Type const&); + + virtual void + requirementName (Type &o) + { + this->requirementName (const_cast <Type const &> (o)); + } + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type &o) + { + this->resourceName (const_cast <Type const &> (o)); + } + + virtual void + resourceName (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + InstanceResourceDeploymentDescription (); + }; + + struct InstanceDeploymentDescription : Traversal::InstanceDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::InstanceDeploymentDescription Type; + InstanceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + node (Type &o) + { + this->node (const_cast <Type const &> (o)); + } + + virtual void + node (Type const&); + + virtual void + source (Type &o) + { + this->source (const_cast <Type const &> (o)); + } + + virtual void + source (Type const&); + + virtual void + implementation (Type &o) + { + this->implementation (const_cast <Type const &> (o)); + } + + virtual void + implementation (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + deployedResource_pre (Type &o) + { + this->deployedResource_pre (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type &o) + { + this->deployedResource_next (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type &o) + { + this->deployedResource_post (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_post (Type const&); + + virtual void + deployedSharedResource (Type &o) + { + this->deployedSharedResource (const_cast <Type const &> (o)); + } + + virtual void + deployedSharedResource (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + protected: + InstanceDeploymentDescription (); + }; + + struct CCMComponentPortKind : Traversal::CCMComponentPortKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + CCMComponentPortKind (); + }; + + struct ComponentPortDescription : Traversal::ComponentPortDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentPortDescription Type; + ComponentPortDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + specificType (Type &o) + { + this->specificType (const_cast <Type const &> (o)); + } + + virtual void + specificType (Type const&); + + virtual void + supportedType_pre (Type &o) + { + this->supportedType_pre (const_cast <Type const &> (o)); + } + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type &o) + { + this->supportedType_next (const_cast <Type const &> (o)); + } + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type &o) + { + this->supportedType_post (const_cast <Type const &> (o)); + } + + virtual void + supportedType_post (Type const&); + + virtual void + provider (Type &o) + { + this->provider (const_cast <Type const &> (o)); + } + + virtual void + provider (Type const&); + + virtual void + exclusiveProvider (Type &o) + { + this->exclusiveProvider (const_cast <Type const &> (o)); + } + + virtual void + exclusiveProvider (Type const&); + + virtual void + exclusiveUser (Type &o) + { + this->exclusiveUser (const_cast <Type const &> (o)); + } + + virtual void + exclusiveUser (Type const&); + + virtual void + optional (Type &o) + { + this->optional (const_cast <Type const &> (o)); + } + + virtual void + optional (Type const&); + + virtual void + kind (Type &o) + { + this->kind (const_cast <Type const &> (o)); + } + + virtual void + kind (Type const&); + + virtual void + templateParam_pre (Type &o) + { + this->templateParam_pre (const_cast <Type const &> (o)); + } + + virtual void + templateParam_pre (Type const&); + + virtual void + templateParam_next (Type &o) + { + this->templateParam_next (const_cast <Type const &> (o)); + } + + virtual void + templateParam_next (Type const&); + + virtual void + templateParam_post (Type &o) + { + this->templateParam_post (const_cast <Type const &> (o)); + } + + virtual void + templateParam_post (Type const&); + + protected: + ComponentPortDescription (); + }; + + struct ComponentPropertyDescription : Traversal::ComponentPropertyDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentPropertyDescription Type; + ComponentPropertyDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + type (Type &o) + { + this->type (const_cast <Type const &> (o)); + } + + virtual void + type (Type const&); + + protected: + ComponentPropertyDescription (); + }; + + struct ComponentExternalPortEndpoint : Traversal::ComponentExternalPortEndpoint, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentExternalPortEndpoint Type; + ComponentExternalPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + portName (Type &o) + { + this->portName (const_cast <Type const &> (o)); + } + + virtual void + portName (Type const&); + + protected: + ComponentExternalPortEndpoint (); + }; + + struct PlanSubcomponentPortEndpoint : Traversal::PlanSubcomponentPortEndpoint, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint Type; + PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + portName (Type &o) + { + this->portName (const_cast <Type const &> (o)); + } + + virtual void + portName (Type const&); + + virtual void + provider (Type &o) + { + this->provider (const_cast <Type const &> (o)); + } + + virtual void + provider (Type const&); + + virtual void + kind (Type &o) + { + this->kind (const_cast <Type const &> (o)); + } + + virtual void + kind (Type const&); + + virtual void + instance (Type &o) + { + this->instance (const_cast <Type const &> (o)); + } + + virtual void + instance (Type const&); + + protected: + PlanSubcomponentPortEndpoint (); + }; + + struct ExternalReferenceEndpoint : Traversal::ExternalReferenceEndpoint, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ExternalReferenceEndpoint Type; + ExternalReferenceEndpoint (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + location (Type &o) + { + this->location (const_cast <Type const &> (o)); + } + + virtual void + location (Type const&); + + virtual void + provider (Type &o) + { + this->provider (const_cast <Type const &> (o)); + } + + virtual void + provider (Type const&); + + virtual void + portName (Type &o) + { + this->portName (const_cast <Type const &> (o)); + } + + virtual void + portName (Type const&); + + virtual void + supportedType_pre (Type &o) + { + this->supportedType_pre (const_cast <Type const &> (o)); + } + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type &o) + { + this->supportedType_next (const_cast <Type const &> (o)); + } + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type &o) + { + this->supportedType_post (const_cast <Type const &> (o)); + } + + virtual void + supportedType_post (Type const&); + + protected: + ExternalReferenceEndpoint (); + }; + + struct ConnectionResourceDeploymentDescription : Traversal::ConnectionResourceDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription Type; + ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + targetName (Type &o) + { + this->targetName (const_cast <Type const &> (o)); + } + + virtual void + targetName (Type const&); + + virtual void + requirementName (Type &o) + { + this->requirementName (const_cast <Type const &> (o)); + } + + virtual void + requirementName (Type const&); + + virtual void + resourceName (Type &o) + { + this->resourceName (const_cast <Type const &> (o)); + } + + virtual void + resourceName (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + ConnectionResourceDeploymentDescription (); + }; + + struct PlanConnectionDescription : Traversal::PlanConnectionDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PlanConnectionDescription Type; + PlanConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + source (Type &o) + { + this->source (const_cast <Type const &> (o)); + } + + virtual void + source (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + externalEndpoint_pre (Type &o) + { + this->externalEndpoint_pre (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_pre (Type const&); + + virtual void + externalEndpoint_next (Type &o) + { + this->externalEndpoint_next (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_next (Type const&); + + virtual void + externalEndpoint_post (Type &o) + { + this->externalEndpoint_post (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_post (Type const&); + + virtual void + internalEndpoint_pre (Type &o) + { + this->internalEndpoint_pre (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_pre (Type const&); + + virtual void + internalEndpoint_next (Type &o) + { + this->internalEndpoint_next (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_next (Type const&); + + virtual void + internalEndpoint_post (Type &o) + { + this->internalEndpoint_post (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_post (Type const&); + + virtual void + externalReference_pre (Type &o) + { + this->externalReference_pre (const_cast <Type const &> (o)); + } + + virtual void + externalReference_pre (Type const&); + + virtual void + externalReference_next (Type &o) + { + this->externalReference_next (const_cast <Type const &> (o)); + } + + virtual void + externalReference_next (Type const&); + + virtual void + externalReference_post (Type &o) + { + this->externalReference_post (const_cast <Type const &> (o)); + } + + virtual void + externalReference_post (Type const&); + + virtual void + deployedResource_pre (Type &o) + { + this->deployedResource_pre (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_pre (Type const&); + + virtual void + deployedResource_next (Type &o) + { + this->deployedResource_next (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_next (Type const&); + + virtual void + deployedResource_post (Type &o) + { + this->deployedResource_post (const_cast <Type const &> (o)); + } + + virtual void + deployedResource_post (Type const&); + + protected: + PlanConnectionDescription (); + }; + + struct ImplementationDependency : Traversal::ImplementationDependency, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ImplementationDependency Type; + ImplementationDependency (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + requiredType (Type &o) + { + this->requiredType (const_cast <Type const &> (o)); + } + + virtual void + requiredType (Type const&); + + protected: + ImplementationDependency (); + }; + + struct Capability : Traversal::Capability, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Capability Type; + Capability (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + resourceType_pre (Type &o) + { + this->resourceType_pre (const_cast <Type const &> (o)); + } + + virtual void + resourceType_pre (Type const&); + + virtual void + resourceType_next (Type &o) + { + this->resourceType_next (const_cast <Type const &> (o)); + } + + virtual void + resourceType_next (Type const&); + + virtual void + resourceType_post (Type &o) + { + this->resourceType_post (const_cast <Type const &> (o)); + } + + virtual void + resourceType_post (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + Capability (); + }; + + struct ImplementationRequirement : Traversal::ImplementationRequirement, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ImplementationRequirement Type; + ImplementationRequirement (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + resourceUsage (Type &o) + { + this->resourceUsage (const_cast <Type const &> (o)); + } + + virtual void + resourceUsage (Type const&); + + virtual void + resourcePort (Type &o) + { + this->resourcePort (const_cast <Type const &> (o)); + } + + virtual void + resourcePort (Type const&); + + virtual void + componentPort (Type &o) + { + this->componentPort (const_cast <Type const &> (o)); + } + + virtual void + componentPort (Type const&); + + virtual void + resourceType (Type &o) + { + this->resourceType (const_cast <Type const &> (o)); + } + + virtual void + resourceType (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + protected: + ImplementationRequirement (); + }; + + struct SubcomponentPortEndpoint : Traversal::SubcomponentPortEndpoint, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SubcomponentPortEndpoint Type; + SubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + portName (Type &o) + { + this->portName (const_cast <Type const &> (o)); + } + + virtual void + portName (Type const&); + + virtual void + instance (Type &o) + { + this->instance (const_cast <Type const &> (o)); + } + + virtual void + instance (Type const&); + + protected: + SubcomponentPortEndpoint (); + }; + + struct AssemblyConnectionDescription : Traversal::AssemblyConnectionDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::AssemblyConnectionDescription Type; + AssemblyConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + internalEndpoint_pre (Type &o) + { + this->internalEndpoint_pre (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_pre (Type const&); + + virtual void + internalEndpoint_next (Type &o) + { + this->internalEndpoint_next (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_next (Type const&); + + virtual void + internalEndpoint_post (Type &o) + { + this->internalEndpoint_post (const_cast <Type const &> (o)); + } + + virtual void + internalEndpoint_post (Type const&); + + virtual void + externalEndpoint_pre (Type &o) + { + this->externalEndpoint_pre (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_pre (Type const&); + + virtual void + externalEndpoint_next (Type &o) + { + this->externalEndpoint_next (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_next (Type const&); + + virtual void + externalEndpoint_post (Type &o) + { + this->externalEndpoint_post (const_cast <Type const &> (o)); + } + + virtual void + externalEndpoint_post (Type const&); + + virtual void + externalReference_pre (Type &o) + { + this->externalReference_pre (const_cast <Type const &> (o)); + } + + virtual void + externalReference_pre (Type const&); + + virtual void + externalReference_next (Type &o) + { + this->externalReference_next (const_cast <Type const &> (o)); + } + + virtual void + externalReference_next (Type const&); + + virtual void + externalReference_post (Type &o) + { + this->externalReference_post (const_cast <Type const &> (o)); + } + + virtual void + externalReference_post (Type const&); + + protected: + AssemblyConnectionDescription (); + }; + + struct PlanLocalityKind : Traversal::PlanLocalityKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + PlanLocalityKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + PlanLocalityKind (); + }; + + struct PlanLocality : Traversal::PlanLocality, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PlanLocality Type; + PlanLocality (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + constraint (Type &o) + { + this->constraint (const_cast <Type const &> (o)); + } + + virtual void + constraint (Type const&); + + virtual void + constrainedInstance_pre (Type &o) + { + this->constrainedInstance_pre (const_cast <Type const &> (o)); + } + + virtual void + constrainedInstance_pre (Type const&); + + virtual void + constrainedInstance_next (Type &o) + { + this->constrainedInstance_next (const_cast <Type const &> (o)); + } + + virtual void + constrainedInstance_next (Type const&); + + virtual void + constrainedInstance_post (Type &o) + { + this->constrainedInstance_post (const_cast <Type const &> (o)); + } + + virtual void + constrainedInstance_post (Type const&); + + protected: + PlanLocality (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // BASIC_DEPLOYMENT_DATA_HPP diff --git a/modules/CIAO/tools/Config_Handlers/CCD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/CCD_Handler.cpp new file mode 100644 index 00000000000..9f596cdcdeb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CCD_Handler.cpp @@ -0,0 +1,181 @@ +// $Id$ + +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" + +#include "ciao/Logger/Log_Macros.h" +#include "CCD_Handler.h" +#include "ccd.hpp" +#include "Property_Handler.h" +#include "CPD_Handler.h" +#include "ComponentPropertyDescription_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void + CCD_Handler::component_interface_descr ( + const ComponentInterfaceDescription &desc, + Deployment::ComponentInterfaceDescription& toconfig) + { + CIAO_TRACE("CCD_Handler::component_interface_descr"); + if (desc.UUID_p ()) + toconfig.UUID = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.UUID ().c_str ())); + + if (desc.label_p ()) + { + toconfig.label = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.label ().c_str ())); + } + + if (desc.specificType_p ()) + { + toconfig.specificType = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.specificType ().c_str ())); + } + + ComponentInterfaceDescription::supportedType_const_iterator + end = desc.end_supportedType (); + + CORBA::ULong pos = 0; + toconfig.supportedType.length (desc.count_supportedType ()); + for (ComponentInterfaceDescription::supportedType_const_iterator s = + desc.begin_supportedType (); + s != end; + ++s) + { + toconfig.supportedType[pos++] = ACE_TEXT_ALWAYS_CHAR ((*s)->c_str ()); + } + + ComponentInterfaceDescription::idlFile_const_iterator + eidl = desc.end_idlFile (); + pos = 0; + toconfig.idlFile.length (desc.count_idlFile ()); + for (ComponentInterfaceDescription::idlFile_const_iterator sidl= + desc.begin_idlFile (); + sidl != eidl; + ++sidl) + { + toconfig.idlFile [pos++] = ACE_TEXT_ALWAYS_CHAR ((*sidl)->c_str ()); + } + + ComponentInterfaceDescription::configProperty_const_iterator pend = + desc.end_configProperty (); + pos = 0; + toconfig.configProperty.length (desc.count_configProperty ()); + for (ComponentInterfaceDescription::configProperty_const_iterator pstart = + desc.begin_configProperty (); + pstart != pend; + ++pstart) + { + Property_Handler::handle_property (*(*pstart), + toconfig.configProperty [pos++]); + } + + pos = 0; + toconfig.port.length (desc.count_port ()); + for (ComponentInterfaceDescription::port_const_iterator + port (desc.begin_port ()); + port != desc.end_port (); + ++port) + { + CPD_Handler::handle_component_port_description (*(*port), + toconfig.port[pos++]); + } + + pos = 0; + CORBA::ULong len = desc.count_property (); + toconfig.property.length ( len ); + for(ComponentInterfaceDescription::property_const_iterator + prop (desc.begin_property()); + prop != desc.end_property(); + prop++) + { + ComponentPropertyDescription_Handler::component_property_description (*(*prop), + toconfig.property[pos++]); + } + + pos = 0; + toconfig.infoProperty.length (desc.count_infoProperty ()); + for ( ComponentInterfaceDescription::infoProperty_const_iterator + infoProp (desc.begin_infoProperty()); + infoProp != desc.end_infoProperty(); + infoProp++) + { + Property_Handler::handle_property (*(*infoProp), + toconfig.infoProperty[pos]); + } + } + + ComponentInterfaceDescription + CCD_Handler::component_interface_descr ( + const ::Deployment::ComponentInterfaceDescription& src) + { + CIAO_TRACE("CCD_Handler::component_interface_descr - reverse"); + ComponentInterfaceDescription cid; + + //Load up the basic string members + XMLSchema::string< ACE_TCHAR > uuid (ACE_TEXT_CHAR_TO_TCHAR (src.UUID)); + XMLSchema::string< ACE_TCHAR > label (ACE_TEXT_CHAR_TO_TCHAR (src.label)); + XMLSchema::string< ACE_TCHAR > specifict (ACE_TEXT_CHAR_TO_TCHAR (src.specificType)); + + //Then put them in the CID + cid.UUID (uuid); + cid.label (label); + cid.specificType (specifict); + + //Get the supported type(s) and load them into cid + ::CORBA::ULong total = src.supportedType.length (); + for (size_t i = 0; i < total; ++i) + { + XMLSchema::string< ACE_TCHAR > curr (ACE_TEXT_CHAR_TO_TCHAR (src.supportedType[i])); + //cid.add_supportedType (new XMLSchema::string< ACE_TCHAR > (curr)); + } + + //Get the idlFile(s) and store them into the cid + total = src.idlFile.length (); + for (size_t j = 0; j < total; ++j) + { + XMLSchema::string< ACE_TCHAR > curr (ACE_TEXT_CHAR_TO_TCHAR (src.idlFile[j])); + //cid.add_idlFile (curr); + } + + //Get the configProperty(ies) and store them into the cid + total = src.configProperty.length (); + for (size_t k = 0; k < total; ++k) + { + //cid.add_configProperty (Property_Handler::get_property (src.configProperty[k])); + } + + //Same drill for the component port description(s) + total = src.port.length (); + for (size_t l = 0; l < total; ++l) + { + //cid.add_port (CPD_Handler::component_port_description (src.port[l])); + } + + + //Load up the property field + total = src.property.length(); + for(size_t m = 0; + m < total; + m++) + { + //cid.add_property(ComponentPropertyDescription_Handler::component_property_description (src.property[m])); + } + + //Load up the infoProperty(s) + total = src.infoProperty.length(); + for(size_t n = 0; + n < total; + n++) + { + //cid.add_infoProperty(Property_Handler::get_property (src.infoProperty[n])); + } + + return cid; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/CCD_Handler.h b/modules/CIAO/tools/Config_Handlers/CCD_Handler.h new file mode 100644 index 00000000000..b3e8292f038 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CCD_Handler.h @@ -0,0 +1,57 @@ +//================================================ +/** +* @file CCD_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CCD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CCD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ +struct ComponentInterfaceDescription; +} + +namespace CIAO +{ +namespace Config_Handlers +{ +class ComponentInterfaceDescription; + +/* +* @class CCD_Handler +* +* @brief Handler class for <ComponentInterfaceDescription> types. +* +* This class is named CCD_Handler but actually fills +* <ComponentInterfaceDescription>. Why is this confusion? We +* want to maintain the correlation between the XSD file and the +* actual datatype. The file name corresponds to the XSD file but +* the data type being filled in is of type +* <ComponentInterfaceDescription> +*/ +class Config_Handlers_Export CCD_Handler +{ +public: +static void component_interface_descr (const ComponentInterfaceDescription &src, +::Deployment::ComponentInterfaceDescription& dest); +static ComponentInterfaceDescription +component_interface_descr (const ::Deployment::ComponentInterfaceDescription& src); + +}; +} +} + +#include /**/ "ace/post.h" +#endif /* CID_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/CEPE_Handler.cpp b/modules/CIAO/tools/Config_Handlers/CEPE_Handler.cpp new file mode 100644 index 00000000000..a3d76c50ef0 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CEPE_Handler.cpp @@ -0,0 +1,51 @@ +// $Id$ + +#include "CEPE_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + void + CEPE_Handler::external_port_endpoints ( + const PlanConnectionDescription &src, + ::Deployment::ComponentExternalPortEndpoints &dest) + { + CIAO_TRACE("CEOE_Handler::external_port_endpoints"); + PlanConnectionDescription::externalEndpoint_const_iterator eeci_e = + src.end_externalEndpoint (); + + CORBA::ULong pos = 0; + dest.length (src.count_externalEndpoint ()); + for (PlanConnectionDescription::externalEndpoint_const_iterator eeci_b = + src.begin_externalEndpoint (); + eeci_b != eeci_e; + ++eeci_b) + { + CEPE_Handler::handle_external_port_endpoint (*(*eeci_b), + dest[pos++]); + } + } + + void + CEPE_Handler::handle_external_port_endpoint ( + const ComponentExternalPortEndpoint &src, + ::Deployment::ComponentExternalPortEndpoint &dest) + { + CIAO_TRACE("CEOE_Handler::external_port_endpoint"); + dest.portName = ACE_TEXT_ALWAYS_CHAR (src.portName ().c_str ()); + } + + ComponentExternalPortEndpoint + CEPE_Handler::external_port_endpoint ( + const ::Deployment::ComponentExternalPortEndpoint &src) + { + CIAO_TRACE("CEOE_Handler::external_port_endpoint - reverse"); + //MAJO Unfinished + XMLSchema::string< ACE_TCHAR > portname (ACE_TEXT_CHAR_TO_TCHAR (src.portName)); + return ComponentExternalPortEndpoint (portname); + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/CEPE_Handler.h b/modules/CIAO/tools/Config_Handlers/CEPE_Handler.h new file mode 100644 index 00000000000..b3b0938b8c2 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CEPE_Handler.h @@ -0,0 +1,67 @@ +//============================================================== +/** + * @file CEPE_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CEPE_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CEPE_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + class ComponentExternalPortEndpoints; + struct ComponentExternalPortEndpoint; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class PlanConnectionDescription; + class ComponentExternalPortEndpoint; + + /* + * @class CEPE_Handler + * + * @brief Handler class for <ComponentExternalPortEndpoint> types. + * + * This class defines handler methods to map values from + * XSC ComponentExternalPortEndpoint objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Common_Export CEPE_Handler + { + public: + static void external_port_endpoints (const PlanConnectionDescription &src, + ::Deployment::ComponentExternalPortEndpoints &dest); + + static ComponentExternalPortEndpoint + external_port_endpoint (const ::Deployment::ComponentExternalPortEndpoint &src); + + static void handle_external_port_endpoint (const ComponentExternalPortEndpoint &src, + ::Deployment::ComponentExternalPortEndpoint &dest); + }; + + typedef Sequence_Handler < ComponentExternalPortEndpoint, + ::Deployment::ComponentExternalPortEndpoints, + ::Deployment::ComponentExternalPortEndpoint, + CEPE_Handler::handle_external_port_endpoint > CEPE_Functor; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CEPE_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/CPD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/CPD_Handler.cpp new file mode 100644 index 00000000000..afad9712eed --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CPD_Handler.cpp @@ -0,0 +1,152 @@ +// $Id$ + +#include "CPD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void + CPD_Handler::handle_component_port_description ( + const ComponentPortDescription& desc, + Deployment::ComponentPortDescription& toconfig) + { + CIAO_TRACE("CPD_Handler::component_port_description"); + toconfig.name = + ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + + if (desc.specificType_p ()) + toconfig.specificType = + ACE_TEXT_ALWAYS_CHAR (desc.specificType ().c_str ()); + + toconfig.supportedType.length (desc.count_supportedType ()); + std::for_each (desc.begin_supportedType (), + desc.end_supportedType (), + String_Seq_Functor (toconfig.supportedType)); + + + switch (desc.kind ().integral ()) + { + case CCMComponentPortKind::Facet_l: + toconfig.kind = Deployment::Facet; + break; + + case CCMComponentPortKind::SimplexReceptacle_l: + toconfig.kind = Deployment::SimplexReceptacle; + break; + + case CCMComponentPortKind::MultiplexReceptacle_l: + toconfig.kind = Deployment::MultiplexReceptacle; + break; + + case CCMComponentPortKind::EventEmitter_l: + toconfig.kind = Deployment::EventEmitter; + break; + + case CCMComponentPortKind::EventPublisher_l: + toconfig.kind = Deployment::EventPublisher; + break; + + case CCMComponentPortKind::EventConsumer_l: + toconfig.kind = Deployment::EventConsumer; + break; + + default: + ACE_ERROR ((LM_ERROR, "Invalid port type in connection %s\n", + desc.name ().c_str ())); + throw 1; + } + + /* @@BUG: We need to consider how to handle booleans. */ + toconfig.provider = desc.provider (); + toconfig.exclusiveProvider = desc.exclusiveProvider (); + toconfig.exclusiveUser = desc.exclusiveUser (); + toconfig.optional = desc.optional (); + } + + ComponentPortDescription + CPD_Handler::component_port_description ( + const Deployment::ComponentPortDescription& src) + { + CIAO_TRACE("CPD_Handler::component_port_description - reverse"); + ::XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + ::XMLSchema::string< ACE_TCHAR > stype (ACE_TEXT_CHAR_TO_TCHAR (src.specificType)); + + ::XMLSchema::string< ACE_TCHAR > tval (ACE_TEXT ("true")); + ::XMLSchema::string< ACE_TCHAR > fval (ACE_TEXT ("false")); + XMLSchema::boolean provider; + XMLSchema::boolean exclusiveProvider; + XMLSchema::boolean exclusiveUser; + XMLSchema::boolean optional; + + if (src.provider) + provider = true; + else + provider = false; + + if (src.exclusiveUser) + exclusiveUser = true; + else + provider = false; + + if (src.exclusiveProvider) + exclusiveProvider = true; + else + provider = false; + + if (src.optional) + optional = true; + else + provider = false; + + ComponentPortDescription cpd (name, + provider, + exclusiveProvider, + exclusiveUser, + optional, + CCMComponentPortKind::Facet); + + switch (src.kind) + { + case ::Deployment::Facet: + cpd.kind (CCMComponentPortKind::Facet); + break; + + case ::Deployment::SimplexReceptacle: + cpd.kind (CCMComponentPortKind::SimplexReceptacle); + break; + + case ::Deployment::MultiplexReceptacle: + cpd.kind (CCMComponentPortKind::MultiplexReceptacle); + break; + + case ::Deployment::EventEmitter: + cpd.kind (CCMComponentPortKind::EventEmitter); + break; + + case ::Deployment::EventPublisher: + cpd.kind (CCMComponentPortKind::EventPublisher); + break; + + case ::Deployment::EventConsumer: + cpd.kind (CCMComponentPortKind::EventConsumer); + break; + + default: + ACE_ERROR ((LM_ERROR, ACE_TEXT("Invalid port kind in connection %C\n"), + name.c_str ())); + } + + for (CORBA::ULong i = 0; i < src.supportedType.length (); ++i) + { + //cpd.add_supportedType (XMLSchema::string< ACE_TCHAR > ((src.supportedType[i]))); + } + + return cpd; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/CPD_Handler.h b/modules/CIAO/tools/Config_Handlers/CPD_Handler.h new file mode 100644 index 00000000000..445d2c5f329 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CPD_Handler.h @@ -0,0 +1,68 @@ +//================================================ +/** + * @file CPD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CPD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CPD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ComponentPortDescription; + class ComponentPortDescriptions; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentPortDescription; + /* + * @class CPD_Handler + * + * @brief Handler class for <CCMComponentPortDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + + class Config_Handlers_Common_Export CPD_Handler + { + + public: + /// Maps the values from the XSC object + /// <ComponentInterfaceDescription> to the CORBA IDL type + /// <Deployment::ComponentInterfaceDescription>. + static void handle_component_port_description (const ComponentPortDescription &desc, + ::Deployment::ComponentPortDescription &toconfig); + + static ComponentPortDescription + component_port_description (const Deployment::ComponentPortDescription& src); + }; + + typedef Sequence_Handler < ComponentPortDescription, + ::Deployment::ComponentPortDescriptions, + ::Deployment::ComponentPortDescription, + CPD_Handler::handle_component_port_description > CPD_Functor; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CPD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/CRDD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/CRDD_Handler.cpp new file mode 100644 index 00000000000..226ab86d70e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CRDD_Handler.cpp @@ -0,0 +1,66 @@ +// $Id$ + +#include "CRDD_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Property_Handler.h" + +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + + CRDD_Handler::CRDD_Handler (void) + { + } + + CRDD_Handler::~CRDD_Handler (void) + { + } + + ///This method takes a <Deployment::ConnectionResourceDeploymentDescription> + ///and maps the values from the passed in XSC + ///ConnectionResourceDeploymentDescription to its members. + void CRDD_Handler::get_ConnectionResourceDeploymentDescription (Deployment::ConnectionResourceDeploymentDescription& toconfig, + const ConnectionResourceDeploymentDescription& desc) + { + CIAO_TRACE("CRDD_Handler::get_ConnectionResourceDD"); + + toconfig.targetName = ACE_TEXT_ALWAYS_CHAR ( desc.targetName ().c_str ()); + toconfig.requirementName = ACE_TEXT_ALWAYS_CHAR ( desc.requirementName ().c_str ()); + toconfig.resourceName = ACE_TEXT_ALWAYS_CHAR ( desc.resourceName ().c_str ()); + + std::for_each (desc.begin_property (), + desc.end_property (), + Property_Functor (toconfig.property)); + } + + ConnectionResourceDeploymentDescription + CRDD_Handler::connection_resource_depl_desc ( + const ::Deployment::ConnectionResourceDeploymentDescription& src) + { + CIAO_TRACE("CRDD_Handler::get_ConnectionResourceDeploymentDescription- reverse"); + XMLSchema::string< ACE_TCHAR > tname (ACE_TEXT_CHAR_TO_TCHAR (src.targetName)); + XMLSchema::string< ACE_TCHAR > reqname (ACE_TEXT_CHAR_TO_TCHAR(src.requirementName)); + XMLSchema::string <ACE_TCHAR> resname (ACE_TEXT_CHAR_TO_TCHAR (src.resourceName)); + + ConnectionResourceDeploymentDescription crdd (tname, + reqname, + resname); + + for (CORBA::ULong i = 0; + i != src.property.length (); + ++i) + { + //crdd.add_property (Property_Handler::get_property (src.property[i])); + } + + + return crdd; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/CRDD_Handler.h b/modules/CIAO/tools/Config_Handlers/CRDD_Handler.h new file mode 100644 index 00000000000..8f5c964aab4 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/CRDD_Handler.h @@ -0,0 +1,67 @@ +//============================================================== +/** + * @file CRDD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CRDD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CRDD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ConnectionResourceDeploymentDescription; +} + +namespace CIAO +{ + + namespace Config_Handlers + { + + class ConnectionResourceDeploymentDescription; + + /* + * @class CRDD_Handler + * + * @brief Handler class for <ConnectionResourceDeploymentDescription> types. + * + * This class defines handler methods to map values from + * XSC ConnectionResourceDeploymentDescription objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Export CRDD_Handler{ + + public: + + CRDD_Handler (void); + virtual ~CRDD_Handler (void); + + ///This method takes a <Deployment::ConnectionResourceDeploymentDescription> + ///and maps the values from the passed in XSC + ///ConnectionResourceDeploymentDescription to its members. + void get_ConnectionResourceDeploymentDescription (Deployment::ConnectionResourceDeploymentDescription& toconfig, + const ConnectionResourceDeploymentDescription& desc); + + static ConnectionResourceDeploymentDescription + connection_resource_depl_desc ( + const ::Deployment::ConnectionResourceDeploymentDescription& src); + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CRDD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Common.h b/modules/CIAO/tools/Config_Handlers/Common.h new file mode 100644 index 00000000000..dec8f4b497a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Common.h @@ -0,0 +1,46 @@ +// $Id$ +/** + * @file Common.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * Some common definitions for all config_handlers. + */ +#ifndef CONFIG_HANDLERS_COMMON_H +#define CONFIG_HANDLERS_COMMON_H +#include <string> + +namespace CIAO +{ + namespace Config_Handlers + { + /** + * @class Config_Error + * @brief Exception to communicate a config_handlers error + */ + class Config_Error + { + public: + Config_Error (const std::basic_string<ACE_TCHAR> &name, + const std::basic_string<ACE_TCHAR> &error) : + name_ (name), + error_ (error) + {}; + + void add_name (const std::basic_string<ACE_TCHAR> &name) + { + name_ = name + ACE_TEXT (":") + name_; + } + + /// Some identifying information about the element that + /// caused the error + std::basic_string<ACE_TCHAR> name_; + + /// A human readable error message + std::basic_string<ACE_TCHAR> error_; + + }; + } +} +#endif /* CONFIG_HANDLERS_COMMON_H */ + + diff --git a/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.cpp b/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.cpp new file mode 100644 index 00000000000..e9941254093 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.cpp @@ -0,0 +1,41 @@ +//$Id$ + +#include "ComponentPropertyDescription_Handler.h" +#include "DataType_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + void + ComponentPropertyDescription_Handler::component_property_description ( + const ComponentPropertyDescription& desc, + ::Deployment::ComponentPropertyDescription& toconfig) + { + CIAO_TRACE("ComponentPropertyDescription_Handler::component_property_description"); + toconfig.name = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ())); + + // Delegate the DataType to the + // DataType_Handler. + + // @@ There is a lurking bug here. + //#if 0 + CORBA::TypeCode_ptr tcptr = toconfig.type.in (); + DataType_Handler::data_type (desc.type (), tcptr); + //#endif /*if 0*/ + } + + ComponentPropertyDescription + ComponentPropertyDescription_Handler::component_property_description ( + const ::Deployment::ComponentPropertyDescription &src) + { + CIAO_TRACE("ComponentPropertyDescription_Handler::component_property_description - reverse"); + XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + DataType dt (DataType_Handler::data_type (src.type)); + ComponentPropertyDescription cpd (name,dt); + return cpd; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.h b/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.h new file mode 100644 index 00000000000..f87edc7fcea --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.h @@ -0,0 +1,61 @@ +//============================================================== +/** +* @file ComponentPropertyDescription_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_ComponentPropertyDescription_Handler_H +#define CIAO_CONFIG_HANDLERS_ComponentPropertyDescription_Handler_H +#include /**/ "ace/pre.h" + + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ +struct ComponentPropertyDescription; +} + +namespace CIAO +{ +namespace Config_Handlers +{ +class ComponentPropertyDescription; + +/* +* @class ComponentPropertyDescription_Handler +* +* @brief Handler class for <ComponentPortDescription> types. +* +* This class defines handler methods to map values from +* XSC objects, parsed from the descriptor files, to the +* corresponding CORBA IDL type for the schema element. +* +*/ +class Config_Handlers_Export ComponentPropertyDescription_Handler +{ +public: + +/// This method maps the values from the XSC object +/// <ComponentPropertyDescription> to the CORBA IDL type +/// <Deployment::ComponentPropertyDescription>. +static void component_property_description ( +const ComponentPropertyDescription& desc, +::Deployment::ComponentPropertyDescription& toconfig); +static ComponentPropertyDescription +component_property_description ( +const ::Deployment::ComponentPropertyDescription &src); +}; +} +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ComponentPropertyDescription_Handler_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Config_Handlers.mpc b/modules/CIAO/tools/Config_Handlers/Config_Handlers.mpc new file mode 100644 index 00000000000..03ad9ffae78 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Config_Handlers.mpc @@ -0,0 +1,139 @@ +//$Id$ + +project (XSC_XML_Generation) : xscdefaults { + requires += xsc + + xscflags += --cxx-banner-file $(CIAO_ROOT)/docs/schema/xsc-banner.cpp + xscflags += --cxx-header-banner-file $(CIAO_ROOT)/docs/schema/xsc-banner.h + xscflags += --cxx-export-symbol XSC_XML_Handlers_Export + xscflags += --cxx-namespace-regex "%.*Deployment.*%CIAO/Config_Handlers%" //<%quote%> + xscflags += --cxx-export-header XSC_XML_Handlers_Export.h + xscflags += --search-path "$(CIAO_ROOT)/docs/schema" + + custom_only = 1 + + XSC_Files { + gendir = . + $(CIAO_ROOT)/docs/schema/Basic_Deployment_Data.xsd + $(CIAO_ROOT)/docs/schema/Deployment.xsd + $(CIAO_ROOT)/docs/schema/XMI.xsd + $(CIAO_ROOT)/docs/schema/ccd.xsd + $(CIAO_ROOT)/docs/schema/cdd.xsd + $(CIAO_ROOT)/docs/schema/cdp.xsd + $(CIAO_ROOT)/docs/schema/cid.xsd + $(CIAO_ROOT)/docs/schema/cpd.xsd + $(CIAO_ROOT)/docs/schema/iad.xsd + $(CIAO_ROOT)/docs/schema/pcd.xsd + $(CIAO_ROOT)/docs/schema/toplevel.xsd + } + + Source_Files { + } +} + +project (XSC_XML_Handlers) : acelib, xerces, ciao_lib, ciao_xml_utils { + sharedname += XSC_XML_Handlers + dynamicflags = XSC_XML_HANDLERS_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers $(CIAO_ROOT)/tools + after += XSC_XML_Generation + + Source_Files { + XMI.cpp + Deployment.cpp + ccd.cpp + cdd.cpp + cdp.cpp + cid.cpp + cpd.cpp + iad.cpp + pcd.cpp + toplevel.cpp + Basic_Deployment_Data.cpp + XML_Typedefs.cpp + } + + Header_Files { + XSC_XML_Handlers_Export.h + XML_Typedefs.h + } + + verbatim(gnuace, macros) { + override no_hidden_visibility = 1 + } + +} + +project (XSC_Config_Handlers) : dance_deployment_stub, ciao_config_handlers_base, ciao_lib, dance { + after += XSC_DynAny_Handler \ + XSC_Config_Handlers_Common + + sharedname = XSC_Config_Handlers + dynamicflags = CONFIG_HANDLERS_BUILD_DLL + libs += CIAO_XML_Utils \ + XSC_XML_Handlers \ + XSC_DynAny_Handler \ + XSC_Config_Handlers_Common + + includes += $(CIAO_ROOT)/ciao + + Source_Files { + DP_Handler.cpp + CCD_Handler.cpp + ComponentPropertyDescription_Handler.cpp + MDD_Handler.cpp + ComponentPropertyDescription_Handler.cpp + MDD_Handler.cpp + PSPE_Handler.cpp + CRDD_Handler.cpp + IDD_Handler.cpp + ADD_Handler.cpp + ComponentPropertyDescription_Handler.cpp + RDD_Handler.cpp + ID_Handler.cpp + PL_Handler.cpp + XML_File_Intf.cpp + IDREF_Base.cpp + Dump_Obj.cpp + PCD_Handler.cpp + IRDD_Handler.cpp + DD_Handler.cpp + DnC_Dump.cpp + } + + Header_Files { + Config_Handlers_Export.h + } + +} + +project (XSC_Config_Handlers_Common) : dance_deployment_stub, ciao_config_handlers_base, ciao_lib, dance { + after += XSC_DynAny_Handler + sharedname = XSC_Config_Handlers_Common + dynamicflags = CONFIG_HANDLERS_COMMON_BUILD_DLL + + libs += XSC_DynAny_Handler + + Source_Files { + ERE_Handler.cpp + Req_Handler.cpp + DataType_Handler.cpp + Property_Handler.cpp + SatisfierProperty_Handler.cpp + CPD_Handler.cpp + CEPE_Handler.cpp + Any_Handler.cpp + } +} +project (XSC_Config_Handlers_Tests) : dance_deployment_stub, ciao_config_handlers, ifr_client { + requires += dummy_label + includes += $(CIAO_ROOT)/tools/Config_Handlers + exename = test + macros += XML_USE_PTHREADS + + Source_Files { + test.cpp + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/Config_Handlers_Common_Export.h b/modules/CIAO/tools/Config_Handlers/Config_Handlers_Common_Export.h new file mode 100644 index 00000000000..f1583c7e71d --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Config_Handlers_Common_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl -s Config_Handlers_Common +// ------------------------------ +#ifndef CONFIG_HANDLERS_COMMON_EXPORT_H +#define CONFIG_HANDLERS_COMMON_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (CONFIG_HANDLERS_COMMON_HAS_DLL) +# define CONFIG_HANDLERS_COMMON_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && CONFIG_HANDLERS_COMMON_HAS_DLL */ + +#if !defined (CONFIG_HANDLERS_COMMON_HAS_DLL) +# define CONFIG_HANDLERS_COMMON_HAS_DLL 1 +#endif /* ! CONFIG_HANDLERS_COMMON_HAS_DLL */ + +#if defined (CONFIG_HANDLERS_COMMON_HAS_DLL) && (CONFIG_HANDLERS_COMMON_HAS_DLL == 1) +# if defined (CONFIG_HANDLERS_COMMON_BUILD_DLL) +# define Config_Handlers_Common_Export ACE_Proper_Export_Flag +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CONFIG_HANDLERS_COMMON_BUILD_DLL */ +# define Config_Handlers_Common_Export ACE_Proper_Import_Flag +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CONFIG_HANDLERS_COMMON_BUILD_DLL */ +#else /* CONFIG_HANDLERS_COMMON_HAS_DLL == 1 */ +# define Config_Handlers_Common_Export +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARATION(T) +# define CONFIG_HANDLERS_COMMON_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CONFIG_HANDLERS_COMMON_HAS_DLL == 1 */ + +// Set CONFIG_HANDLERS_COMMON_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CONFIG_HANDLERS_COMMON_NTRACE) +# if (ACE_NTRACE == 1) +# define CONFIG_HANDLERS_COMMON_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CONFIG_HANDLERS_COMMON_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CONFIG_HANDLERS_COMMON_NTRACE */ + +#if (CONFIG_HANDLERS_COMMON_NTRACE == 1) +# define CONFIG_HANDLERS_COMMON_TRACE(X) +#else /* (CONFIG_HANDLERS_COMMON_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CONFIG_HANDLERS_COMMON_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CONFIG_HANDLERS_COMMON_NTRACE == 1) */ + +#endif /* CONFIG_HANDLERS_COMMON_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/Config_Handlers_Export.h b/modules/CIAO/tools/Config_Handlers/Config_Handlers_Export.h new file mode 100644 index 00000000000..64dec8bdfa5 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Config_Handlers_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl -s Config_Handlers +// ------------------------------ +#ifndef CONFIG_HANDLERS_EXPORT_H +#define CONFIG_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (CONFIG_HANDLERS_HAS_DLL) +# define CONFIG_HANDLERS_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && CONFIG_HANDLERS_HAS_DLL */ + +#if !defined (CONFIG_HANDLERS_HAS_DLL) +# define CONFIG_HANDLERS_HAS_DLL 1 +#endif /* ! CONFIG_HANDLERS_HAS_DLL */ + +#if defined (CONFIG_HANDLERS_HAS_DLL) && (CONFIG_HANDLERS_HAS_DLL == 1) +# if defined (CONFIG_HANDLERS_BUILD_DLL) +# define Config_Handlers_Export ACE_Proper_Export_Flag +# define CONFIG_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CONFIG_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CONFIG_HANDLERS_BUILD_DLL */ +# define Config_Handlers_Export ACE_Proper_Import_Flag +# define CONFIG_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CONFIG_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CONFIG_HANDLERS_BUILD_DLL */ +#else /* CONFIG_HANDLERS_HAS_DLL == 1 */ +# define Config_Handlers_Export +# define CONFIG_HANDLERS_SINGLETON_DECLARATION(T) +# define CONFIG_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CONFIG_HANDLERS_HAS_DLL == 1 */ + +// Set CONFIG_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CONFIG_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define CONFIG_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CONFIG_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CONFIG_HANDLERS_NTRACE */ + +#if (CONFIG_HANDLERS_NTRACE == 1) +# define CONFIG_HANDLERS_TRACE(X) +#else /* (CONFIG_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CONFIG_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CONFIG_HANDLERS_NTRACE == 1) */ + +#endif /* CONFIG_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/DD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DD_Handler.cpp new file mode 100644 index 00000000000..41c6db742c7 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DD_Handler.cpp @@ -0,0 +1,212 @@ +// $Id$ + +#include "XML_Typedefs.h" +#include "SatisfierProperty_Handler.h" +#include "DD_Handler.h" +#include "Any_Handler.h" +#include "Deployment.hpp" +#include "DAnCE/Deployment/Deployment_TargetDataC.h" +#include "ciao/Logger/Log_Macros.h" + +using namespace std; + +namespace CIAO +{ + namespace Config_Handlers + { + DD_Handler::DD_Handler (const ACE_TCHAR *file) : + idl_domain_(0), + domain_ (0), + retval_ (false) + { + CIAO_TRACE("DP_PCD_Handler::constructor"); + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + XML_Helper::XML_HELPER.create_dom (file); + + if (!dom) + throw DD_Handler::NoDomain (); + + Domain *dm = + new Domain (reader::domain (dom)); + + // Domain d = domain (dom); + + this->domain_.reset (dm); + + if (!this->build_domain ()) + throw NoDomain (); + } + + DD_Handler::DD_Handler (Domain *dmn): + idl_domain_(0), + domain_(dmn), + retval_(false) + { + CIAO_TRACE("DP_PCD_Handler::constructor - Domain"); + if(!this->build_domain ()) + throw NoDomain (); + } + + DD_Handler::DD_Handler (::Deployment::Domain *dmn): + idl_domain_(dmn), + domain_(0), + retval_(false) + { + if(!this->build_xsc()) + throw NoDomain (); + } + + DD_Handler::~DD_Handler (void) + { + } + + bool + DD_Handler::build_domain () + { + CIAO_TRACE("DP_PCD_Handler::build_domain"); + this->idl_domain_.reset ( new ::Deployment::Domain ); + + // Read in the name + // Check if the label is there or not + if (domain_->label_p ()) + this->idl_domain_->label = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (domain_->label ().c_str ())); + + if (domain_->UUID_p ()) + this->idl_domain_->UUID = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (domain_->UUID ().c_str ())); + + CORBA::ULong len = domain_->count_node (); + this->idl_domain_->node.length (len); + + //Resource _resource; + int i =0; + for (Domain::node_const_iterator iter = domain_->begin_node (); + iter != domain_->end_node (); + ++iter,++i + ) + { + // Node* thisNode = (Node*)iter; + this->idl_domain_->node[i].name = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*iter)->name ().c_str ())); + + if ((*iter)->label_p ()) + this->idl_domain_->node[i].label = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*iter)->label ().c_str ())); + + // length is hard-coded for now ... + // here iterate over the resources ... + CORBA::ULong res_len = (*iter)->count_resource (); + this->idl_domain_->node[i].resource.length (res_len); + + int res_id=0; + // FOR EACH RESOURCE .... + for (Node::resource_const_iterator res_iter = (*iter)->begin_resource (); + res_iter != (*iter)->end_resource (); + res_iter++, res_id++) + { + + this->idl_domain_->node[i].resource[res_id].name = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*res_iter)->name ().c_str ())); + + CORBA::ULong resource_type_len = (*res_iter)->count_resourceType (); + this->idl_domain_->node[i].resource[res_id].resourceType.length (resource_type_len); + + int res_type_id =0; + + // FOR EACH RESOURCE TYPE + for (Resource::resourceType_const_iterator res_type_iter = + (*res_iter)->begin_resourceType (); + res_type_iter != (*res_iter)->end_resourceType (); + res_type_iter++, res_type_id++) + { + this->idl_domain_->node[i].resource[res_id].resourceType[res_type_id] = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*res_type_iter)->c_str ())); + } + + CORBA::ULong property_len = (*res_iter)->count_property (); + this->idl_domain_->node[i].resource[res_id].property.length (property_len); + + // int property_id =0; + + std::for_each ((*res_iter)->begin_property (), + (*res_iter)->end_property (), + SatisfierProperty_Functor (this->idl_domain_->node[i].resource[res_id].property)); + + /* + //FOR EACH PROPERTY + for (Resource::property_const_iterator property_iter = + (*res_iter)->begin_property (); + property_iter != (*res_iter)->end_property (); + property_iter++, property_id++) + { + this->idl_domain_->node[i].resource[res_id].property[property_id ].name = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (property_iter->name ().c_str ())); + + + this->idl_domain_->node[i].resource[res_id].property[property_id].kind = + ::Deployment::Quantity; + + Any the_any = property_iter->value (); + CORBA::Any a_corba_any; + Any_Handler::extract_into_any (the_any , a_corba_any); + this->idl_domain_->node[i].resource[res_id].property[property_id].value + = a_corba_any; + } + */ + } + } + + return true; + + } + + bool + DD_Handler::build_xsc () + { + return true; + } + + ::Deployment::Domain const * + DD_Handler::domain_idl () const + { + if(!this->idl_domain_.get()) + throw NoDomain (); + + //else + return this->idl_domain_.get(); + } + + ::Deployment::Domain * + DD_Handler::domain_idl () + { + if(!this->idl_domain_.get()) + throw NoDomain(); + + //else + return this->idl_domain_.release(); + } + + Domain const * + DD_Handler::domain_xsc () const + { + if(!this->domain_.get()) + throw NoDomain (); + + //else + return this->domain_.get(); + } + + Domain * + DD_Handler::domain_xsc () + { + if(!this->domain_.get()) + throw NoDomain (); + + //else + return this->domain_.release(); + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/DD_Handler.h b/modules/CIAO/tools/Config_Handlers/DD_Handler.h new file mode 100644 index 00000000000..f3a9e0c60c9 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DD_Handler.h @@ -0,0 +1,114 @@ +// $Id$ +//====================================== +/** +* @file DD_Handler.h +* +* @brief Contains the Domain Descriptior +* Handler +* +* @author Nilabja Roy <nilabjar@dre.vanderbilt.edu> +* +*/ +//====================================== + +#ifndef CIAO_CONFIG_HANDLERS_DD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include "ace/Auto_Ptr.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ +struct Domain; +} + +namespace CIAO +{ +namespace Config_Handlers +{ +class Domain; + +/* +* @class DD_Handler +* +* @brief Handler class for <Domain> +*/ + +class Config_Handlers_Export DD_Handler +{ +public: +class NoDomain {}; + +/** +* @param file The file to be read +*/ +DD_Handler (const ACE_TCHAR *file); + +/** +* @param dmn The Domain structure +*/ +DD_Handler(Domain *dmn); + +/** +* @param dmn The Deployment::Domain structure +*/ +DD_Handler(::Deployment::Domain *dmn); + +/** +*/ +~DD_Handler (void); + +/** +* @brief Returns the const IDL domain +* @return Domain* the IDL domain pointer +*/ + ::Deployment::Domain const *domain_idl (void) const; + +/** +* @brief Returns the IDL domain +* @return Domain* the IDL domain pointer +*/ + ::Deployment::Domain *domain_idl (void); + +/** +* @brief Returns the const XSC domain +* @return Domain* the XSC domain pointer +*/ + Domain const *domain_xsc (void) const; + +/** +* @brief Returns the XSC domain +* @return Domain* the XSC domain pointer +*/ + Domain *domain_xsc (void); + +private: +/** +* @brief builds the domain structure +*/ +bool build_domain (); + +/** +* @brief builds the XSC data structure +*/ +bool build_xsc (); + +/// The Deployment Domain structure +auto_ptr < ::Deployment::Domain > idl_domain_; + +/// The XSC Domain structure +auto_ptr <Domain> domain_; + +/// The return value used +bool retval_; +}; +} +} + +#include /**/ "ace/post.h" +#endif /* DD_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/DP_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DP_Handler.cpp new file mode 100644 index 00000000000..d649e6ee06a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DP_Handler.cpp @@ -0,0 +1,276 @@ +// $Id$ + +#include "DP_Handler.h" +#include "ace/UUID.h" +#include "DAnCE/Deployment/Deployment_DataC.h" + +#include "CCD_Handler.h" +#include "ADD_Handler.h" +#include "MDD_Handler.h" +#include "IDD_Handler.h" +#include "ID_Handler.h" +#include "PL_Handler.h" +#include "Property_Handler.h" +#include "cdp.hpp" + +#include "PCD_Handler.h" + +ACE_RCSID (Config_Handlers, + DP_Handler, + "$Id$") + + namespace CIAO + { + namespace Config_Handlers + { + DP_Handler::DP_Handler (deploymentPlan &dp) + : xsc_dp_ (0) + , idl_dp_ (0) + , retval_ (true) + { + if (!this->resolve_plan (dp)) + throw; + } + + DP_Handler::DP_Handler (const ::Deployment::DeploymentPlan &plan) + : xsc_dp_ (new deploymentPlan), + idl_dp_ (0), + retval_ (0) + { + if (!this->build_xsc (plan)) + throw; + } + + DP_Handler::~DP_Handler (void) + throw () + { + } + + deploymentPlan const * + DP_Handler::xsc (void) const + { + if (this->retval_ && this->xsc_dp_.get () != 0) + return this->xsc_dp_.get (); + + throw NoPlan (); + } + + deploymentPlan * + DP_Handler::xsc (void) + { + if (this->retval_ && this->xsc_dp_.get () != 0) + return this->xsc_dp_.release (); + + throw NoPlan (); + } + + ::Deployment::DeploymentPlan const * + DP_Handler::plan (void) const + { + if (this->retval_ && this->idl_dp_.get () != 0) + return this->idl_dp_.get (); + + throw NoPlan (); + } + + ::Deployment::DeploymentPlan * + DP_Handler::plan (void) + { + if (this->retval_ && this->idl_dp_.get () != 0) + return this->idl_dp_.release (); + + throw NoPlan (); + } + + bool + DP_Handler::resolve_plan (deploymentPlan &xsc_dp) + { + CIAO_TRACE ("DP_Handler::resolve_plan"); + + ::Deployment::DeploymentPlan *tmp = + new Deployment::DeploymentPlan; + + this->idl_dp_.reset (tmp); + + // Read in the label, if present, since minoccurs = 0 + if (xsc_dp.label_p ()) + { + this->idl_dp_->label = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (xsc_dp.label ().c_str ())); + } + + // Read in the UUID, if present + if (xsc_dp.UUID_p ()) + { + this->idl_dp_->UUID = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (xsc_dp.UUID ().c_str ())); + } + + // Similar thing for dependsOn + for (deploymentPlan::dependsOn_const_iterator dstart = xsc_dp.begin_dependsOn (); + dstart != xsc_dp.end_dependsOn (); + ++dstart) + { + CORBA::ULong len = this->idl_dp_->dependsOn.length (); + this->idl_dp_->dependsOn.length (len + 1); + ID_Handler::get_ImplementationDependency (*(*dstart), + this->idl_dp_->dependsOn [len]); + + } + + // ... An the property stuff + for (deploymentPlan::infoProperty_const_iterator pstart = xsc_dp.begin_infoProperty (); + pstart != xsc_dp.end_infoProperty (); + ++pstart) + { + CORBA::ULong len = + this->idl_dp_->infoProperty.length (); + + this->idl_dp_->infoProperty.length (len + 1); + + Property_Handler::handle_property (*(*pstart), + this->idl_dp_->infoProperty [len]); + } + + // Read in the realizes, if present + if (xsc_dp.realizes_p ()) + { + CCD_Handler::component_interface_descr ( + xsc_dp.realizes (), + this->idl_dp_->realizes); + } + + ADD_Handler::artifact_deployment_descrs (xsc_dp, + this->idl_dp_->artifact); + + MDD_Handler::mono_deployment_descriptions (xsc_dp, + this->idl_dp_->implementation); + + IDD_Handler::instance_deployment_descrs (xsc_dp, + this->idl_dp_->instance); + + this->idl_dp_->connection.length (xsc_dp.count_connection ()); + std::for_each (xsc_dp.begin_connection (), + xsc_dp.end_connection (), + PCD_Functor (this->idl_dp_->connection)); + + this->idl_dp_->localityConstraint.length (xsc_dp.count_localityConstraint ()); + + std::for_each (xsc_dp.begin_localityConstraint (), + xsc_dp.end_localityConstraint (), + PL_Functor (this->idl_dp_->localityConstraint)); + + //PCD_Handler::get_PlanConnectionDescription (xsc_dp, this->idl_dp_->connection); + + return true; + } + + bool + DP_Handler::build_xsc (const ::Deployment::DeploymentPlan &plan) + { + CIAO_TRACE ("DP_Handler::build_xsc"); + + // Initialize the UUID generator. + ACE_Utils::UUID_GENERATOR::instance ()->init (); + + // Clear IDREF tables + IDD_Handler::IDREF.unbind_refs (); + MDD_Handler::IDREF.unbind_refs (); + ADD_Handler::IDREF.unbind_refs (); + + + size_t len; //Used for checking the length of struct data members + + // Read in the label, if present, since minoccurs = 0 + if (plan.label != 0) + { + XMLSchema::string< ACE_TCHAR > i(ACE_TEXT_CHAR_TO_TCHAR (plan.label)); + this->xsc_dp_->label(i); + } + + // Read in the UUID, if present + if (plan.UUID != 0) + { + XMLSchema::string< ACE_TCHAR > j(ACE_TEXT_CHAR_TO_TCHAR(plan.UUID)); + this->xsc_dp_->UUID(j); + } + + // Similar thing for dependsOn + len = plan.dependsOn.length(); + for (size_t j = 0; + j < len; + ++j) + { + //this->xsc_dp_->add_dependsOn(ID_Handler::impl_dependency(plan.dependsOn[j])); + } + + // ... And the property stuff + len = plan.infoProperty.length(); + for (size_t q = 0; + q < len; + q++) + { + if (ACE_OS::strcmp (plan.infoProperty[q].name.in (), + "CIAOServerResources") == 0) + { + ACE_ERROR ((LM_ERROR, + "(%P|%t) DP_Handler: Dumping of ServerResources not currently supported.")); + continue; + } + + //this->xsc_dp_->add_infoProperty (Property_Handler::get_property (plan.infoProperty[q])); + } + + + // We are assuming there is a realizes for the moment + // @@ We may want to change this at a later date by creating a sequence of + // @@ ComponentInterfaceDescriptions in the DeploymentPlan in ../DAnCE/Deployment/Deployment_Data.idl + // @@ so we can check for length + this->xsc_dp_->realizes(CCD_Handler::component_interface_descr(plan.realizes)); + if (!this->xsc_dp_->realizes_p()) + { + ACE_ERROR ((LM_ERROR, + "(%P|%t) DP_Handler: " + "Error parsing Component Interface Descriptor.")); + return false; + } + + //Take care of the artifact(s) if they exist + len = plan.artifact.length(); + for(size_t k = 0; + k < len; + k++) + { + //this->xsc_dp_->add_artifact (ADD_Handler::artifact_deployment_descr (plan.artifact[k])); + } + + //Take care of the implementation(s) if they exist + len = plan.implementation.length(); + for(size_t l = 0; + l < len; + l++) + { + //this->xsc_dp_->add_implementation (MDD_Handler::mono_deployment_description (plan.implementation[l])); + } + + //Ditto for the instance(s) + len = plan.instance.length(); + for(size_t m = 0; + m < len; + m++) + { + //this->xsc_dp_->add_instance (IDD_Handler::instance_deployment_descr (plan.instance[m])); + } + + //Finally, take care of the Connection Planning + len = plan.connection.length(); + for(size_t n = 0; n < len; n++) + { + //this->xsc_dp_->add_connection (PCD_Handler::get_PlanConnectionDescription (plan.connection[n])); + } + + retval_ = true; + return true; + } + } + } diff --git a/modules/CIAO/tools/Config_Handlers/DP_Handler.h b/modules/CIAO/tools/Config_Handlers/DP_Handler.h new file mode 100644 index 00000000000..82d93aaa62f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DP_Handler.h @@ -0,0 +1,87 @@ +//============================================================== +/** + * @file DP_Handler.h + * + * $Id$ + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_DP_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DP_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include <memory> +using std::auto_ptr; + + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace Deployment +{ + struct DeploymentPlan ; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class deploymentPlan; + + /* + * @class DP_Handler + * + * @brief Handler for Deployment::DeploymentPlan + */ + class Config_Handlers_Export DP_Handler + { + public: + class NoPlan {}; + + /// Use this constructor if you want to use + /// the XSC->IDL mapping + DP_Handler (deploymentPlan &dp); + + /// Use this constructor if you want to use + /// the IDL->XSC mapping + DP_Handler (const ::Deployment::DeploymentPlan &plan); + + ~DP_Handler (void) + throw (); + + /// Generates the IDL->XSC mapping. returns + /// null if the method fails or if the class was + /// constructed with the wrong source. + deploymentPlan const *xsc (void) const; + + deploymentPlan *xsc (void); + + /// Generates the XSC->IDL mapping. returns null + /// if the method fails or the class was constructed + ::Deployment::DeploymentPlan const *plan (void) const; + + ::Deployment::DeploymentPlan *plan (void); + + private: + + bool resolve_plan (deploymentPlan &dp); + + bool build_xsc (const ::Deployment::DeploymentPlan &plan); + + private: + auto_ptr< deploymentPlan > xsc_dp_; + + auto_ptr< ::Deployment::DeploymentPlan> idl_dp_; + + bool retval_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_HANDLERS_DP_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.cpp new file mode 100644 index 00000000000..ba0b88a2bf7 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.cpp @@ -0,0 +1,107 @@ +// $Id$ + +#include "DP_PCD_Handler.h" +#include "CEPE_Handler.h" +#include "PSPE_Handler.h" +#include "ERE_Handler.h" +#include "CRDD_Handler.h" +#include "PCD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "cdp.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + void + DP_PCD_Handler::plan_connection_descrs ( + const DeploymentPlan &src, + Deployment::PlanConnectionDescriptions& dest) + { + CIAO_TRACE("DP_PCD_Handler::plan_connection_descrs"); + DeploymentPlan::connection_const_iterator cci_e = + src.end_connection (); + + CORBA::ULong pos = 0; + dest.length (src.count_connection ()); + for (DeploymentPlan::connection_const_iterator cci_b = + src.begin_connection (); + cci_b != cci_e; + ++cci_b) + { + DP_PCD_Handler::plan_connection_descr (*(cci_b), + dest[pos++]); + } + } + + PlanConnectionDescription + DP_PCD_Handler::plan_connection_descr ( + const Deployment::PlanConnectionDescription &src) + { + CIAO_TRACE("DP_PCD_Handler::plan_connection_descr"); + PlanConnectionDescription pcd = PCD_Handler::get_PlanConnectionDescription(src); + return pcd; + } + + void + DP_PCD_Handler::plan_connection_descr ( + const PlanConnectionDescription &src, + Deployment::PlanConnectionDescription &dest) + { + CIAO_TRACE("DP_PCD_Handler::plan_connection_descr - reverse"); + dest.name = + src.name ().c_str (); + + if (src.source_p ()) + { + // There will be only one as per the schema + dest.source.length (1); + dest.source[0] = + src.source ().c_str (); + } + + + CEPE_Handler::external_port_endpoints (src, + dest.externalEndpoint); + ERE_Handler::external_ref_endpoints (src, + dest.externalReference); + + PSPE_Handler::sub_component_port_endpoints (src, + dest.internalEndpoint); + +#if 0 + // @@MAJO: Need to figure how to use this. + if (desc.deployedResource_p ()) + { + CRDD_Handler crddhandler; + + toconfig.deployedResource.length ( + toconfig.deployedResource.length () + 1); + + crddhandler.get_ConnectionResourceDeploymentDescription ( + toconfig.deployedResource[toconfig.deployedResource.length () - 1], + desc.deployedResource ()); + } + + if (desc.deployRequirement_p ()) + { + + // @@ MAJO: Not sure how to use this + //Create the handler for the requirements. + Requirement_Handler reqhandler; + + //Increase the sequence length and delgate + //the Requirement to the Req_Handler. + toconfig.deployRequirement.length ( + toconfig.deployRequirement.length () + 1); + reqhandler.get_Requirement ( + toconfig.deployRequirement[toconfig.deployRequirement.length () - 1], + desc.deployRequirement ()); + + + } +#endif /*if 0*/ + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.h b/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.h new file mode 100644 index 00000000000..eceb6f03bb6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DP_PCD_Handler.h @@ -0,0 +1,67 @@ +//============================================================== +/** + * @file DP_PCD_Handler.h + * + * $Id$ + * + * Handler for Deployment::PlanConnectionHandler + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_DP_PCD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DP_PCD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct PlanConnectionDescription; + class PlanConnectionDescriptions; +} + +namespace CIAO +{ + + namespace Config_Handlers + { + class DeploymentPlan; + class PlanConnectionDescription; + + /* + * @class DP_PCD_Handler + * + * @brief Handler class for <PlanConnectionDescription> types. + * + * This class defines handler methods to map values from + * XSC PlanConnectionDescription objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Export DP_PCD_Handler + { + public: + static void plan_connection_descrs ( + const DeploymentPlan &src, + Deployment::PlanConnectionDescriptions& toconfig); + + static PlanConnectionDescription plan_connection_descr( + const Deployment::PlanConnectionDescription &src); + + private: + static void plan_connection_descr ( + const PlanConnectionDescription& desc, + Deployment::PlanConnectionDescription& toconfig); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_PCD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/DataType_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DataType_Handler.cpp new file mode 100644 index 00000000000..6020c40727f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DataType_Handler.cpp @@ -0,0 +1,179 @@ +//$Id$ + +#include "DataType_Handler.h" +#include "tao/AnyTypeCode/TypeCode.h" +#include "tao/AnyTypeCode/TypeCode_Constants.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + + DataType_Handler::DataType_Handler (void) + { + } + DataType_Handler::~DataType_Handler (void) + { + } + + ///This method takes a <CIAO::Config_Handlers::DataType> + ///and returns the corresponding CORBA::TypeCode. + void + DataType_Handler::data_type (const DataType& desc, + CORBA::TypeCode_ptr& type) + { + CIAO_TRACE("DataType_Handler::data_type"); + TCKind kind (desc.kind ()); + + switch (kind.integral ()) + { + case TCKind::tk_null_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_null); + break; + + case TCKind::tk_short_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_short); + break; + + case TCKind::tk_long_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_long); + break; + + case TCKind::tk_ushort_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_ushort); + break; + + case TCKind::tk_ulong_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_ulong); + break; + + case TCKind::tk_float_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_float); + break; + + case TCKind::tk_double_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_double); + break; + + case TCKind::tk_boolean_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_boolean); + break; + + case TCKind::tk_char_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_char); + break; + + case TCKind::tk_octet_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_octet); + break; + + case TCKind::tk_string_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_string); + break; + + case TCKind::tk_longlong_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_longlong); + break; + + case TCKind::tk_ulonglong_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_ulonglong); + break; + + case TCKind::tk_longdouble_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_longdouble); + break; + + case TCKind::tk_wchar_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_wchar); + break; + + case TCKind::tk_wstring_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_wstring); + break; + + case TCKind::tk_any_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_any); + break; + + case TCKind::tk_TypeCode_l: + type = CORBA::TypeCode::_duplicate (CORBA::_tc_TypeCode); + break; + + default: + ACE_ERROR ((LM_ERROR, "DataType_Handler::data_type, Invalid typecode in any\n")); + throw 1; + } + + // This case used to be supported...is it not in the schema? + // case TCKind::tk_Object) + // type = CORBA::TypeCode::_duplicate (CORBA::_tc_Object);*/ + + } + + DataType + DataType_Handler::data_type (const CORBA::TypeCode_ptr& src) + { + CIAO_TRACE("DataType_Handler::data_type - reverse"); + switch (src->kind ()) + { + case ::CORBA::tk_null: + return DataType (TCKind::tk_null); + break; + case CORBA::tk_short: + return DataType (TCKind::tk_short); + break; + case CORBA::tk_long: + return DataType (TCKind::tk_long); + break; + case CORBA::tk_ushort: + return DataType (TCKind::tk_ushort); + break; + case CORBA::tk_ulong: + return DataType (TCKind::tk_ulong); + break; + case CORBA::tk_float: + return DataType (TCKind::tk_float); + break; + case CORBA::tk_double: + return DataType (TCKind::tk_double); + break; + case CORBA::tk_boolean: + return DataType (TCKind::tk_boolean); + break; + case CORBA::tk_char: + return DataType (TCKind::tk_char); + break; + case CORBA::tk_octet: + return DataType (TCKind::tk_octet); + break; + case CORBA::tk_string: + return DataType (TCKind::tk_string); + break; + case CORBA::tk_longlong: + return DataType (TCKind::tk_longlong); + break; + case CORBA::tk_ulonglong: + return DataType (TCKind::tk_ulonglong); + break; + case CORBA::tk_longdouble: + return DataType (TCKind::tk_longdouble); + break; + case CORBA::tk_wchar: + return DataType (TCKind::tk_wchar); + break; + case CORBA::tk_wstring: + return DataType (TCKind::tk_wstring); + break; + case CORBA::tk_any: + return DataType (TCKind::tk_any); + break; + case CORBA::tk_TypeCode: + return DataType (TCKind::tk_TypeCode); + default: + ACE_ERROR ((LM_ERROR, "DataType_Handler::data_type, Invalid typecode\n")); + throw 1; + } + throw 1; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DataType_Handler.h b/modules/CIAO/tools/Config_Handlers/DataType_Handler.h new file mode 100644 index 00000000000..b2a3240fbec --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DataType_Handler.h @@ -0,0 +1,62 @@ +//================================================ +/** +* @file DataType_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================ + +#ifndef DATATYPE_HANDLER_H +#define DATATYPE_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "DAnCE/Deployment/DeploymentC.h" +#include "Basic_Deployment_Data.hpp" + +#include "Config_Handlers_Common_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO{ + +namespace Config_Handlers{ + +/* +* @class DataType_Handler +* +* @brief Handler class for <ComponentPortDescription> types. +* +* This class defines handler methods to map values from +* XSC objects, parsed from the descriptor files, to the +* corresponding CORBA IDL type for the schema element. +* +*/ + +class Config_Handlers_Common_Export DataType_Handler { + +public: + +DataType_Handler (void); +virtual ~DataType_Handler (void); + +////This method takes a <CIAO::Config_Handlers::DataType> +///and returns the corresponding CORBA::TypeCode. +static void +data_type (const DataType& desc, +CORBA::TypeCode_ptr& type); + + +static DataType data_type (const CORBA::TypeCode_ptr& type); +}; + +} +} + +#include /**/ "ace/post.h" +#endif /* DATATYPE_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Deployment.cpp b/modules/CIAO/tools/Config_Handlers/Deployment.cpp new file mode 100644 index 00000000000..cce77ace34b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Deployment.cpp @@ -0,0 +1,854 @@ +/* $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 "Deployment.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace reader + { + ::CIAO::Config_Handlers::Domain + domain (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("domain")) + { + ::CIAO::Config_Handlers::Domain r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::deploymentPlan + DeploymentPlan (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("DeploymentPlan")) + { + ::CIAO::Config_Handlers::deploymentPlan r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::ImplementationArtifactDescription + implementationArtifactDescription (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("implementationArtifactDescription")) + { + ::CIAO::Config_Handlers::ImplementationArtifactDescription r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription + componentInterfaceDescription (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("componentInterfaceDescription")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::ComponentImplementationDescription + componentImplementationDescription (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("componentImplementationDescription")) + { + ::CIAO::Config_Handlers::ComponentImplementationDescription r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::ComponentPackageDescription + componentPackageDescription (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("componentPackageDescription")) + { + ::CIAO::Config_Handlers::ComponentPackageDescription r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::PackageConfiguration + packageConfiguration (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("packageConfiguration")) + { + ::CIAO::Config_Handlers::PackageConfiguration r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + + namespace reader + { + ::CIAO::Config_Handlers::TopLevelPackageDescription + topLevelPackageDescription (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("topLevelPackageDescription")) + { + ::CIAO::Config_Handlers::TopLevelPackageDescription r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } + } +} + +#include "XMLSchema/TypeInfo.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace + { + ::XMLSchema::TypeInfoInitializer < ACE_TCHAR > XMLSchemaTypeInfoInitializer_ (::XSCRT::extended_type_info_map ()); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace writer + { + void + domain (::CIAO::Config_Handlers::Domain const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("domain")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::Domain, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::Node, + virtual ::CIAO::Config_Handlers::Writer::Interconnect, + virtual ::CIAO::Config_Handlers::Writer::Bridge, + virtual ::CIAO::Config_Handlers::Writer::Resource, + virtual ::CIAO::Config_Handlers::Writer::SatisfierProperty, + virtual ::CIAO::Config_Handlers::Writer::SatisfierPropertyKind, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::SharedResource, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + DeploymentPlan (::CIAO::Config_Handlers::deploymentPlan const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("DeploymentPlan")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::deploymentPlan, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::CIAO::Config_Handlers::Writer::MonolithicDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::IdRef, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::CIAO::Config_Handlers::Writer::InstanceDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::InstanceResourceDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::ResourceUsageKind, + virtual ::CIAO::Config_Handlers::Writer::PlanConnectionDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentExternalPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::PlanSubcomponentPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ExternalReferenceEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ConnectionResourceDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::PlanPropertyMapping, + virtual ::CIAO::Config_Handlers::Writer::PlanSubcomponentPropertyReference, + virtual ::CIAO::Config_Handlers::Writer::ImplementationDependency, + virtual ::CIAO::Config_Handlers::Writer::ArtifactDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::ResourceDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::PlanLocality, + virtual ::CIAO::Config_Handlers::Writer::PlanLocalityKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + implementationArtifactDescription (::CIAO::Config_Handlers::ImplementationArtifactDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("implementationArtifactDescription")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::ImplementationArtifactDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedImplementationArtifact, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + componentInterfaceDescription (::CIAO::Config_Handlers::ComponentInterfaceDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("componentInterfaceDescription")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + componentImplementationDescription (::CIAO::Config_Handlers::ComponentImplementationDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("componentImplementationDescription")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::ComponentImplementationDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentAssemblyDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentInstantiationDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageDescription, + virtual ::CIAO::Config_Handlers::Writer::PackagedComponentImplementation, + virtual ::CIAO::Config_Handlers::Writer::PackageConfiguration, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageImport, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageReference, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::CIAO::Config_Handlers::Writer::AssemblyConnectionDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::IdRef, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentExternalPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ExternalReferenceEndpoint, + virtual ::CIAO::Config_Handlers::Writer::AssemblyPropertyMapping, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPropertyReference, + virtual ::CIAO::Config_Handlers::Writer::Locality, + virtual ::CIAO::Config_Handlers::Writer::LocalityKind, + virtual ::CIAO::Config_Handlers::Writer::MonolithicImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ImplementationRequirement, + virtual ::CIAO::Config_Handlers::Writer::ResourceUsageKind, + virtual ::CIAO::Config_Handlers::Writer::NamedImplementationArtifact, + virtual ::CIAO::Config_Handlers::Writer::ImplementationArtifactDescription, + virtual ::CIAO::Config_Handlers::Writer::Capability, + virtual ::CIAO::Config_Handlers::Writer::SatisfierProperty, + virtual ::CIAO::Config_Handlers::Writer::SatisfierPropertyKind, + virtual ::CIAO::Config_Handlers::Writer::ImplementationDependency, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + componentPackageDescription (::CIAO::Config_Handlers::ComponentPackageDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("componentPackageDescription")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::ComponentPackageDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::CIAO::Config_Handlers::Writer::PackagedComponentImplementation, + virtual ::CIAO::Config_Handlers::Writer::ComponentImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentAssemblyDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentInstantiationDescription, + virtual ::CIAO::Config_Handlers::Writer::PackageConfiguration, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageImport, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageReference, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::CIAO::Config_Handlers::Writer::AssemblyConnectionDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::IdRef, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentExternalPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ExternalReferenceEndpoint, + virtual ::CIAO::Config_Handlers::Writer::AssemblyPropertyMapping, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPropertyReference, + virtual ::CIAO::Config_Handlers::Writer::Locality, + virtual ::CIAO::Config_Handlers::Writer::LocalityKind, + virtual ::CIAO::Config_Handlers::Writer::MonolithicImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ImplementationRequirement, + virtual ::CIAO::Config_Handlers::Writer::ResourceUsageKind, + virtual ::CIAO::Config_Handlers::Writer::NamedImplementationArtifact, + virtual ::CIAO::Config_Handlers::Writer::ImplementationArtifactDescription, + virtual ::CIAO::Config_Handlers::Writer::Capability, + virtual ::CIAO::Config_Handlers::Writer::SatisfierProperty, + virtual ::CIAO::Config_Handlers::Writer::SatisfierPropertyKind, + virtual ::CIAO::Config_Handlers::Writer::ImplementationDependency, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + packageConfiguration (::CIAO::Config_Handlers::PackageConfiguration const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("packageConfiguration")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::PackageConfiguration, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::CIAO::Config_Handlers::Writer::PackagedComponentImplementation, + virtual ::CIAO::Config_Handlers::Writer::ComponentImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentAssemblyDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentInstantiationDescription, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageReference, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageImport, + virtual ::CIAO::Config_Handlers::Writer::AssemblyConnectionDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::IdRef, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentExternalPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ExternalReferenceEndpoint, + virtual ::CIAO::Config_Handlers::Writer::AssemblyPropertyMapping, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPropertyReference, + virtual ::CIAO::Config_Handlers::Writer::Locality, + virtual ::CIAO::Config_Handlers::Writer::LocalityKind, + virtual ::CIAO::Config_Handlers::Writer::MonolithicImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ImplementationRequirement, + virtual ::CIAO::Config_Handlers::Writer::ResourceUsageKind, + virtual ::CIAO::Config_Handlers::Writer::NamedImplementationArtifact, + virtual ::CIAO::Config_Handlers::Writer::ImplementationArtifactDescription, + virtual ::CIAO::Config_Handlers::Writer::Capability, + virtual ::CIAO::Config_Handlers::Writer::SatisfierProperty, + virtual ::CIAO::Config_Handlers::Writer::SatisfierPropertyKind, + virtual ::CIAO::Config_Handlers::Writer::ImplementationDependency, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + + namespace writer + { + void + topLevelPackageDescription (::CIAO::Config_Handlers::TopLevelPackageDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("topLevelPackageDescription")) + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::TopLevelPackageDescription, + virtual ::CIAO::Config_Handlers::Writer::PackageConfiguration, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentInterfaceDescription, + virtual ::CIAO::Config_Handlers::Writer::Property, + virtual ::CIAO::Config_Handlers::Writer::Any, + virtual ::CIAO::Config_Handlers::Writer::DataType, + virtual ::CIAO::Config_Handlers::Writer::TCKind, + virtual ::CIAO::Config_Handlers::Writer::EnumType, + virtual ::CIAO::Config_Handlers::Writer::StructType, + virtual ::CIAO::Config_Handlers::Writer::StructMemberType, + virtual ::CIAO::Config_Handlers::Writer::ValueType, + virtual ::CIAO::Config_Handlers::Writer::ValueMemberType, + virtual ::CIAO::Config_Handlers::Writer::SequenceType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedInt, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AliasType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::DataValue, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::short_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::float_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::double_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedByte, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::NamedValue, + virtual ::CIAO::Config_Handlers::Writer::ComponentPortDescription, + virtual ::CIAO::Config_Handlers::Writer::CCMComponentPortKind, + virtual ::CIAO::Config_Handlers::Writer::ComponentPropertyDescription, + virtual ::CIAO::Config_Handlers::Writer::PackagedComponentImplementation, + virtual ::CIAO::Config_Handlers::Writer::ComponentImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ComponentAssemblyDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentInstantiationDescription, + virtual ::CIAO::Config_Handlers::Writer::Requirement, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageReference, + virtual ::CIAO::Config_Handlers::Writer::ComponentPackageImport, + virtual ::CIAO::Config_Handlers::Writer::AssemblyConnectionDescription, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::IdRef, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ComponentExternalPortEndpoint, + virtual ::CIAO::Config_Handlers::Writer::ExternalReferenceEndpoint, + virtual ::CIAO::Config_Handlers::Writer::AssemblyPropertyMapping, + virtual ::CIAO::Config_Handlers::Writer::SubcomponentPropertyReference, + virtual ::CIAO::Config_Handlers::Writer::Locality, + virtual ::CIAO::Config_Handlers::Writer::LocalityKind, + virtual ::CIAO::Config_Handlers::Writer::MonolithicImplementationDescription, + virtual ::CIAO::Config_Handlers::Writer::ImplementationRequirement, + virtual ::CIAO::Config_Handlers::Writer::ResourceUsageKind, + virtual ::CIAO::Config_Handlers::Writer::NamedImplementationArtifact, + virtual ::CIAO::Config_Handlers::Writer::ImplementationArtifactDescription, + virtual ::CIAO::Config_Handlers::Writer::Capability, + virtual ::CIAO::Config_Handlers::Writer::SatisfierProperty, + virtual ::CIAO::Config_Handlers::Writer::SatisfierPropertyKind, + virtual ::CIAO::Config_Handlers::Writer::ImplementationDependency, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/Deployment.hpp b/modules/CIAO/tools/Config_Handlers/Deployment.hpp new file mode 100644 index 00000000000..2a039912b19 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Deployment.hpp @@ -0,0 +1,221 @@ +/* $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 + +#ifndef DEPLOYMENT_HPP +#define DEPLOYMENT_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +#include "cpd.hpp" + +#include "cdd.hpp" + +#include "cdp.hpp" + +#include "toplevel.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::Domain + domain (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::deploymentPlan + DeploymentPlan (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ImplementationArtifactDescription + implementationArtifactDescription (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentInterfaceDescription + componentInterfaceDescription (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentImplementationDescription + componentImplementationDescription (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentPackageDescription + componentPackageDescription (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::PackageConfiguration + packageConfiguration (xercesc::DOMDocument const*); + } + + + namespace reader + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::TopLevelPackageDescription + topLevelPackageDescription (xercesc::DOMDocument const*); + } + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace writer + { + XSC_XML_Handlers_Export + void + domain (::CIAO::Config_Handlers::Domain const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + DeploymentPlan (::CIAO::Config_Handlers::deploymentPlan const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + implementationArtifactDescription (::CIAO::Config_Handlers::ImplementationArtifactDescription const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + componentInterfaceDescription (::CIAO::Config_Handlers::ComponentInterfaceDescription const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + componentImplementationDescription (::CIAO::Config_Handlers::ComponentImplementationDescription const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + componentPackageDescription (::CIAO::Config_Handlers::ComponentPackageDescription const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + packageConfiguration (::CIAO::Config_Handlers::PackageConfiguration const&, xercesc::DOMDocument*); + } + + + namespace writer + { + XSC_XML_Handlers_Export + void + topLevelPackageDescription (::CIAO::Config_Handlers::TopLevelPackageDescription const&, xercesc::DOMDocument*); + } + } +} + +#endif // DEPLOYMENT_HPP diff --git a/modules/CIAO/tools/Config_Handlers/DnC_Dump.cpp b/modules/CIAO/tools/Config_Handlers/DnC_Dump.cpp new file mode 100644 index 00000000000..3bee947afd3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DnC_Dump.cpp @@ -0,0 +1,982 @@ +// $Id$ + +#include "ace/Log_Msg.h" +#include "tao/SystemException.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "DnC_Dump.h" +#include "DnC_Dump_T.h" +#include <iostream> + +using namespace ::Deployment::DnC_Dump_T; +namespace Deployment +{ + void + DnC_Dump::dump (const char* caption, const ::CORBA::StringSeq &str_seq) + { + CORBA::ULong size = str_seq.length (); + + if (size != 0) + { + Dump_Obj dump_obj (caption); + + for (CORBA::ULong i = 0; i < size; ++i) + { + ACE_DEBUG ((LM_DEBUG, "%s%s %d:\n", + Dump_Obj::indent(), caption, i)); + ACE_DEBUG ((LM_DEBUG, "%s %s:\n", + Dump_Obj::indent(), str_seq[i].in ())); + } + } + } + + // Dumps a string + void DnC_Dump::dump (const char* caption, const TAO::String_Manager& str) + { + ACE_DEBUG ((LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), + caption, str.in())); + } + + // Dumps a boolean + void DnC_Dump::dump (const char* caption, const CORBA::Boolean& val) + { + ACE_DEBUG ((LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), + caption, val ? "true" : "false")); + } + + /* + * Object dump methods + */ + + // SatisfierProperty + void DnC_Dump::dump (const Deployment::SatisfierProperty& sp) + { + Dump_Obj dump_obj("SatisfierProperty"); + dump ("name", sp.name); + + ACE_DEBUG ((LM_DEBUG, "%skind: ", Dump_Obj::indent())); + switch (sp.kind) { + case Quantity: ACE_DEBUG ((LM_DEBUG, "Quantity\n")); break; + case Capacity: ACE_DEBUG ((LM_DEBUG, "Capacity\n")); break; + case Minimum: ACE_DEBUG ((LM_DEBUG, "Minimum\n")); break; + case Maximum: ACE_DEBUG ((LM_DEBUG, "Maximum\n")); break; + case Attribute: ACE_DEBUG ((LM_DEBUG, "Attribute\n")); break; + case Selection: ACE_DEBUG ((LM_DEBUG, "Selection\n")); break; + } + + ACE_DEBUG ((LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); + dump (sp.value); + } + + // SharedResource + void DnC_Dump::dump (const Deployment::SharedResource& sr) + { + Dump_Obj dump_obj("SharedResource"); + dump ("name", sr.name); + dump ("resourceType", sr.resourceType); +#if 0 + dump_ref_seq<Deployment::Domain> ("nodeRef", + sr.nodeRef, + "Domain", + &Domain::node); +#endif /*if 0*/ + dump_sequence ("property", + sr.property); + } + + // Resource + void DnC_Dump::dump (const Deployment::Resource& resource) + { + Dump_Obj dump_obj("Resource"); + dump ("name", resource.name); + dump ("resourceType", resource.resourceType); + dump_sequence ("property", + resource.property); + } + + // Node + void DnC_Dump::dump (const Deployment::Node& node) + { + Dump_Obj dump_obj("Node"); + dump ("name", node.name); + dump ("label", node.label); + +#if (_MSC_VER) + dump_ref_seq<Deployment::Domain> ( + "sharedResourceRef", + node.sharedResourceRef, + "Domain", + &Domain::sharedResource); +#endif + +#if (_MSC_VER) + dump_ref_seq<Deployment::Domain> ( + "connectionRef", + node.connectionRef, + "Domain", + &Domain::interconnect); +#endif + + dump_sequence ("resource", + node.resource); + + } + + // Interconnect + void DnC_Dump::dump (const Deployment::Interconnect& conn) + { + Dump_Obj dump_obj("Interconnect"); + dump ("name", conn.name); + dump ("label", conn.label); + +#if (_MSC_VER) + dump_ref_seq<Deployment::Domain> ( + "connectionRef", + conn.connectionRef, + "Domain", + &Domain::bridge); +#endif +#if (_MSC_VER) + dump_ref_seq<Deployment::Domain> ( + "connectRef", + conn.connectRef, + "Domain", + &Domain::node); +#endif + dump_sequence ("resource", + conn.resource); + } + + // Bridge + void + DnC_Dump::dump (const Deployment::Bridge& bridge) + { + Dump_Obj dump_obj("Bridge"); + dump ("name", bridge.name); + dump ("label", bridge.label); + +#if (_MSC_VER) + dump_ref_seq<Deployment::Domain> ( + "connectRef", + bridge.connectRef, + "Domain", + &Domain::interconnect); +#endif + + dump_sequence ("resource", bridge.resource); + } + + void DnC_Dump::dump (const ::Deployment::Domain &domain) + { + CORBA::Any val; + val <<= domain; + + Dump_Obj dump_obj ("Domain", + val); + + dump ("UUID", + domain.UUID); + dump ("label", + domain.label); + + dump_sequence ("sharedResource", + domain.sharedResource); + dump_sequence ("node", + domain.node); + dump_sequence ("interconnect", + domain.interconnect); + dump_sequence ("bridge", + domain.bridge); + + dump_sequence ("infoProperty", + domain.infoProperty); + } + + // ComponentPortDescription + + void DnC_Dump::dump (const ::Deployment::ComponentPortDescription + &compportdesc) + { + Dump_Obj dump_obj("ComponentPortDescription"); + + dump ("name", compportdesc.name); + dump ("specificType", compportdesc.specificType); + dump ("supportedType", compportdesc.supportedType); + dump ("provider", compportdesc.provider); + dump ("exclusiveProvider", compportdesc.exclusiveProvider); + dump ("exclusiveUser", compportdesc.exclusiveUser); + dump ("optional", compportdesc.optional); + + ACE_DEBUG ((LM_DEBUG, "%skind: ", Dump_Obj::indent())); + switch (compportdesc.kind) { + case Facet: ACE_DEBUG ((LM_DEBUG, "Facet\n")); break; + case SimplexReceptacle: ACE_DEBUG ((LM_DEBUG, "SimplexReceptacle\n")); break; + case MultiplexReceptacle: ACE_DEBUG ((LM_DEBUG, "MultiplexReceptacle\n")); break; + case EventEmitter: ACE_DEBUG ((LM_DEBUG, "EventEmitter\n")); break; + case EventPublisher: ACE_DEBUG ((LM_DEBUG, "EventPublisher\n")); break; + case EventConsumer: ACE_DEBUG ((LM_DEBUG, "EventConsumer\n")); break; + default: ACE_DEBUG ((LM_DEBUG, "Unknown port kind\n")); break; + } + } + + // ComponentPropertyDescription + + void DnC_Dump::dump (const ::Deployment::ComponentPropertyDescription &comppropdesc) + { + Dump_Obj dump_obj("ComponentPropertyDescription"); + + dump ("name", comppropdesc.name); + + ACE_DEBUG ((LM_DEBUG, "%stype: ", Dump_Obj::indent())); + switch (comppropdesc.type.in()->kind()) { + case ::CORBA::tk_null: ACE_DEBUG ((LM_DEBUG, "tk_null\n")); break; + case ::CORBA::tk_void: ACE_DEBUG ((LM_DEBUG, "tk_void\n")); break; + case ::CORBA::tk_short: ACE_DEBUG ((LM_DEBUG, "tk_short\n")); break; + case ::CORBA::tk_long: ACE_DEBUG ((LM_DEBUG, "tk_long\n")); break; + case ::CORBA::tk_ushort: ACE_DEBUG ((LM_DEBUG, "tk_ushort\n")); break; + case ::CORBA::tk_ulong: ACE_DEBUG ((LM_DEBUG, "tk_ulong\n")); break; + case ::CORBA::tk_float: ACE_DEBUG ((LM_DEBUG, "tk_float\n")); break; + case ::CORBA::tk_double: ACE_DEBUG ((LM_DEBUG, "tk_double\n")); break; + case ::CORBA::tk_boolean: ACE_DEBUG ((LM_DEBUG, "tk_boolean\n")); break; + case ::CORBA::tk_char: ACE_DEBUG ((LM_DEBUG, "tk_char\n")); break; + case ::CORBA::tk_octet: ACE_DEBUG ((LM_DEBUG, "tk_octet\n")); break; + case ::CORBA::tk_any: ACE_DEBUG ((LM_DEBUG, "tk_any\n")); break; + case ::CORBA::tk_TypeCode: ACE_DEBUG ((LM_DEBUG, "tk_TypeCode\n")); break; + case ::CORBA::tk_Principal: ACE_DEBUG ((LM_DEBUG, "tk_Principal\n")); break; + case ::CORBA::tk_objref: ACE_DEBUG ((LM_DEBUG, "tk_objref\n")); break; + case ::CORBA::tk_struct: ACE_DEBUG ((LM_DEBUG, "tk_struct\n")); break; + case ::CORBA::tk_union: ACE_DEBUG ((LM_DEBUG, "tk_union\n")); break; + case ::CORBA::tk_enum: ACE_DEBUG ((LM_DEBUG, "tk_enum\n")); break; + case ::CORBA::tk_string: ACE_DEBUG ((LM_DEBUG, "tk_string\n")); break; + case ::CORBA::tk_sequence: ACE_DEBUG ((LM_DEBUG, "tk_sequence\n")); break; + case ::CORBA::tk_array: ACE_DEBUG ((LM_DEBUG, "tk_array\n")); break; + case ::CORBA::tk_alias: ACE_DEBUG ((LM_DEBUG, "tk_alias\n")); break; + case ::CORBA::tk_except: ACE_DEBUG ((LM_DEBUG, "tk_except\n")); break; + case ::CORBA::tk_longlong: ACE_DEBUG ((LM_DEBUG, "tk_longlong\n")); break; + case ::CORBA::tk_ulonglong: ACE_DEBUG ((LM_DEBUG, "tk_ulonglong\n")); break; + case ::CORBA::tk_longdouble: ACE_DEBUG ((LM_DEBUG, "tk_longdouble\n")); break; + case ::CORBA::tk_wchar: ACE_DEBUG ((LM_DEBUG, "tk_wchar\n")); break; + case ::CORBA::tk_wstring: ACE_DEBUG ((LM_DEBUG, "tk_wstring\n")); break; + case ::CORBA::tk_fixed: ACE_DEBUG ((LM_DEBUG, "tk_fixed\n")); break; + case ::CORBA::tk_value: ACE_DEBUG ((LM_DEBUG, "tk_value\n")); break; + case ::CORBA::tk_value_box: ACE_DEBUG ((LM_DEBUG, "tk_value_box\n")); break; + case ::CORBA::tk_native: ACE_DEBUG ((LM_DEBUG, "tk_native\n")); break; + case ::CORBA::tk_abstract_interface: ACE_DEBUG ((LM_DEBUG, "tk_abstract_interface\n")); break; + case ::CORBA::tk_local_interface: ACE_DEBUG ((LM_DEBUG, "tk_local_interface\n")); break; + case ::CORBA::tk_component: ACE_DEBUG ((LM_DEBUG, "tk_component\n")); break; + case ::CORBA::tk_home: ACE_DEBUG ((LM_DEBUG, "tk_home\n")); break; + case ::CORBA::tk_event: ACE_DEBUG ((LM_DEBUG, "tk_event\n")); break; + default: + break; + }; + } + + // ComponentInterfaceDescription + + void DnC_Dump::dump (const ::Deployment::ComponentInterfaceDescription &cid) + { + Dump_Obj dump_obj("ComponentInterfaceDescription"); + dump ("label", cid.label); + dump ("UUID", cid.UUID); + dump ("specificType", cid.specificType); + dump ("supportedType", cid.supportedType); + dump ("idlFile", cid.idlFile); + dump_sequence ("configProperty", cid.configProperty); + dump_sequence ("port", cid.port); + dump_sequence ("property", cid.property); + dump_sequence ("infoProperty", cid.infoProperty); + } + + // Requirement + + void DnC_Dump::dump (const ::Deployment::Requirement &req) + { + Dump_Obj dump_obj("Requirement"); + + dump ("resourceType", req.resourceType); + dump ("name", req.name); + dump_sequence ("property", req.property); + } + + // MonolithicDeploymentDescription + + void DnC_Dump::dump(const Deployment::MonolithicDeploymentDescription &mdd) + { + Dump_Obj dump_obj("MonolithicDeploymentDescription"); + + dump ("name", mdd.name); + dump ("source", mdd.source); + +#if (_MSC_VER) + dump_ref_seq<Deployment::DeploymentPlan> ("artifactRef", mdd.artifactRef, + "DeploymentPlan", + &DeploymentPlan::artifact); +#endif + dump_sequence ("execParameter", mdd.execParameter); + dump_sequence ("deployRequirement", mdd.deployRequirement); + } + + // ResourceUsageKind + + void DnC_Dump::dump(const Deployment::ResourceUsageKind &ruk) + { + ACE_DEBUG ((LM_DEBUG, "%sresourceUsage: ", Dump_Obj::indent())); + switch (ruk) { + case None: ACE_DEBUG ((LM_DEBUG, "None\n")); break; + case InstanceUsesResource: ACE_DEBUG ((LM_DEBUG, "InstanceUsesResource\n")); break; + case ResourceUsesInstance: ACE_DEBUG ((LM_DEBUG, "ResourceUsesInstance\n")); break; + case PortUsesResource: ACE_DEBUG ((LM_DEBUG, "PortUsesResource\n")); break; + case ResourceUsesPort: ACE_DEBUG ((LM_DEBUG, "ResourceUsesPort\n")); break; + } + } + + // InstanceResourceDeploymentDescription + + void DnC_Dump::dump(const Deployment::InstanceResourceDeploymentDescription &irdd) + { + Dump_Obj dump_obj("InstanceResourceDeploymentDescription"); + + dump (irdd.resourceUsage); + dump ("requirementName", irdd.requirementName); + dump ("resourceName", irdd.resourceName); + ACE_DEBUG ((LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + dump_sequence ("property", irdd.property); + } + + // InstanceDeploymentDescription + + void DnC_Dump::dump(const Deployment::InstanceDeploymentDescription &idd) + { + Dump_Obj dump_obj("InstanceDeploymentDescription"); + + dump ("name", idd.name); + dump ("node", idd.node); + dump ("source", idd.source); + +#if (_MSC_VER) + dump_ref<Deployment::DeploymentPlan> ("implementationRef", + idd.implementationRef, + "DeploymentPlan", + &DeploymentPlan::implementation); +#endif + dump_sequence ("configProperty", idd.configProperty); + dump_sequence ("deployedResource", idd.deployedResource); + dump_sequence ("deployedSharedResource", idd.deployedSharedResource); + } + + // ComponentExternalPortEndpoint + + void DnC_Dump::dump (const ::Deployment::ComponentExternalPortEndpoint &cepe) + { + Dump_Obj dump_obj("ComponentExternalPortEndpoint"); + + dump ("portName", cepe.portName); + } + + // PlanSubcomponentPortEndpoint + + void DnC_Dump::dump(const Deployment::PlanSubcomponentPortEndpoint &pspe) + { + Dump_Obj dump_obj("PlanSubcomponentPortEndpoint"); + + dump ("portName", pspe.portName); + dump ("provider", pspe.provider); + ACE_DEBUG ((LM_DEBUG, "%skind: ", Dump_Obj::indent())); + switch (pspe.kind) { + case Facet: ACE_DEBUG ((LM_DEBUG, "Facet\n")); break; + case SimplexReceptacle: ACE_DEBUG ((LM_DEBUG, "SimplexReceptacle\n")); break; + case MultiplexReceptacle: ACE_DEBUG ((LM_DEBUG, "MultiplexReceptacle\n")); break; + case EventEmitter: ACE_DEBUG ((LM_DEBUG, "EventEmitter\n")); break; + case EventPublisher: ACE_DEBUG ((LM_DEBUG, "EventPublisher\n")); break; + case EventConsumer: ACE_DEBUG ((LM_DEBUG, "EventConsumer\n")); break; + default: ACE_DEBUG ((LM_DEBUG, "Unknown port kind\n")); break; + } +#if (_MSC_VER) + dump_ref<Deployment::DeploymentPlan> ("instanceRef", pspe.instanceRef, + "DeploymentPlan", + &DeploymentPlan::instance); +#endif + } + + // ExternalReferenceEndpoint + + void DnC_Dump::dump (const ::Deployment::ExternalReferenceEndpoint &ere) + { + Dump_Obj dump_obj("ExternalReferenceEndpoint"); + + dump ("location", ere.location); + } + + // ConnectionResourceDeploymentDescription + + void DnC_Dump::dump(const Deployment::ConnectionResourceDeploymentDescription &crdd) + { + Dump_Obj dump_obj("ConnectionResourceDeploymentDescription"); + + dump ("targetName", crdd.targetName); + dump ("requirementName", crdd.requirementName); + dump ("resourceName", crdd.resourceName); + ACE_DEBUG ((LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + dump_sequence ("properties", crdd.property); + } + + // PlanConnectionDescription + + void DnC_Dump::dump(const Deployment::PlanConnectionDescription &pcd) + { + Dump_Obj dump_obj("PlanConnectionDescription"); + + dump ("name", pcd.name); + dump ("source", pcd.source); + dump_sequence ("deployRequirement", pcd.deployRequirement); + dump_sequence ("externalEndpoint", pcd.externalEndpoint); + dump_sequence ("internalEndpoint", pcd.internalEndpoint); + dump_sequence ("externalReference", pcd.externalReference); + dump_sequence ("deployedResource", pcd.deployedResource); + } + + // PlanSubcomponentPropertyReference + + void DnC_Dump::dump(const Deployment::PlanSubcomponentPropertyReference &pspr) + { + Dump_Obj dump_obj("PlanSubcomponentPropertyReference"); + + dump ("propertyName", pspr.propertyName); + +#if (_MSC_VER) + dump_ref<Deployment::DeploymentPlan> ("instanceRef", pspr.instanceRef, + "DeploymentPlan", + &DeploymentPlan::instance); +#endif + } + + // PlanPropertyMapping + + void DnC_Dump::dump(const Deployment::PlanPropertyMapping &ppm) + { + Dump_Obj dump_obj("PlanPropertyMapping"); + + dump ("name", ppm.name); + dump ("source", ppm.source); + dump ("externalName", ppm.externalName); + dump_sequence ("delegatesTo", ppm.delegatesTo); + } + + // ImplementationDependency + + void DnC_Dump::dump(const Deployment::ImplementationDependency &id) + { + Dump_Obj dump_obj("ImplementationDependency"); + + dump ("requiredType", id.requiredType); + } + + // ResourceDeploymentDescription + + void DnC_Dump::dump(const Deployment::ResourceDeploymentDescription &rdd) + { + Dump_Obj dump_obj("ResourceDeploymentDescription"); + + dump ("requirementName", rdd.requirementName); + dump ("resourceName", rdd.resourceName); + ACE_DEBUG ((LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + dump_sequence ("properties", rdd.property); + } + + // ArtifactDeploymentDescription + + void DnC_Dump::dump(const Deployment::ArtifactDeploymentDescription &add) + { + Dump_Obj dump_obj("ArtifactDeploymentDescription"); + + dump ("name", add.name); + dump ("location", add.location); + dump ("node", add.node); + dump ("source", add.source); + dump_sequence ("execParameter", add.execParameter); + dump_sequence ("deployRequirement", add.deployRequirement); + dump_sequence ("deployedResource", add.deployedResource); + } + + void DnC_Dump::dump(const Deployment::DeploymentPlan &plan) + { + CORBA::Any val; + + val <<= plan; + + Dump_Obj dump_obj("DeploymentPlan", val); + + dump ("label", plan.label); + dump ("UUID", plan.UUID); + dump (plan.realizes); + dump_sequence ("implementation", plan.implementation); + dump_sequence ("instance", plan.instance); + //dump_sequence ("connection", plan.connection); + dump_sequence ("externalProperty", plan.externalProperty); + dump_sequence ("dependsOn", plan.dependsOn); + dump_sequence ("artifact", plan.artifact); + dump_sequence ("infoProperty", plan.infoProperty); + } + + // ComponentPackageReference + + void DnC_Dump::dump (const ::Deployment::ComponentPackageReference &cpr) + { + Dump_Obj dump_obj("ComponentPackageReference"); + + dump ("requiredUUID", cpr.requiredUUID); + dump ("requiredName", cpr.requiredName); + dump ("requiredType", cpr.requiredType.specificType); + } + + // SubcomponentInstantiationDescription + + void DnC_Dump::dump (const ::Deployment::SubcomponentInstantiationDescription &sid) + { + Dump_Obj dump_obj("SubcomponentInstantiationDescription"); + + dump ("name", sid.name); + // dump_sequence ("basePackage", sid.package); + dump_sequence ("configProperty", sid.configProperty); + dump_sequence ("selectRequirement", sid.selectRequirement); + // dump_sequence ("reference", sid.reference); + } + + // SubcomponentPortEndpoint + + void DnC_Dump::dump (const ::Deployment::SubcomponentPortEndpoint& spe) + { + Dump_Obj dump_obj("SubcomponentPortEndpoint"); + + dump ("portName", spe.portName); + int value = spe.instanceRef; + ::Deployment::ComponentAssemblyDescription *v; + const CORBA::Any &a = + Dump_Obj::desc ("ComponentAssemblyDescription"); + + a >>= v; + + ACE_DEBUG ((LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), + v->instance[value].name.in ())); + } + + // AssemblyConnectionDescription + + void DnC_Dump::dump (const ::Deployment::AssemblyConnectionDescription &acd) + { + Dump_Obj dump_obj("AssemblyConnectionDescription"); + + dump ("name", acd.name); + dump_sequence ("deployRequirement", acd.deployRequirement); + dump_sequence ("externalEndpoint", acd.externalEndpoint); + dump_sequence ("internalEndpoint", acd.internalEndpoint); + dump_sequence ("externalReference", acd.externalReference); + } + + // SubcomponentPropertyReference + + void DnC_Dump::dump (const ::Deployment::SubcomponentPropertyReference &spr) + { + Dump_Obj dump_obj("SubcomponentPropertyReference"); + + dump ("propertyName", spr.propertyName); + int value = spr.instanceRef; + + ::Deployment::ComponentAssemblyDescription *v; + + const CORBA::Any &a = + Dump_Obj::desc ("ComponentAssemblyDescription"); + + a >>= v; + + ACE_DEBUG ((LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), + v->instance[value].name.in ())); + } + + void + DnC_Dump::dump (const ::Deployment::AssemblyPropertyMapping &apm) + { + Dump_Obj dump_obj("AssemblyPropertyMapping"); + + dump ("name", apm.name); + dump ("externalName", apm.externalName); + dump_sequence ("delegatesTo", apm.delegatesTo); + } + + // ComponentAssemblyDescription + + void DnC_Dump::dump (const ::Deployment::ComponentAssemblyDescription& cad) + { + CORBA::Any a; + a <<= cad; + + Dump_Obj dump_obj ("ComponentAssemblyDescription", + a); + + dump_sequence ("instance", cad.instance); + dump_sequence ("connection", cad.connection); + dump_sequence ("externalProperty", cad.externalProperty); + } + + // ImplementationArtifactDescription + + void DnC_Dump::dump (const ::Deployment::ImplementationArtifactDescription &iad) + { + Dump_Obj dump_obj("ImplementationArtifactDescription"); + + dump ("label", iad.label); + dump ("UUID", iad.UUID); + dump ("location", iad.location); + dump_sequence ("execParameter", iad.execParameter); + dump_sequence ("deployRequirement", iad.deployRequirement); + dump_sequence ("dependsOn", iad.dependsOn); + dump_sequence ("infoProperty", iad.infoProperty); + } + + // NamedImplementationArtifact + + void DnC_Dump::dump (const ::Deployment::NamedImplementationArtifact &nia) + { + Dump_Obj dump_obj("NamedImplementationArtifact"); + + dump ("name", nia.name); + dump (nia.referencedArtifact); + } + + // ImplementationRequirement + + void DnC_Dump::dump (const ::Deployment::ImplementationRequirement &ir) + { + Dump_Obj dump_obj("ImplementationRequirement"); + + dump_sequence ("resourceUsage", ir.resourceUsage); + dump ("resourcePort", ir.resourcePort); + dump ("componentPort", ir.componentPort); + dump ("resourceType", ir.resourceType); + dump ("name", ir.name); + dump_sequence ("property", ir.property); + } + + // MonolithicImplementationDescription + + void DnC_Dump::dump (const ::Deployment::MonolithicImplementationDescription + &mid) + { + Dump_Obj dump_obj("MonolithicImplementationDescription"); + + // dump_sequence ("execParameter", mid.execParameter); + dump_sequence ("primaryArtifact", mid.primaryArtifact); + dump_sequence ("deployRequirement", mid.deployRequirement); + } + + void + DnC_Dump::dump (const ::Deployment::Capability &capability) + { + Dump_Obj dump_obj("Capability"); + + dump ("name", capability.name); + DnC_Dump::dump ("resourceType", capability.resourceType); + dump_sequence ("property", + capability.property); + } + + // ComponentImplementationDescription + + void DnC_Dump::dump ( + const ::Deployment::ComponentImplementationDescription &cid) + { + Dump_Obj dump_obj("ComponentImplementationDescription"); + + dump ("label", cid.label); + dump ("UUID", cid.UUID); + ACE_DEBUG ((LM_DEBUG, "%sImplements:\n", Dump_Obj::indent())); + dump (cid.implements); + dump_sequence ("assemblyImpl", cid.assemblyImpl); + dump_sequence ("monolithicImpl", cid.monolithicImpl); + dump_sequence ("configProperty", cid.configProperty); + dump_sequence ("capability", cid.capability); + dump_sequence ("dependsOn", cid.dependsOn); + dump_sequence ("infoProperty", cid.infoProperty); + } + + // PackagedComponentImplementation + + void DnC_Dump::dump (const ::Deployment::PackagedComponentImplementation &pci) + { + Dump_Obj dump_obj("PackagedComponentImplementation"); + + dump ("Name", pci.name); + ACE_DEBUG ((LM_DEBUG, + "%sreferencedImplementation:\n", Dump_Obj::indent())); + DnC_Dump::dump (pci.referencedImplementation); + } + + // ComponentPackageDescription + + void DnC_Dump::dump (const ::Deployment::ComponentPackageDescription + &comppkgdesc) + { + Dump_Obj dump_obj("ComponentPackageDescription"); + + dump ("label", comppkgdesc.label); + dump ("UUID", comppkgdesc.UUID); + ACE_DEBUG ((LM_DEBUG, "%srealizes:\n", Dump_Obj::indent ())); + DnC_Dump::dump (comppkgdesc.realizes); // ComponentInterfaceDescription + dump_sequence ("configProperty", comppkgdesc.configProperty); + dump_sequence ("implementation", comppkgdesc.implementation); + dump_sequence ("infoProperty", comppkgdesc.infoProperty); + } + + // PackageConfiguration + + void DnC_Dump::dump (const ::Deployment::PackageConfiguration &pc) + { + Dump_Obj dump_obj("PackageConfiguration"); + + dump ("label", pc.label); + dump ("UUID", pc.UUID); + dump_sequence ("specializedConfig", pc.specializedConfig); + dump_sequence ("basePackage", pc.basePackage); + dump_sequence ("reference", pc.referencedPackage); + dump_sequence ("selectRequirement", pc.selectRequirement); + dump_sequence ("configProperty", pc.configProperty); + } + + // Property + void DnC_Dump::dump (const Deployment::Property& property) + { + Dump_Obj dump_obj("Property"); + dump ("name", property.name); + ACE_DEBUG ((LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); + dump (property.value); + } + + // CORBA::Any + + void DnC_Dump::dump (const ::CORBA::Any &any) + { + ::CORBA::TypeCode * type = any.type (); + switch (type->kind ()) + { + case CORBA::tk_short: + { + CORBA::Short temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC_Dump::dump (CORBA::Any), expected short\ +encoded different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_null: + ACE_DEBUG ((LM_DEBUG, "%sAny value: null value encoded\n", + Dump_Obj::indent ())); + break; + + case CORBA::tk_void: + ACE_DEBUG ((LM_DEBUG, "Any value: void type encoded\n")); + break; + case CORBA::tk_long: + { + CORBA::Long temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected long\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_ushort: + { + CORBA::UShort temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected u short\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_ulong: + { + CORBA::ULong temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected ulong\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_float: + { + CORBA::Float temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected float\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), + temp)); + } + break; + case CORBA::tk_double: + { + CORBA::Double temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected double\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), + temp)); + } + break; + case CORBA::tk_boolean: + { + CORBA::Boolean temp; + if (! (any >>= CORBA::Any::to_boolean (temp))) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected bool\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + + if (temp) + ACE_DEBUG ((LM_DEBUG, "Any value: True\n")); + else + ACE_DEBUG ((LM_DEBUG, "Any value: False\n")); + } + break; + + case CORBA::tk_char: + { + CORBA::Char temp; + if (! (any >>= CORBA::Any::to_char (temp))) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected char\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_octet: + { + CORBA::Octet temp; + if (! (any >>= CORBA::Any::to_octet (temp))) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected octet\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_string: + { + const char * temp = 0; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected string\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (), + temp)); + } + break; + case CORBA::tk_longlong: + { + CORBA::LongLong temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected longlong\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %l\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_longdouble: + { + CORBA::LongDouble temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected longdouble\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); + } + + break; + case CORBA::tk_wchar: + { + CORBA::WChar temp; + if (! (any >>= CORBA::Any::to_wchar (temp))) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected wchar\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_wstring: + { + const CORBA::WChar * temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected wstring\ +encoded with different type")); + throw CORBA::INTERNAL (); + } + ACE_DEBUG ((LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (), + temp)); + } + break; + + case CORBA::tk_enum: + { +/* CORBA::Enum temp; + if (! (any >>= temp)) + { + ACE_DEBUG ((LM_DEBUG, "DnC::dump (CORBA::Any) expected enum \ +encoded with different type")); + throw CORBA::INTERNAL (); + } +*/ ACE_DEBUG ((LM_DEBUG, "%sAny value: some enum\n", Dump_Obj::indent ())); + } + break; + + default: + ACE_DEBUG ((LM_DEBUG, "Unknown type encoded in Any\n")); + throw CORBA::INTERNAL (); + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DnC_Dump.h b/modules/CIAO/tools/Config_Handlers/DnC_Dump.h new file mode 100644 index 00000000000..4cddf38cc31 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DnC_Dump.h @@ -0,0 +1,153 @@ +//================================================================== +/** +* @file DnC_Dump.h +* +* $Id$ +* +* @author Gan Deng <gan.deng@vanderbilt.edu> +*/ +//===================================================================== + +#ifndef DNC_DUMP_H +#define DNC_DUMP_H +#include /**/ "ace/pre.h" + +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "DAnCE/Deployment/Deployment_TargetDataC.h" +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace Deployment +{ + +/** +* @class DnC_Dump +* +* @brief This class defines a set of overloaded "dump" methods to print +* the contents of various IDL data types, which passed as input. +*/ +class Config_Handlers_Export DnC_Dump +{ +public: +/// Dump functions for CORBA sequences +static void dump (const char* caption, +const ::CORBA::StringSeq &str_seq); + +static void dump (const char* caption, const TAO::String_Manager& str); + +static void dump (const char* caption, const CORBA::Boolean& val); + +/// A whole slew of overloaded dump routines for different IDL +/// data types. + +static void dump(const Deployment::SatisfierProperty &sp); + +static void dump (const Deployment::SharedResource& sr); + +static void dump (const Deployment::Node& node); + +static void dump (const Deployment::Resource& resource); + +static void dump (const Deployment::Interconnect& conn); + +static void dump (const Deployment::Bridge& bridge); + +static void dump (const ::Deployment::Property &property); + +static void dump (const ::Deployment::AssemblyConnectionDescription &acd); + +static void dump (const ::Deployment::AssemblyPropertyMapping &apm); + +static void dump (const ::Deployment::ComponentPackageDescription +&comppkgdesc); + +static void dump (const ::Deployment::ComponentPortDescription +&compportdesc); + +static void dump (const ::Deployment::ComponentPropertyDescription +&comppropdesc); + +static void dump (const ::Deployment::MonolithicImplementationDescription +&mid); + +static void dump (const ::Deployment::PackageConfiguration &pc); + +static void dump (const ::Deployment::PackagedComponentImplementation +&pci); + +static void dump (const ::Deployment::SubcomponentPortEndpoint &spe); + +static void dump (const ::Deployment::Requirement &requirement); + +static void dump (const ::Deployment::ComponentExternalPortEndpoint +&cepe); + +static void dump (const ::Deployment::ComponentPackageReference &cpr); + +static void dump (const ::Deployment::ComponentImplementationDescription +&cid); + +static void dump (const ::Deployment::SubcomponentInstantiationDescription +&sid); + +static void dump (const ::Deployment::NamedImplementationArtifact +&named_implementation); + +static void dump (const ::Deployment::ComponentInterfaceDescription &cid); + +static void dump (const ::Deployment::SubcomponentPropertyReference +&scpr); + +static void dump (const ::Deployment::ExternalReferenceEndpoint &ere); + +static void dump (const ::Deployment::Domain &domain); + +static void dump (const ::Deployment::Capability &capability); + +static void dump (const ::Deployment::ImplementationArtifactDescription +&iad); + +static void dump (const ::Deployment::ImplementationRequirement &ir); + +static void dump(const Deployment::ResourceUsageKind &ruk); + +static void dump(const Deployment::DeploymentPlan &plan); + +static void dump(const Deployment::MonolithicDeploymentDescription &mdd); + +static void dump(const Deployment::InstanceDeploymentDescription &idd); + +static void dump(const Deployment::PlanConnectionDescription &pcd); + +static void dump(const Deployment::PlanPropertyMapping &ppm); + +static void dump(const Deployment::ImplementationDependency &id); + +static void dump(const Deployment::ArtifactDeploymentDescription &add); + +static void dump(const Deployment::InstanceResourceDeploymentDescription +&irdd); + +static void dump(const PlanSubcomponentPortEndpoint &pspe); + +static void dump(const ConnectionResourceDeploymentDescription &crdd); + +static void dump(const PlanSubcomponentPropertyReference &pspr); + +static void dump(const ResourceDeploymentDescription &rdd); + +static void dump (const ::Deployment::ComponentAssemblyDescription& cad); + +private: +static void dump (const ::CORBA::Any &any); +// Helper function to print an Any +}; +} + +#include /**/ "ace/post.h" + +#endif /* DNC_DUMP_H */ diff --git a/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.cpp b/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.cpp new file mode 100644 index 00000000000..0f95945fb0f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.cpp @@ -0,0 +1,90 @@ +// $Id$ +#ifndef DNC_DUMP_T_C +#define DNC_DUMP_T_C +#include "DnC_Dump.h" +#include "DnC_Dump_T.h" +#include "Dump_Obj.h" + +ACE_RCSID (Config_Handlers, + DnC_Dump_T, + "$Id$") + namespace Deployment + { + namespace DnC_Dump_T + { + // Dumps a reference + template <typename ROOT, typename REFERENCE, typename DATA_TYPE, + typename CLASS> + void + dump_ref (const char* caption, REFERENCE& ref, + const char* root, DATA_TYPE CLASS::*data) + { + ACE_DEBUG ((LM_DEBUG, "%s%s:\n", + Dump_Obj::indent(), caption)); + + const CORBA::Any &val = Dump_Obj::desc (root); + + ROOT *t = 0; + + val >>= t; + + const ROOT &root_obj = *t; + + int value = ref; + ACE_DEBUG ((LM_DEBUG, "%s%s.name: %s\n", + Dump_Obj::indent(), caption, + (root_obj.*data)[value].name.in())); + } + + // Dumps a reference sequence + template <typename ROOT, typename SEQUENCE, typename DATA_TYPE, + typename CLASS> + void + dump_ref_seq (const char* caption, SEQUENCE& seq, + const char* root, DATA_TYPE CLASS::*data) + { + ACE_DEBUG ((LM_DEBUG, + "%s%s:\n", + Dump_Obj::indent(), caption)); + + CORBA::Any val; + val <<= root; + + for (size_t i = 0; i < seq.length(); ++i) + { + const CORBA::Any &val = Dump_Obj::desc (root); + + ROOT *t = 0; + + val >>= t; + + const ROOT &root_obj = *t; + int value = seq[i]; + ACE_DEBUG ((LM_DEBUG, "%s%s[%d].name: %s\n", + Dump_Obj::indent(), caption, i, + (root_obj.*data)[value].name.in())); + } + } + + // Dumps a sequence + template <typename SEQUENCE> + void + dump_sequence (const char* caption, const SEQUENCE &seq) + { + CORBA::ULong size = seq.length (); + + if (size != 0) + { + Dump_Obj dump_obj(caption); + + for (CORBA::ULong i = 0; i < size; ++i) + { + ACE_DEBUG ((LM_DEBUG, "%s%s %d:\n", Dump_Obj::indent(), + caption, i)); + DnC_Dump::dump (seq[i]); + } + } + } + } + } +#endif /* DNC_DUMP_C */ diff --git a/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.h b/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.h new file mode 100644 index 00000000000..88a5c55f3cd --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DnC_Dump_T.h @@ -0,0 +1,50 @@ +//================================================================== +/** +* @file DnC_Dump_T.h +* +* $Id$ +* +* @author Gan Deng <gan.deng@vanderbilt.edu> +*/ +//===================================================================== + +#ifndef CIAO_CONFIG_HANDLERS_DNC_DUMP_T_H +#define CIAO_CONFIG_HANDLERS_DNC_DUMP_T_H +#include /**/ "ace/pre.h" + +#include "ace/config-lite.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ +namespace DnC_Dump_T +{ +template <typename SEQUENCE> +void dump_sequence (const char* caption, const SEQUENCE &seq); + +template <typename ROOT, typename SEQUENCE, +typename DATA_TYPE, typename CLASS> +void dump_ref_seq (const char* caption, SEQUENCE& seq, +const char* root, DATA_TYPE CLASS::*data); + +template <typename ROOT, typename REFERENCE, typename DATA_TYPE, +typename CLASS> +void dump_ref (const char* caption, REFERENCE& ref, +const char* root, DATA_TYPE CLASS::*data); +} +} + +#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) +#include "DnC_Dump_T.cpp" +#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ + +#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) +#pragma implementation ("DnC_Dump_T.cpp") +#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ + + +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_HANDLERS_DNC_DUMP_T_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Dump_Obj.cpp b/modules/CIAO/tools/Config_Handlers/Dump_Obj.cpp new file mode 100644 index 00000000000..b2cc34fd089 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Dump_Obj.cpp @@ -0,0 +1,65 @@ +// $Id$ +#include "Dump_Obj.h" +#include "ace/Log_Msg.h" + +ACE_RCSID (Config_Handlers, + Dump_Obj, + "$Id$") + + namespace Deployment + { + // static member initialization + std::string Dump_Obj::indent_ = "-"; + std::map<std::string, CORBA::Any> Dump_Obj::desc_map_; + + Dump_Obj::Dump_Obj(const char* caption) + : desc_() + { + ACE_DEBUG ((LM_DEBUG, "%C%C:\n", indent_.c_str(), caption)); + indent_.append(" "); + } + + + Dump_Obj::Dump_Obj(const char* caption, + CORBA::Any &val) + : desc_(caption) + { + ACE_DEBUG ((LM_DEBUG, "%C%C:\n", + indent_.c_str(), + caption)); + + indent_.append(" "); + + if (desc_map_.find (std::string (caption)) != desc_map_.end()) + { + ACE_DEBUG ((LM_DEBUG, "DnC_Dump.cpp:Dump_Obj - \ +The item with name %C is already in \ +the node map.\n", caption)); + throw Node_Exist(); + } + else + { + desc_map_[std::string(caption)] = val; + } + } + + Dump_Obj::~Dump_Obj() + { + indent_.erase(indent_.size() - 2, 2); + if (desc_.size() != 0) + { + if (desc_map_.find(desc_) != desc_map_.end()) + { + desc_map_.erase(desc_map_.find(desc_)); + } + else + { + ACE_DEBUG ((LM_DEBUG, "DnC_Dump.cpp:Dump_Obj - \ +The item with name %C is not in the node map.\n", + desc_.c_str())); + throw Node_Not_Exist(); + } + } + } + + } diff --git a/modules/CIAO/tools/Config_Handlers/Dump_Obj.h b/modules/CIAO/tools/Config_Handlers/Dump_Obj.h new file mode 100644 index 00000000000..babffe43bac --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Dump_Obj.h @@ -0,0 +1,77 @@ +//================================================================== +/** +* @file Dump_Obj.h +* +* $Id$ +* +* @author Gan Deng <gan.deng@vanderbilt.edu> +*/ +//===================================================================== + +#ifndef CIAO_DUMP_OBJ_H +#define CIAO_DUMP_OBJ_H +#include /**/ "ace/pre.h" + +#include "DAnCE/Deployment/DeploymentC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "Config_Handlers_Export.h" +#include "tao/AnyTypeCode/Any.h" +#include <string> +#include <map> + +namespace Deployment +{ +/* +* @brief class Dump_Obj handles the indentation and keeps a map of +* structures for reference look-up. +*/ +class Config_Handlers_Export Dump_Obj +{ + public: + /// Exception thrown when there is a node with the same name in the + /// map + class Node_Exist { }; + + /// Exception thrown when there is no node with the name given in + /// the map + class Node_Not_Exist { }; + + /// Constructors prints out the caption and increases indent + Dump_Obj (const char *caption); + + /// Additionally insets @a val into the map + Dump_Obj (const char* caption, CORBA::Any &val); + + /// Destructor + ~Dump_Obj (void); + + /// return the indent string + static const char* indent() + { + return indent_.c_str(); + } + + static CORBA::Any& desc(const char* caption) + { + return desc_map_[caption]; + } + +private: + /// indent string + static std::string indent_; + + /// map for reference lookup + static std::map<std::string, CORBA::Any> desc_map_; + + /// descriptor - used by destructor for deleting the + /// correct descriptor from the map + std::string desc_; +}; +} + +#include /**/ "ace/post.h" +#endif /*CIAO_DUMP_OBJ_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler.mpc b/modules/CIAO/tools/Config_Handlers/DynAny_Handler.mpc new file mode 100644 index 00000000000..c5cc64b7a34 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler.mpc @@ -0,0 +1,22 @@ +// $Id$ + +project (XSC_DynAny_Handler) : xerces, dynamicany, typecodefactory, dance_deployment_stub, \ + ciao_config_handlers_base, ciao_lib, dance, ifr_client { + after += XSC_XML_Handlers + libs += XSC_XML_Handlers + dynamicflags += DYNANY_HANDLER_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + + Source_Files { + DynAny_Handler/DynAny_Handler.cpp + DynAny_Handler/DynEnum_Handler.cpp + DynAny_Handler/DynSequence_Handler.cpp + DynAny_Handler/DynStruct_Handler.cpp + DynAny_Handler/DynAlias_Handler.cpp + } + + Header_Files { + DynAny_Handler_Export.h + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp new file mode 100644 index 00000000000..0e2bfe0e411 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp @@ -0,0 +1,181 @@ +//$Id$ + +#include "DataType_Handler.h" +#include "tao/AnyTypeCode/TypeCode.h" + +namespace CIAO{ + + namespace Config_Handlers{ + + DataType_Handler::DataType_Handler (void) + { + } + DataType_Handler::~DataType_Handler (void) + { + } + + ///This method takes a <CIAO::Config_Handlers::DataType> + ///and returns the corresponding CORBA::TypeCode. + CORBA::TypeCode_ptr + DataType_Handler::data_type (const DataType& desc) + { + + TCKind kind (desc.kind ()); + + switch (kind.integral ()) + { + case TCKind::tk_null_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_null); + + + case TCKind::tk_short_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_short); + + + case TCKind::tk_long_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_long); + + + case TCKind::tk_ushort_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ushort); + + + case TCKind::tk_ulong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ulong); + + + case TCKind::tk_float_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_float); + + + case TCKind::tk_double_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_double); + + + case TCKind::tk_boolean_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_boolean); + + + case TCKind::tk_char_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_char); + + + case TCKind::tk_octet_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_octet); + + + case TCKind::tk_string_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_string); + + + case TCKind::tk_longlong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_longlong); + + + case TCKind::tk_ulonglong_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_ulonglong); + + + case TCKind::tk_longdouble_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_longdouble); + + + case TCKind::tk_wchar_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_wchar); + + + case TCKind::tk_wstring_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_wstring); + + + case TCKind::tk_any_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_any); + + + case TCKind::tk_TypeCode_l: + return CORBA::TypeCode::_duplicate (CORBA::_tc_TypeCode); + + + default: + ACE_ERROR ((LM_ERROR, "Invalid typecode in any\n")); + throw Config_Error ("", "Invalid typecode"); + } + + // This case used to be supported...is it not in the schema? + // case TCKind::tk_Object) + // return CORBA::TypeCode::_duplicate (CORBA::_tc_Object);*/ + + } + + DataType + DataType_Handler::data_type ( + const CORBA::TypeCode_ptr& src) + { + DataType type; + + switch (src->kind ()) + { + case ::CORBA::tk_null: + type.kind (TCKind::tk_null); + break; + case CORBA::tk_short: + type.kind (TCKind::tk_short); + break; + case CORBA::tk_long: + type.kind (TCKind::tk_long); + break; + case CORBA::tk_ushort: + type.kind (TCKind::tk_ushort); + break; + case CORBA::tk_ulong: + type.kind (TCKind::tk_ulong); + break; + case CORBA::tk_float: + type.kind (TCKind::tk_float); + break; + case CORBA::tk_double: + type.kind (TCKind::tk_double); + break; + case CORBA::tk_boolean: + type.kind (TCKind::tk_boolean); + break; + case CORBA::tk_char: + type.kind (TCKind::tk_char); + break; + case CORBA::tk_octet: + type.kind (TCKind::tk_octet); + break; + case CORBA::tk_string: + type.kind (TCKind::tk_string); + break; + case CORBA::tk_longlong: + type.kind (TCKind::tk_longlong); + break; + case CORBA::tk_ulonglong: + type.kind (TCKind::tk_ulonglong); + break; + case CORBA::tk_longdouble: + type.kind (TCKind::tk_longdouble); + break; + case CORBA::tk_wchar: + type.kind (TCKind::tk_wchar); + break; + case CORBA::tk_wstring: + type.kind (TCKind::tk_wstring); + break; + case CORBA::tk_any: + type.kind (TCKind::tk_any); + break; + case CORBA::tk_TypeCode: + type.kind (TCKind::tk_TypeCode); + default: + ACE_ERROR ((LM_ERROR, "Invalid typecode\n")); + throw Config_Error ("", "Invalid typecode"); + } + + return type; + } + + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h new file mode 100644 index 00000000000..c16b4b21fe3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h @@ -0,0 +1,60 @@ +//================================================ +/** + * @file DataType_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef DATATYPE_HANDLER_H +#define DATATYPE_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "ciao/DeploymentC.h" +#include "Basic_Deployment_Data.hpp" + + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO{ + + namespace Config_Handlers{ + + /* + * @class DataType_Handler + * + * @brief Handler class for <ComponentPortDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + + class DataType_Handler{ + + public: + + DataType_Handler (void); + virtual ~DataType_Handler (void); + + ////This method takes a <CIAO::Config_Handlers::DataType> + ///and returns the corresponding CORBA::TypeCode. + static void + data_type (CORBA::TypeCode_ptr& type, + const DataType& desc); + + static DataType data_type (const CORBA::TypeCode_ptr& type); + }; + + } +} + +#include /**/ "ace/post.h" +#endif /* DATATYPE_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.cpp new file mode 100644 index 00000000000..a16e5c882c1 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.cpp @@ -0,0 +1,195 @@ +// $Id$ + +#include "DynAlias_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "Common.h" + +#include "tao/AnyTypeCode/TypeCode.h" +#include "tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h" +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/AnyTypeCode/Enum_TypeCode.h" +#include "tao/IFR_Client/IFR_BasicC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + DynamicAny::DynAny_ptr + DynAlias_Handler::extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr req_tc) + { + try + { + CORBA::TypeCode_ptr tc; + + if (req_tc) + tc = req_tc; + else + tc = DynAlias_Handler::create_typecode (type); + + // Make the actual DynAlias + // DynamicAny::DynAny_var retval = + //DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc); + // DynamicAny::DynAlias_var retval = DynamicAny::DynAlias::_narrow (temp.in ()); + + DynamicAny::DynAny_var alias = DYNANY_HANDLER->extract_into_dynany (type.alias ().elementType (), value, tc); + return alias._retn (); + /* + switch (type.kind ().integral ()) + { + // ========== BASIC TYPES + case TCKind::tk_null_l: + case TCKind::tk_void_l: + ACE_ERROR ((LM_WARNING, "I don't know how to handle null or void types\n")); + + case TCKind::tk_short_l: + retval->insert_short (CORBA::Short (static_cast < ::XMLSchema::short_ const & > (*value.begin_short ()))); + break; + + case TCKind::tk_long_l: + retval->insert_long (CORBA::Long (static_cast < ::XMLSchema::int_ const& > (*value.begin_long ()))); + break; + + case TCKind::tk_ushort_l: + retval->insert_ushort (CORBA::UShort (static_cast< ::XMLSchema::unsignedShort const & > (*value.begin_ushort ()))); + break; + + case TCKind::tk_ulong_l: + retval->insert_ulong (CORBA::ULong (static_cast < ::XMLSchema::unsignedInt const& > (*value.begin_ulong ()))); + break; + + case TCKind::tk_float_l: + retval->insert_float (CORBA::Float (*value.begin_float ())); + break; + + case TCKind::tk_double_l: + retval->insert_double (CORBA::Double (*value.begin_double ())); + break; + + case TCKind::tk_boolean_l: + retval->insert_boolean (static_cast < ::XMLSchema::boolean const& > (*value.begin_boolean ())); + break; + + case TCKind::tk_char_l: + retval->insert_char (CORBA::Char (*value.begin_string ()->c_str ())); + break; + + case TCKind::tk_octet_l: + retval->insert_octet (static_cast <const unsigned char &> (*value.begin_octet ())); + break; + + case TCKind::tk_string_l: + retval->insert_string (value.begin_string ()->c_str ()); + break; + + case TCKind::tk_longlong_l: + retval->insert_longlong (CORBA::LongLong (static_cast < ::XMLSchema::long_ const& > (*value.begin_longlong ()))); + break; + + case TCKind::tk_ulonglong_l: + retval->insert_ulonglong (CORBA::ULongLong (static_cast < ::XMLSchema::unsignedLong const& > (*value.begin_ulonglong ()))); + break; + + case TCKind::tk_wchar_l: + retval->insert_wchar (CORBA::WChar (*value.begin_string ()->c_str ())); + break; + + case TCKind::tk_enum_l: + return DynEnum_Handler::extract_into_dynany (type, value); + + case TCKind::tk_sequence_l: + return DynSequence_Handler::extract_into_dynany (type, value); + + case TCKind::tk_struct_l: + return DynStruct_Handler::extract_into_dynany (type, value); + + case TCKind::tk_alias_l: + return DynAlias_Handler::extract_into_dynany (type, value); + + case TCKind::tk_longdouble_l: + case TCKind::tk_wstring_l: + case TCKind::tk_wfixed_l: + case TCKind::tk_any_l: + case TCKind::tk_TypeCode_l: + case TCKind::tk_Principal_l: + case TCKind::tk_objref_l: + case TCKind::tk_union_l: + case TCKind::tk_array_l: + case TCKind::tk_except_l: + case TCKind::tk_value_l: + case TCKind::tk_value_box_l: + case TCKind::tk_native_l: + case TCKind::tk_abstract_interface_l: + case TCKind::tk_local_interface_l: + case TCKind::tk_component_l: + case TCKind::tk_home_l: + case TCKind::tk_event_l: + ACE_ERROR ((LM_ERROR, "Type not supported\n")); + throw Config_Error ("", "Type not supported"); + } + */ + // retval->assign (alias); + + // return retval._retn (); + } + catch (DynamicAny::DynAny::InvalidValue) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Invalid value provided in XML when trying to ") + ACE_TEXT ("initialize an instance of enumerated type %s\n"), + type.alias ().typeId ().c_str ())); + throw Config_Error (type.alias ().typeId (), + ACE_TEXT ("Invalid value provided in XML")); + } + catch (Config_Error &ex) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("DynAlias_Handler caught Config_Error\n"))); + if (type.alias_p ()) + ex.add_name (type.alias ().typeId ()); + + throw ex; + } + catch (...) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("DynAlias_Handler caught unknown exception\n"))); + throw Config_Error (type.alias ().typeId (), + ACE_TEXT ("Unknown exception")); + } + } + + void + DynAlias_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Extracting Enums not yet supported\n"))); + } + + CORBA::TypeCode_ptr + DynAlias_Handler::create_typecode (const DataType &type) + { + if (!type.alias_p ()) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Alias type description required"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Did not find expected alias type description, tk_kind may be wrong.")); + } + + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_alias_tc + (ACE_TEXT_ALWAYS_CHAR (type.alias ().typeId ().c_str ()), + ACE_TEXT_ALWAYS_CHAR (type.alias ().name ().c_str ()), + DYNANY_HANDLER->create_typecode (type.alias ().elementType ())); + + DYNANY_HANDLER->register_typecode (type.alias ().typeId (), + tc); + + return tc; + } + + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.h new file mode 100644 index 00000000000..b5bca3c7377 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.h @@ -0,0 +1,52 @@ +/** + * $Id$ + * + * @file DynAlias_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ + +#ifndef CIAO_CONFIG_HANDLERS_DYNALIAS_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNALIAS_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class DynAlias_Handler + * @brief Translates enums specified in deployment plans into Dynamic Anys + * + */ + class DynAlias_Handler + { + public: + static DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr = 0); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + + static CORBA::TypeCode_ptr create_typecode (const DataType &type); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H*/ + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp new file mode 100644 index 00000000000..151591af591 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp @@ -0,0 +1,379 @@ +// $Id$ + +#include /**/ "ace/pre.h" + +#include "DynAny_Handler.h" +#include "DynEnum_Handler.h" +#include "DynSequence_Handler.h" +#include "DynStruct_Handler.h" +#include "DynAlias_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "Common.h" + +namespace CIAO +{ + namespace Config_Handlers + { + DynAny_Handler::DynAny_Handler (void) : + orb_ (0), + daf_ (0) + { + int argc = 0; + char **argv = 0; + + orb_ = CORBA::ORB_init (argc, argv); + + CORBA::Object_var temp = orb_->resolve_initial_references ("DynAnyFactory"); + daf_ = DynamicAny::DynAnyFactory::_narrow (temp.in ()); + + if (CORBA::is_nil (daf_.in ())) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to narrow Dynamic Any factory\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Unable to narrow DynAny factory")); + } + } + + DynAny_Handler::~DynAny_Handler (void) + { + } + + CORBA::ORB_ptr + DynAny_Handler::orb () + { + return orb_.in (); + } + + DynamicAny::DynAnyFactory_ptr + DynAny_Handler::daf () + { + return daf_.in (); + } + + DynamicAny::DynAny_ptr + DynAny_Handler::extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr req_tc) + { + DynamicAny::DynAny_var retval; + + if (req_tc) + retval = this->daf_->create_dyn_any_from_type_code (req_tc); + + switch (type.kind ().integral ()) + { + // ========== BASIC TYPES + case TCKind::tk_null_l: + case TCKind::tk_void_l: + ACE_ERROR ((LM_WARNING, ACE_TEXT ("I don't know how to handle null or void types\n"))); + + case TCKind::tk_short_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_short); + retval->insert_short (CORBA::Short (static_cast < ::XMLSchema::short_ const & > (*(*value.begin_short ())))); + break; + + case TCKind::tk_long_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_long); + retval->insert_long (CORBA::Long (static_cast < ::XMLSchema::int_ const& > (*(*value.begin_long ())))); + break; + + case TCKind::tk_ushort_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ushort); + retval->insert_ushort (CORBA::UShort (static_cast< ::XMLSchema::unsignedShort const & > (*(*value.begin_ushort ())))); + break; + + case TCKind::tk_ulong_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulong); + retval->insert_ulong (CORBA::ULong (static_cast < ::XMLSchema::unsignedInt const& > (*(*value.begin_ulong ())))); + break; + + case TCKind::tk_float_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_float); + retval->insert_float (CORBA::Float (*value.begin_float ())); + break; + + case TCKind::tk_double_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_double); + retval->insert_double (CORBA::Double (*value.begin_double ())); + break; + + case TCKind::tk_boolean_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_boolean); + retval->insert_boolean (static_cast < ::XMLSchema::boolean const& > (*(*value.begin_boolean ()))); + break; + + case TCKind::tk_char_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_char); + retval->insert_char (CORBA::Char (*(*value.begin_string ())->c_str ())); + break; + + case TCKind::tk_octet_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_octet); + retval->insert_octet (static_cast <const unsigned char &> (*(*(value.begin_octet ())))); + break; + + case TCKind::tk_string_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_string); + retval->insert_string (ACE_TEXT_ALWAYS_CHAR ((*value.begin_string ())->c_str ())); + break; + + case TCKind::tk_longlong_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_longlong); + retval->insert_longlong (CORBA::LongLong (static_cast < ::XMLSchema::long_ const& > (*(*value.begin_longlong ())))); + break; + + case TCKind::tk_ulonglong_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_ulonglong); + retval->insert_ulonglong (CORBA::ULongLong (static_cast < ::XMLSchema::unsignedLong const& > (*(*value.begin_ulonglong ())))); + break; + + case TCKind::tk_wchar_l: + if (!req_tc) retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_wchar); + retval->insert_wchar (CORBA::WChar (*(*value.begin_string ())->c_str ())); + break; + + case TCKind::tk_enum_l: + return DynEnum_Handler::extract_into_dynany (type, value, req_tc); + + case TCKind::tk_sequence_l: + return DynSequence_Handler::extract_into_dynany (type, value, req_tc); + + case TCKind::tk_struct_l: + return DynStruct_Handler::extract_into_dynany (type, value, req_tc); + + case TCKind::tk_alias_l: + return DynAlias_Handler::extract_into_dynany (type, value, req_tc); + + case TCKind::tk_longdouble_l: + case TCKind::tk_wstring_l: + case TCKind::tk_fixed_l: + case TCKind::tk_any_l: + case TCKind::tk_TypeCode_l: + case TCKind::tk_Principal_l: + case TCKind::tk_objref_l: + case TCKind::tk_union_l: + case TCKind::tk_array_l: + case TCKind::tk_except_l: + case TCKind::tk_value_l: + case TCKind::tk_value_box_l: + case TCKind::tk_native_l: + case TCKind::tk_abstract_interface_l: + case TCKind::tk_local_interface_l: + case TCKind::tk_component_l: + case TCKind::tk_home_l: + case TCKind::tk_event_l: + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Type not supported\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported")); + } + + return retval._retn (); + } + + Any + DynAny_Handler::extract_from_dynany (const CORBA::Any &any) + { + DynamicAny::DynAny_var dyn = this->daf_->create_dyn_any (any); + + DataValue val; +#if 0 + switch (dyn->type ()->kind ()) + { + case CORBA::tk_short: + val.add_short (dyn->get_short ()); + return Any (TCKind::tk_short, val); + + case CORBA::tk_long: + val.add_long (dyn->get_long ()); + return Any (TCKind::tk_long, val); + + case CORBA::tk_ushort: + val.add_ushort (dyn->get_ushort ()); + return Any (TCKind::tk_ushort, val); + + case CORBA::tk_ulong: + val.add_ulong (dyn->get_ulong ()); + return Any (TCKind::tk_ulong, val); + + case CORBA::tk_float: + val.add_float (dyn->get_float ()); + return Any (TCKind::tk_float, val); + + case CORBA::tk_double: + val.add_double (dyn->get_double ()); + return Any (TCKind::tk_double, val); + + case CORBA::tk_boolean: + val.add_boolean (dyn->get_boolean ()); + return Any (TCKind::tk_boolean, val); + + case CORBA::tk_octet: + val.add_octet (dyn->get_octet ()); + return Any (TCKind::tk_octet, val); + + case CORBA::tk_string: + val.add_string (dyn->get_string ()); + return Any (TCKind::tk_string, val); + + case CORBA::tk_longlong: + val.add_longlong (dyn->get_longlong ()); + return Any (TCKind::tk_longlong, val); + + case CORBA::tk_ulonglong: + val.add_ulonglong (dyn->get_ulonglong ()); + return Any (TCKind::tk_ulonglong, val); + + case CORBA::tk_longdouble: + // return Any (TCKind::tk_longdouble); + // @@MAJO: Need to add longdouble to schema. + //val.add_longdouble (dyn->get_longdouble ()); + + case CORBA::tk_wchar: + // return Any (TCKind::tk_wchar); + // @@MAJO: Need to add wchar to schema + // val.add_wchar (dyn->get_wchar ()); + case CORBA::tk_char: + // return Any (TCKind::tk_char); + // @@MAJO: Need to add char into the schema. + // val.add_char (dyn->get_char ()); + + case CORBA::tk_wstring: + case CORBA::tk_any: + case CORBA::tk_TypeCode: + case ::CORBA::tk_null: + default: + ACE_ERROR ((LM_ERROR, ACE_TEXT ("DynAny_Handler: I have no idea how to perform a referse mapping.\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("reverse mapping for this type not supported")); + } +#endif + Any retval (TCKind::tk_char, val); + return retval; + } + + CORBA::TypeCode_ptr + DynAny_Handler::create_typecode (const DataType &type) + { + + switch (type.kind ().integral ()) + { + // ========== BASIC TYPES + case TCKind::tk_null_l: + case TCKind::tk_void_l: + ACE_ERROR ((LM_WARNING, ACE_TEXT ("I don't know how to handle null or void types\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Null or void types not supported")); + break; + + case TCKind::tk_short_l: + return CORBA::_tc_short; + break; + + case TCKind::tk_long_l: + return CORBA::_tc_long; + break; + + case TCKind::tk_ushort_l: + return CORBA::_tc_ushort; + break; + + case TCKind::tk_ulong_l: + return CORBA::_tc_ulong; + break; + + case TCKind::tk_float_l: + return CORBA::_tc_float; + break; + + case TCKind::tk_double_l: + return CORBA::_tc_double; + break; + + case TCKind::tk_boolean_l: + return CORBA::_tc_boolean; + break; + + case TCKind::tk_char_l: + return CORBA::_tc_char; + break; + + case TCKind::tk_octet_l: + return CORBA::_tc_octet; + break; + + case TCKind::tk_string_l: + return CORBA::_tc_string; + break; + + case TCKind::tk_longlong_l: + return CORBA::_tc_longlong; + break; + + case TCKind::tk_ulonglong_l: + return CORBA::_tc_ulonglong; + break; + + case TCKind::tk_longdouble_l: + break; + + case TCKind::tk_wchar_l: + return CORBA::_tc_wchar; + break; + + case TCKind::tk_wstring_l: + break; + + case TCKind::tk_enum_l: + return DynEnum_Handler::create_typecode (type); + + case TCKind::tk_struct_l: + return DynStruct_Handler::create_typecode (type); + + case TCKind::tk_sequence_l: + return DynSequence_Handler::create_typecode (type); + + case TCKind::tk_alias_l: + return DynAlias_Handler::create_typecode (type); + + case TCKind::tk_fixed_l: + case TCKind::tk_any_l: + case TCKind::tk_TypeCode_l: + case TCKind::tk_Principal_l: + case TCKind::tk_objref_l: + case TCKind::tk_union_l: + case TCKind::tk_array_l: + case TCKind::tk_except_l: + case TCKind::tk_value_l: + case TCKind::tk_value_box_l: + case TCKind::tk_native_l: + case TCKind::tk_abstract_interface_l: + case TCKind::tk_local_interface_l: + case TCKind::tk_component_l: + case TCKind::tk_home_l: + case TCKind::tk_event_l: + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Type not supported\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported")); + } + + return 0; + } + + void + DynAny_Handler::register_typecode (const std::basic_string<ACE_TCHAR> typeID, + CORBA::TypeCode_ptr tc) + { + this->typecode_map_[typeID] = tc; + } + + + CORBA::TypeCode_ptr + DynAny_Handler::get_typecode (const std::basic_string<ACE_TCHAR> typeID) + { + try + { + return this->typecode_map_ [typeID]; + } + catch (...) + { + return 0; + } + } + } +} +#include /**/ "ace/post.h" diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h new file mode 100644 index 00000000000..d0cf66e9c32 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h @@ -0,0 +1,85 @@ +//============================================================== +/** + * @file DynAny_Handler.h + * + * $Id$ + * + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_DYNANY_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNANY_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" +#include "ace/Singleton.h" + +#include <map> + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class Any_Handler + * + * @brief Handler class for <ComponentInterfaceDescription> types. + * + * This class defines handler methods to map values from + * XSC Any objects, parsed from the descriptor files, to the + * corresponding CORBA IDL Any type. + * + */ + class DynAny_Handler_Export DynAny_Handler + { + public: + DynAny_Handler (); + + ~DynAny_Handler (void); + + DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr = 0); + + Any extract_from_dynany (const CORBA::Any &any); + + CORBA::ORB_ptr orb (); + + DynamicAny::DynAnyFactory_ptr daf (); + + CORBA::TypeCode_ptr create_typecode (const DataType &type); + + void register_typecode (const std::basic_string<ACE_TCHAR> typeID, + CORBA::TypeCode_ptr tc); + + CORBA::TypeCode_ptr get_typecode (const std::basic_string<ACE_TCHAR> typeID); + + private: + + CORBA::ORB_var orb_; + + DynamicAny::DynAnyFactory_var daf_; + + std::map <std::basic_string<ACE_TCHAR>, CORBA::TypeCode_ptr> typecode_map_; + }; + + typedef ACE_Singleton<DynAny_Handler, ACE_Null_Mutex> DynAny_Singleton; + #define DYNANY_HANDLER DynAny_Singleton::instance() + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ANY_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h new file mode 100644 index 00000000000..78a3ee57b77 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl DynAny_Handler +// ------------------------------ +#ifndef DYNANY_HANDLER_EXPORT_H +#define DYNANY_HANDLER_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (DYNANY_HANDLER_HAS_DLL) +# define DYNANY_HANDLER_HAS_DLL 1 +#endif /* ! DYNANY_HANDLER_HAS_DLL */ + +#if defined (DYNANY_HANDLER_HAS_DLL) && (DYNANY_HANDLER_HAS_DLL == 1) +# if defined (DYNANY_HANDLER_BUILD_DLL) +# define DynAny_Handler_Export ACE_Proper_Export_Flag +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* DYNANY_HANDLER_BUILD_DLL */ +# define DynAny_Handler_Export ACE_Proper_Import_Flag +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* DYNANY_HANDLER_BUILD_DLL */ +#else /* DYNANY_HANDLER_HAS_DLL == 1 */ +# define DynAny_Handler_Export +# define DYNANY_HANDLER_SINGLETON_DECLARATION(T) +# define DYNANY_HANDLER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* DYNANY_HANDLER_HAS_DLL == 1 */ + +// Set DYNANY_HANDLER_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (DYNANY_HANDLER_NTRACE) +# if (ACE_NTRACE == 1) +# define DYNANY_HANDLER_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define DYNANY_HANDLER_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !DYNANY_HANDLER_NTRACE */ + +#if (DYNANY_HANDLER_NTRACE == 1) +# define DYNANY_HANDLER_TRACE(X) +#else /* (DYNANY_HANDLER_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define DYNANY_HANDLER_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (DYNANY_HANDLER_NTRACE == 1) */ + +#endif /* DYNANY_HANDLER_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp new file mode 100644 index 00000000000..2b01a870ba6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp @@ -0,0 +1,109 @@ +// $Id$ + +#include "DynEnum_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "Common.h" + +#include "tao/AnyTypeCode/TypeCode.h" +#include "tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h" +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/AnyTypeCode/Enum_TypeCode.h" +#include "tao/IFR_Client/IFR_BasicC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + DynamicAny::DynAny_ptr + DynEnum_Handler::extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr req_tc) + { + try + { + CORBA::TypeCode_ptr tc; + + if (req_tc) + tc = req_tc; + else + tc = DynEnum_Handler::create_typecode (type); + + // Make the actual DynEnum + DynamicAny::DynAny_var temp = + DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc); + DynamicAny::DynEnum_var retval = DynamicAny::DynEnum::_narrow (temp.in ()); + + retval->set_as_string (ACE_TEXT_ALWAYS_CHAR ((*value.begin_enum ())->c_str ())); + + return retval._retn (); + } + catch (DynamicAny::DynAny::InvalidValue) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Invalid value provided in XML when trying to ") + ACE_TEXT ("initialize an instance of enumerated type %s\n"), + type.enum_ ().typeId ().c_str ())); + throw Config_Error (type.enum_ ().typeId (), + ACE_TEXT ("Invalid value provided in XML")); + } + catch (Config_Error &ex) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("DynEnum_Handler caught Config_Error\n"))); + if (type.enum_p ()) + ex.add_name (type.enum_ ().typeId ()); + + throw ex; + } + catch (...) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("DynEnum_Handler caught unknown exception\n"))); + throw Config_Error (type.enum_ ().typeId (), + ACE_TEXT ("Unknown exception")); + } + } + + void + DynEnum_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Extracting Enums not yet supported\n"))); + } + + CORBA::TypeCode_ptr + DynEnum_Handler::create_typecode (const DataType &type) + { + if (!type.enum_p ()) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Enum type descriptioin required"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Did not find expected enum type description, tk_kind may be wrong.")); + } + + // Construct TypeCode for the enum + CORBA::EnumMemberSeq members; + members.length (type.enum_ ().count_member ()); + CORBA::ULong index (0); + + for (EnumType::member_const_iterator i = type.enum_ ().begin_member (); + i != type.enum_ ().end_member (); + ++i) + { + members[index++] = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*i)->c_str ())); + } + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_enum_tc (ACE_TEXT_ALWAYS_CHAR (type.enum_ ().typeId ().c_str ()), + ACE_TEXT_ALWAYS_CHAR (type.enum_ ().name ().c_str ()), + members); + + DYNANY_HANDLER->register_typecode ((type.enum_ ().typeId ()), + tc); + + return tc; + } + + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h new file mode 100644 index 00000000000..8eaa1f11897 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h @@ -0,0 +1,52 @@ +/** + * $Id$ + * + * @file DynEnum_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ + +#ifndef CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class DynEnum_Handler + * @brief Translates enums specified in deployment plans into Dynamic Anys + * + */ + class DynEnum_Handler + { + public: + static DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr = 0); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + + static CORBA::TypeCode_ptr create_typecode (const DataType &type); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H*/ + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.cpp new file mode 100644 index 00000000000..6da77d30e75 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.cpp @@ -0,0 +1,163 @@ +// $Id$ + +#include "DynSequence_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "Common.h" + +#include "ace/Null_Mutex.h" + +#include "tao/AnyTypeCode/TypeCode.h" +#include "tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h" +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/AnyTypeCode/Sequence_TypeCode.h" +#include "tao/IFR_Client/IFR_BasicC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + DynamicAny::DynAny_ptr + DynSequence_Handler::extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr req_tc) + { + CORBA::TypeCode_ptr tc; + if (req_tc) + tc = req_tc; + else + tc = DynSequence_Handler::create_typecode (type); + + // Make the actual DynSequence + DynamicAny::DynAny_var temp = + DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc); + DynamicAny::DynSequence_var retval = DynamicAny::DynSequence::_narrow (temp.in ()); + + DynamicAny::DynAnySeq dynseq; + CORBA::ULong pos = 0; + + switch (type.sequence ().elementType ().kind ().integral ()) + { + // ========== BASIC TYPES + case TCKind::tk_null_l: + case TCKind::tk_void_l: + case TCKind::tk_objref_l: + case TCKind::tk_fixed_l: + case TCKind::tk_component_l: + case TCKind::tk_home_l: + + ACE_ERROR ((LM_WARNING, "I don't know how to handle null or void types\n")); + throw 1; + + case TCKind::tk_short_l: + case TCKind::tk_long_l: + case TCKind::tk_ushort_l: + case TCKind::tk_ulong_l: + case TCKind::tk_float_l: + case TCKind::tk_double_l: + case TCKind::tk_boolean_l: + case TCKind::tk_octet_l: + case TCKind::tk_string_l: + case TCKind::tk_longlong_l: + case TCKind::tk_ulonglong_l: + case TCKind::tk_longdouble_l: + case TCKind::tk_wstring_l: + case TCKind::tk_enum_l: + case TCKind::tk_struct_l: + try + { + dynseq.length (value.count_element ()); + retval->set_length (value.count_element ()); + + for (DataValue::element_const_iterator i = value.begin_element (); + i != value.end_element (); + ++i) + { + DynamicAny::DynAny_var dynany + (DYNANY_HANDLER->extract_into_dynany (type.sequence ().elementType (), + **i)); + dynseq[pos++] = dynany->copy (); + } + + retval->set_elements_as_dyn_any (dynseq); + return retval._retn (); + } + catch (DynamicAny::DynAny::InvalidValue) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Invalid value provided in XML when trying to ") + ACE_TEXT ("populate %ith element of a sequence\n"), + pos)); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Invalid value whilst populating the sequence.")); + } + + case TCKind::tk_char_l: + case TCKind::tk_wchar_l: + // special case where value iterataor multiplicity should be one, and should + // represent a string, each character of which becomes a element of the sequence. + + case TCKind::tk_sequence_l: + case TCKind::tk_array_l: + // Several special cases here. + + case TCKind::tk_any_l: + case TCKind::tk_TypeCode_l: + case TCKind::tk_Principal_l: + case TCKind::tk_union_l: + case TCKind::tk_alias_l: + case TCKind::tk_except_l: + case TCKind::tk_value_l: + case TCKind::tk_value_box_l: + case TCKind::tk_native_l: + case TCKind::tk_abstract_interface_l: + case TCKind::tk_local_interface_l: + case TCKind::tk_event_l: + // Special case where element association in datavalue contains another datavalue. + + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Type not supported\n"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Type not supported")); + } + + return retval._retn (); + } + + void + DynSequence_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Extracting Sequences not yet supported\n"))); + } + + CORBA::TypeCode_ptr + DynSequence_Handler::create_typecode (const DataType &type) + { + if (!type.sequence_p ()) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Sequence type descriptioin required"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Expected <sequence> element, incorrect tc_kind.")); + } + + CORBA::TypeCode_ptr etc = + DYNANY_HANDLER->create_typecode (type.sequence ().elementType ()); + + CORBA::ULong bound (0); + if (type.sequence ().bound_p ()) + bound = type.sequence ().bound (); + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_sequence_tc (bound, + etc); + + // Sequences don't have names. + // DYNANY_HANDLER->register_typecode (type.sequence_ ().typeId (), + // tc); + + return tc; + } + + } +} + + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.h new file mode 100644 index 00000000000..7d6a5b6ba6c --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.h @@ -0,0 +1,52 @@ +/** + * $Id$ + * + * @file DynSequence_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ + +#ifndef CIAO_CONFIG_HANDLERS_DYNSEQUENCE_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNSEQUENCE_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" + +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class DynSequence_Handler + * @brief Translates sequences specified in deployment plans into Dynamic Anys + * + */ + class DynSequence_Handler + { + public: + static DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr = 0); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + + static CORBA::TypeCode_ptr create_typecode (const DataType &type); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNSEQUENCE_HANDLER_H*/ + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.cpp new file mode 100644 index 00000000000..b075d418e7b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.cpp @@ -0,0 +1,130 @@ +// $Id$ + +#include "DynStruct_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "Common.h" + +#include "ace/Null_Mutex.h" + +//#include "tao/ORB.h" +#include "tao/IFR_Client/IFR_BasicC.h" +//#include "tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h" + +#include "tao/AnyTypeCode/Struct_TypeCode.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void create_type_map (const DataType &type, + std::map <std::basic_string<ACE_TCHAR>, DataType const *> &dt_map) + { + for (StructType::member_const_iterator i = type.struct_ ().begin_member (); + i != type.struct_ ().end_member (); ++i) + { + dt_map[(*i)->name ()] = &((*i)->type ()); + } + } + + DynamicAny::DynAny_ptr + DynStruct_Handler::extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr req_tc) + { + try + { + CORBA::TypeCode_ptr tc; + + if (req_tc) + tc = req_tc; + else + tc = DynStruct_Handler::create_typecode (type); + + std::map <std::basic_string<ACE_TCHAR>, DataType const*> dt_map; + create_type_map (type, dt_map); + + // Make the actual DynStruct + DynamicAny::DynAny_var temp = + DYNANY_HANDLER->daf ()->create_dyn_any_from_type_code (tc); + DynamicAny::DynStruct_var retval = DynamicAny::DynStruct::_narrow (temp.in ()); + + CORBA::ULong pos (0); + DynamicAny::NameDynAnyPairSeq values; + values.length (value.count_member ()); + + for (DataValue::member_const_iterator i = value.begin_member (); + i != value.end_member (); ++i) + { + values[pos].id = ACE_TEXT_ALWAYS_CHAR ((*i)->name ().c_str ()); + values[pos].value = DYNANY_HANDLER->extract_into_dynany (*dt_map[(*i)->name ()], + (*i)->value ()); + pos++; + } + + retval->set_members_as_dyn_any (values); + + return retval._retn (); + } + catch (Config_Error &ex) + { + if (type.struct_p ()) + ex.add_name (type.struct_ ().typeId ()); + throw ex; + } + catch (...) + { + throw Config_Error (type.struct_ ().typeId (), + ACE_TEXT ("Unknown exception")); + } + } + + + void + DynStruct_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Extracting Structs not yet supported\n"))); + } + + CORBA::TypeCode_ptr + DynStruct_Handler::create_typecode (const DataType &type) + { + if (!type.struct_p ()) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR: Struct type descriptioin required"))); + throw Config_Error (ACE_TEXT (""), ACE_TEXT ("Expected struct type information, tc_kind may be incorrect\n")); + } + + std::basic_string<ACE_TCHAR> rid (type.struct_ ().typeId ()); + std::basic_string<ACE_TCHAR> name (type.struct_ ().name ()); + + CORBA::StructMemberSeq members; + members.length (type.struct_ ().count_member ()); + CORBA::ULong pos (0); + + for (StructType::member_const_iterator i = type.struct_ ().begin_member (); + i != type.struct_ ().end_member (); ++i) + { + members[pos].name = ACE_TEXT_ALWAYS_CHAR ((*i)->name ().c_str ()); + members[pos].type = DYNANY_HANDLER->create_typecode ((*i)->type ()); + ++pos; + } + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_struct_tc (ACE_TEXT_ALWAYS_CHAR (rid.c_str ()), + ACE_TEXT_ALWAYS_CHAR (name.c_str ()), + members); + + DYNANY_HANDLER->register_typecode (type.struct_ ().typeId (), + tc); + + return tc; + } + } +} + + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.h b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.h new file mode 100644 index 00000000000..554912378c6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.h @@ -0,0 +1,52 @@ +/** + * $Id$ + * + * @file DynStruct_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + */ + +#ifndef CIAO_CONFIG_HANDLERS_DYNSTRUCT_HANDLER_H +#define CIAO_CONFIG_HANDLERS_DYNSTRUCT_HANDLER_H +#include /**/ "ace/pre.h" + +#include "DynAny_Handler_Export.h" +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "tao/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class Any; + class DataType; + class DataValue; + + /** + * @class DynStruct_Handler + * @brief Translates structs specified in deployment plans into Dynamic Anys + * + */ + class DynStruct_Handler + { + public: + static DynamicAny::DynAny_ptr extract_into_dynany (const DataType &type, + const DataValue &value, + CORBA::TypeCode_ptr = 0); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + + static CORBA::TypeCode_ptr create_typecode (const DataType &type); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNSTRUCT_HANDLER_H*/ + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/dynany_test.idl b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/dynany_test.idl new file mode 100644 index 00000000000..0ffecc5c757 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/dynany_test.idl @@ -0,0 +1,28 @@ +//$Id$ +module dynany_test +{ + typedef sequence<double> DoubleSequence; + typedef sequence<long> LongSequence; + typedef sequence<string, 3> StringSequence; + + enum COLOR + { + yellow, + blue, + black, + grey, + red + }; + + typedef sequence<COLOR> ColorSequence; + + struct Foo + { + double db; + LongSequence long_sequence; + StringSequence string_sequence; + ColorSequence color_sequence; + }; + + typedef sequence<Foo> FooSequence; +}; diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.cpp b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.cpp new file mode 100644 index 00000000000..e03f21236b1 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.cpp @@ -0,0 +1,291 @@ +// $Id$ + +#include <iostream> + +#include "Deployment.hpp" +#include "DP_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ace/Get_Opt.h" +#include "XML_Typedefs.h" +#include "tao/ORB.h" +#include "Common.h" +#include "dynany_testC.h" +#include "XML_File_Intf.h" + +static const char *input_file = "BasicSP.cdp"; + + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "i:"); + + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'i': + input_file = get_opts.opt_arg (); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-i <input file> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command-line + return 0; +} + +using namespace CIAO::Config_Handlers; + +bool check_doubleseq (CORBA::Any &any) +{ + ACE_DEBUG ((LM_DEBUG, "Checking a double sequence\n")); + + dynany_test::DoubleSequence *seq; + + if (!(any >>= seq)) + { + ACE_ERROR ((LM_ERROR, "failed to extract double sequence\n")); + return false; + } + + static const CORBA::Double ref_seq[3] = {1.0, 2.0, 2.5}; + + if (seq->length () != 3) + { + ACE_ERROR ((LM_ERROR, "Unexpected length of double sequence\n")); + return false; + } + + for (CORBA::ULong i = 0; i < seq->length (); ++i) + { + if ((*seq)[i] != ref_seq[i]) + { + ACE_ERROR ((LM_ERROR, "Expected %ith element of double sequence " + " to be %d, got %d instead.\n", i, (*seq)[i], ref_seq[i])); + return false; + } + } + + return true; +} + +bool check_longseq (dynany_test::LongSequence *seq); + +bool check_longseq (CORBA::Any &any) +{ + dynany_test::LongSequence *seq; + + if (!(any >>= seq)) + { + ACE_ERROR ((LM_ERROR, "failed to extract long sequence\n")); + return false; + } + + return check_longseq (seq); +} + +bool check_longseq (dynany_test::LongSequence *seq) +{ + ACE_DEBUG ((LM_DEBUG, "Checking a long sequence\n")); + + static const CORBA::Long ref_seq[3] = {1, 5, 6}; + + if (seq->length () != 3) + { + ACE_ERROR ((LM_ERROR, "Unexpected length of long sequence\n")); + return false; + } + + for (CORBA::ULong i = 0; i < seq->length (); ++i) + { + if ((*seq)[i] != ref_seq[i]) + { + ACE_ERROR ((LM_ERROR, "Expected %ith element of long sequence " + " to be %i, got %i instead.\n", i, (*seq)[i], ref_seq[i])); + return false; + } + } + + return true; +} + + +bool check_stringseq (dynany_test::StringSequence *seq); + +bool check_stringseq (CORBA::Any &any) +{ + dynany_test::StringSequence *seq; + + if (!(any >>= seq)) + { + ACE_ERROR ((LM_ERROR, "failed to extract string sequence\n")); + return false; + } + + return check_stringseq (seq); +} + +bool check_stringseq (dynany_test::StringSequence *seq) +{ + ACE_DEBUG ((LM_DEBUG, "Checking a string sequence\n")); + + static const std::string ref_seq[3] = {"StringOne", + "StringTwo", + "StringThree"}; + + if (seq->length () != 3) + { + ACE_ERROR ((LM_ERROR, "Unexpected length of string sequence\n")); + return false; + } + + for (CORBA::ULong i = 0; i < seq->length (); ++i) + { + std::string val ((*seq)[i].in ()); + + if (val != ref_seq[i]) + { + ACE_ERROR ((LM_ERROR, "Expected %ith element of string sequence " + " to be %i, got %i instead.\n", i, val.c_str (), ref_seq[i].c_str ())); + return false; + } + } + + return true; +} + +bool check_colorseq (dynany_test::ColorSequence *seq); + +bool check_colorseq (CORBA::Any &any) +{ + dynany_test::ColorSequence *seq; + + if (!(any >>= seq)) + { + ACE_ERROR ((LM_ERROR, "failed to extract color sequence\n")); + return false; + } + + return check_colorseq (seq); +} + +bool check_colorseq (dynany_test::ColorSequence *seq) +{ + ACE_DEBUG ((LM_DEBUG, "Checking a color sequence\n")); + + static const dynany_test::COLOR ref_seq[5] = {dynany_test::yellow, dynany_test::grey, dynany_test::red, + dynany_test::blue, dynany_test::black}; + + if (seq->length () != 5) + { + ACE_ERROR ((LM_ERROR, "Unexpected length of color sequence\n")); + return false; + } + + for (CORBA::ULong i = 0; i < seq->length (); ++i) + { + if ((*seq)[i] != ref_seq[i]) + { + ACE_ERROR ((LM_ERROR, "Expected %ith element of color sequence " + " to be %i, got %i instead.\n", i, (*seq)[i], ref_seq[i])); + return false; + } + } + + return true; +} + +bool check_foo_struct (CORBA::Any &any) +{ + ACE_DEBUG ((LM_DEBUG, "Checking a foo struct\n")); + + dynany_test::Foo *foo; + + if (!(any >>= foo)) + { + ACE_ERROR ((LM_ERROR, "failed to extract foo struct\n")); + return false; + } + + // Check contents of foo struct + if (foo->db != 5.5) + { + ACE_ERROR ((LM_ERROR, "expected value of db field to be 5.5, for %d\n", + foo->db)); + return false; + } + + return check_colorseq (&foo->color_sequence) && + check_longseq (&foo->long_sequence) && + check_stringseq (&foo->string_sequence); +} + +int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) +{ + try + { + if (parse_args (argc, argv) != 0) + return 1; + + // Initialize an ORB so Any will work + CORBA::ORB_ptr orb = CORBA::ORB_init (argc, argv); + ACE_UNUSED_ARG (orb); + + //Create an XML_Helper for all the file work + + bool success (true); + + XML_File_Intf intf (input_file); + intf.add_search_path ("CIAO_ROOT", "/docs/schema/"); + + if (intf.get_plan () != 0) + { + std::cout << "Instance document import succeeded. Checking contents.\n"; + + //Retrieve the newly created IDL structure + Deployment::DeploymentPlan *idl = intf.release_plan(); + + for (CORBA::ULong i = 0; i < idl->infoProperty.length (); ++i) + { + std::string name (idl->infoProperty[i].name.in ()); + + if (name == "double_sequence") + success = success && check_doubleseq (idl->infoProperty[i].value); + if (name == "long_sequence") + success = success && check_longseq (idl->infoProperty[i].value); + if (name == "string_sequence") + success = success && check_stringseq (idl->infoProperty[i].value); + if (name == "color_sequence") + success = success && check_colorseq (idl->infoProperty[i].value); + if (name == "foo_struct") + success = success && check_foo_struct (idl->infoProperty[i].value); + } + delete idl; + + + } + + if (success) + return 0; + else + { + ACE_ERROR((LM_ERROR, "Some test failures occurred, bailing out.")); + return -1; + } + } + catch (CIAO::Config_Handlers::Config_Error &ex) + { + ACE_ERROR ((LM_ERROR, "Caught config_error: %s:%s\n", + ex.name_.c_str (), ex.error_.c_str ())); + return -1; + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.mpc b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.mpc new file mode 100644 index 00000000000..55ce7ca31ec --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/DynAny_Handler/test.mpc @@ -0,0 +1,16 @@ +// $Id$ +project (XSC_DynAny_Test) : ciao_config_handlers, ifr_client, ciaoidldefaults { + requires += dummy_label + exename = test + macros += XML_USE_PTHREADS + + IDL_Files { + dynany_test.idl + } + + Source_Files { + test.cpp + } +} + + diff --git a/modules/CIAO/tools/Config_Handlers/ERE_Handler.cpp b/modules/CIAO/tools/Config_Handlers/ERE_Handler.cpp new file mode 100644 index 00000000000..916601b7052 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ERE_Handler.cpp @@ -0,0 +1,61 @@ +// $Id$ + +#include "ERE_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + void + ERE_Handler::external_ref_endpoints ( + const PlanConnectionDescription &src, + Deployment::ExternalReferenceEndpoints &dest) + { + CIAO_TRACE("ERE_Handler::external_ref_endpoints"); + PlanConnectionDescription::externalReference_const_iterator erep_e = + src.end_externalReference (); + + CORBA::ULong pos = 0; + dest.length (src.count_externalReference ()); + for (PlanConnectionDescription::externalReference_const_iterator erep_b = + src.begin_externalReference (); + erep_b != erep_e; + ++erep_b) + { + ERE_Handler::handle_external_ref_endpoint (*(*erep_b), + dest[pos++]); + } + } + + void + ERE_Handler::handle_external_ref_endpoint ( + const ExternalReferenceEndpoint &src, + Deployment::ExternalReferenceEndpoint &dest) + { + CIAO_TRACE("ERE_Handler::external_ref_endpoint"); + dest.location = ACE_TEXT_ALWAYS_CHAR ( src.location ().c_str ()); + dest.provider = src.provider (); + if (src.portName_p ()) + dest.portName = ACE_TEXT_ALWAYS_CHAR ( src.portName ().c_str ()); + dest.supportedType.length (src.count_supportedType ()); + std::for_each (src.begin_supportedType (), + src.end_supportedType (), + String_Seq_Functor (dest.supportedType)); + } + + ExternalReferenceEndpoint + ERE_Handler::external_ref_endpoint ( + const Deployment::ExternalReferenceEndpoint& src) + { + CIAO_TRACE("ERE_Handler::external_ref_endpoint - reverse"); + XMLSchema::string< ACE_TCHAR > loc (ACE_TEXT_CHAR_TO_TCHAR (src.location)); + // XMLSchema::string< char > provider ((src.provider)); + XMLSchema::string< ACE_TCHAR > pn (ACE_TEXT_CHAR_TO_TCHAR (src.portName)); + // XMLSchema::string< char > st ((src.supportedType)); + ExternalReferenceEndpoint erp (loc, src.provider); + return erp; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/ERE_Handler.h b/modules/CIAO/tools/Config_Handlers/ERE_Handler.h new file mode 100644 index 00000000000..5e4d1e1054e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ERE_Handler.h @@ -0,0 +1,70 @@ +//============================================================== +/** + * @file ERE_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_ERE_HANDLER_H +#define CIAO_CONFIG_HANDLERS_ERE_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "Utils/Functors.h" + +namespace Deployment +{ + class ExternalReferenceEndpoints; + struct ExternalReferenceEndpoint; +} + +namespace CIAO +{ + + namespace Config_Handlers + { + class PlanConnectionDescription; + class ExternalReferenceEndpoint; + + /* + * @class ERE_Handler + * + * @brief Handler class for <ExternalReferenceEndpoint> types. + * + * This class defines handler methods to map values from + * XSC ExternalReferenceEndpoint objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Common_Export ERE_Handler + { + public: + static void external_ref_endpoints (const PlanConnectionDescription &src, + ::Deployment::ExternalReferenceEndpoints &dest); + + static ExternalReferenceEndpoint external_ref_endpoint ( + const Deployment::ExternalReferenceEndpoint& src); + + static void handle_external_ref_endpoint (const ExternalReferenceEndpoint &src, + Deployment::ExternalReferenceEndpoint &dest); + }; + + typedef Sequence_Handler < ExternalReferenceEndpoint, + ::Deployment::ExternalReferenceEndpoints, + ::Deployment::ExternalReferenceEndpoint, + ERE_Handler::handle_external_ref_endpoint > ERE_Functor; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ERE_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/ESD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/ESD_Handler.cpp new file mode 100644 index 00000000000..5e1647f93b9 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ESD_Handler.cpp @@ -0,0 +1,124 @@ +// $Id$ + +#include "ESD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "cdp.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + void + ESD_Handler::es_deployment_descrs ( + const DeploymentPlan &src, + Deployment::EventServiceDeploymentDescriptions& dest) + { + CIAO_TRACE("ESD_Handler::instance_deployment_descrs"); + DeploymentPlan::es_const_iterator esd_e = src.end_instance (); + + CORBA::ULong pos = 0; + dest.length (src.count_instance ()); + for (DeploymentPlan::es_const_iterator esd_b = + src.begin_instance (); + esd_b != esd_e; + ++esd_b) + { + ESD_Handler::instance_deployment_descr ((*esd_b), + dest[pos], pos); + pos++; + } + } + + + void + ESD_Handler::es_deployment_descr ( + const EventServiceDeploymentDescription& src, + Deployment::EventServiceDeploymentDescription& dest, + CORBA::ULong pos) + { + CIAO_TRACE("IDD_Handler::es_deployment_descr"); + try + { + dest.name = src.name ().c_str (); + dest.node = src.node ().c_str (); + dest.svc_cfg_file = src.svc_cfg_file ().c_str ()); + + switch (desc.type ().integral ()) + { + case EventServiceType::EC_l: + dest.type = Deployment::EC; + break; + + case EventServiceType::RTEC_l: + dest.type = Deployment::RTEC; + break; + + case EventServiceType::NOTIFY_l: + dest.type = Deployment::NOTIFY; + break; + + case EventServiceType::RTNOTIFY_l: + dest.type = Deployment::RTNOTIFY; + break; + + default: + throw Config_Error (desc.requirementName (), + "Unknown EventServiceType."); + break; + } + } + catch (Config_Error &ex) + { + ex.name_ = src.name () + ":" + ex.name_; + throw ex; + } + // Done! + } + + EventServiceDeploymentDescription + ESD_Handler::es_deployment_descr ( + const Deployment::EventServiceDeploymentDescription& src) + { + CIAO_TRACE("ESD_Handler::es_deployment_descr - reverse"); + //Get all the string + XMLSchema::string < ACE_TCHAR > name ((src.name)); + XMLSchema::string < ACE_TCHAR > node ((src.node)); + XMLSchema::string < ACE_TCHAR > svc_cfg_file ((src.svc_cfg_file)); + + // Instantiate the IDD + EventServiceDeploymentDescription esd ( + name, + node, + EventServiceType::RTEC_l, + svc_cfg_file); + + switch (src.EventServiceType) + { + case Deployment::EC: + esd.EventServiceType (EventServiceType::EC); + break; + + case Deployment::RTEC: + esd.EventServiceType (EventServiceType::RTEC); + break; + + case Deployment::NOTIFY: + esd.EventServiceType (EventServiceType::NOTIFY); + break; + + case Deployment::RTNOTIFY: + esd.EventServiceType (EventServiceType::RTNOTIFY); + break; + + default: + throw Config_Error (src.resourceName.in (), + "Unknown EventServiceType."); + break; + } + + return esd; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/ESD_Handler.h b/modules/CIAO/tools/Config_Handlers/ESD_Handler.h new file mode 100644 index 00000000000..b20828a9713 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ESD_Handler.h @@ -0,0 +1,69 @@ +//============================================================== +/** + * @file ESD_Handler.h + * + * $Id$ + * + * @author Gan Deng <dengg@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_IDD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_IDD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Common.h" +#include "tao/Basic_Types.h" +#include "Config_Handlers_Export.h" +#include "IDREF_Base.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct EventServiceDeploymentDescription; + class EventServiceDeploymentDescriptions; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class DeploymentPlan; + class EventServiceDeploymentDescription; + + /* + * @class ESD_Handler + * + * @brief Handler class for <EventServiceDeploymentDescription> types. + * + * This class defines handler methods to map values from + * XSC EventServiceDeploymentDescription objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Export ESD_Handler + { + public: + static void es_deployment_descrs ( + const DeploymentPlan &src, + ::Deployment::EventServiceDeploymentDescriptions& dest); + + static EventServiceDeploymentDescription es_deployment_descr (const Deployment::EventServiceDeploymentDescription &src); + + static IDREF_Base<CORBA::ULong> IDREF; + + private: + static void es_deployment_descr ( + const EventServiceDeploymentDescription &src, + ::Deployment::EventServiceDeploymentDescription &dest, + CORBA::ULong pos); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IDD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/IDD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/IDD_Handler.cpp new file mode 100644 index 00000000000..152dee8c078 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IDD_Handler.cpp @@ -0,0 +1,165 @@ +// $Id$ + +#include "ace/UUID.h" +#include "IDD_Handler.h" +#include "IRDD_Handler.h" +#include "MDD_Handler.h" +#include "Property_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "cdp.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + IDREF_Base<CORBA::ULong> IDD_Handler::IDREF; + + void + IDD_Handler::instance_deployment_descrs (const deploymentPlan &src, + Deployment::InstanceDeploymentDescriptions& dest) + { + CIAO_TRACE("IDD_Handler::instance_deployment_descrs"); + deploymentPlan::instance_const_iterator idd_e = + src.end_instance (); + + CORBA::ULong pos = 0; + dest.length (src.count_instance ()); + for (deploymentPlan::instance_const_iterator idd_b = + src.begin_instance (); + idd_b != idd_e; + ++idd_b) + { + IDD_Handler::instance_deployment_descr (*(*idd_b), + dest[pos], pos); + pos++; + } + } + + void + IDD_Handler::instance_deployment_descr ( + const InstanceDeploymentDescription& src, + Deployment::InstanceDeploymentDescription& dest, + CORBA::ULong pos) + { + CIAO_TRACE("IDD_Handler::instance_deployment_descr"); + try + { + dest.name = ACE_TEXT_ALWAYS_CHAR ( src.name ().c_str ()); + dest.node = ACE_TEXT_ALWAYS_CHAR ( src.node ().c_str ()); + + if (src.id_p ()) + { + ACE_TString cstr (src.id ().c_str ()); + IDD_Handler::IDREF.bind_ref (cstr, pos); + } + else + { + ACE_DEBUG((LM_ERROR, + "(%P|%t) Warning: IDD %s has no idref\n", + ACE_TEXT_ALWAYS_CHAR ( src.name ().c_str ()))); + } + + // We know there should be only one element + dest.source.length (1); + dest.source [0] = + ACE_TEXT_ALWAYS_CHAR (src.source ().c_str ()); + + CORBA::ULong tmp = 0; + MDD_Handler::IDREF.find_ref (ACE_TString (src.implementation ().idref ().id ().c_str ()), tmp); + + dest.implementationRef = tmp; + + dest.configProperty.length (src.count_configProperty ()); + std::for_each (src.begin_configProperty (), + src.end_configProperty (), + Property_Functor (dest.configProperty)); + + dest.deployedResource.length (src.count_deployedResource ()); + std::for_each (src.begin_deployedResource (), + src.end_deployedResource (), + IRDD_Functor (dest.deployedResource)); + + if (src.deployedSharedResource_p ()) + { + dest.deployedSharedResource.length (1); + IRDD_Handler::handle_irdd (src.deployedSharedResource (), + dest.deployedSharedResource[0]); + } + + } + catch (Config_Error &ex) + { + ex.name_ = src.name () + ACE_TEXT (":") + ex.name_; + throw ex; + } + catch (...) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unknown exception at IDD:%s"), + src.name ().c_str ())); + throw Config_Error (src.name (), ACE_TEXT ("Unknown exception")); + } + + // Done! + } + + InstanceDeploymentDescription + IDD_Handler::instance_deployment_descr ( + const Deployment::InstanceDeploymentDescription& src) + { + CIAO_TRACE("IDD_Handler::instance_deployment_descr - reverse"); + //Get all the string/IDREFs + XMLSchema::string < ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + XMLSchema::string < ACE_TCHAR > node (ACE_TEXT_CHAR_TO_TCHAR (src.node)); + XMLSchema::string < ACE_TCHAR > source (ACE_TEXT ("")); + if (src.source.length () > 0) + { + XMLSchema::string < ACE_TCHAR > source_detail (ACE_TEXT_CHAR_TO_TCHAR (src.source[0])); + source = source_detail; + } + ACE_TString temp; + MDD_Handler::IDREF.find_ref(src.implementationRef, temp); + XMLSchema::IDREF< ACE_TCHAR > implementation ((temp.c_str())); + + // Instantiate the IDD + IdRef xid; + xid.idref (implementation); + InstanceDeploymentDescription idd (name, node, source, xid); + + //Get and store the configProperty(s) + size_t total = src.configProperty.length(); + for(size_t j = 0; j < total; j++) + { + //idd.add_configProperty(Property_Handler::get_property (src.configProperty[j])); + } + + // Get and store the deployedResource(s) + size_t dp_total = src.deployedResource.length (); + for (size_t k = 0; k < dp_total; k++) + { + //idd.add_deployedResource (IRDD_Handler::instance_resource_deployment_descr (src.deployedResource[k])); + } + + //Check if there is a deployedSharedResource, if so store it + if(src.deployedSharedResource.length() != 0) + idd. deployedSharedResource(IRDD_Handler::instance_resource_deployment_descr(src.deployedSharedResource[0])); + + // Generate a UUID to use for the IDREF. + ACE_Utils::UUID uuid; + ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); + ACE_TString idd_id (ACE_TEXT ("_")); + idd_id += ACE_TEXT_CHAR_TO_TCHAR (uuid.to_string ()->c_str ()); + + XMLSchema::ID< ACE_TCHAR > xml_id (idd_id.c_str ()); + + // Bind the ref and set it in the IDD + IDD_Handler::IDREF.bind_next_available (idd_id); + + idd.id (xml_id); + + return idd; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/IDD_Handler.h b/modules/CIAO/tools/Config_Handlers/IDD_Handler.h new file mode 100644 index 00000000000..313b7d9e6b2 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IDD_Handler.h @@ -0,0 +1,70 @@ +//============================================================== +/** + * @file IDD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_IDD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_IDD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Common.h" +#include "tao/Basic_Types.h" +#include "Config_Handlers_Export.h" +#include "IDREF_Base.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct InstanceDeploymentDescription; + class InstanceDeploymentDescriptions; + struct InstanceResourceDeploymentDescription; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class deploymentPlan; + class InstanceDeploymentDescription; + class InstanceResourceDeploymentDescription; + + /* + * @class IDD_Handler + * + * @brief Handler class for <InstanceDeploymentDescription> types. + * + * This class defines handler methods to map values from + * XSC InstanceDeploymentDescriptionn objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Export IDD_Handler + { + public: + static void instance_deployment_descrs (const deploymentPlan &src, + ::Deployment::InstanceDeploymentDescriptions& dest); + + static InstanceDeploymentDescription instance_deployment_descr (const Deployment::InstanceDeploymentDescription &src); + + static IDREF_Base<CORBA::ULong> IDREF; + + private: + static void instance_deployment_descr (const InstanceDeploymentDescription &src, + ::Deployment::InstanceDeploymentDescription &dest, + CORBA::ULong pos); + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IDD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/IDREF_Base.cpp b/modules/CIAO/tools/Config_Handlers/IDREF_Base.cpp new file mode 100644 index 00000000000..4df3c5863c7 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IDREF_Base.cpp @@ -0,0 +1,111 @@ +// $Id$ + +#ifndef IDREF_BASE_CPP +#define IDREF_BASE_CPP + +#include "ciao/Logger/Log_Macros.h" +#include "IDREF_Base.h" +#include <iostream> + + +ACE_RCSID (DAnCE, + IDREF_Base, + "$Id$") + +namespace CIAO + { + namespace Config_Handlers + { + template <typename T> + void + IDREF_Base<T>::bind_ref (ACE_TString& id, T value) + { + CIAO_TRACE("IDREF_Base<T>::bind_ref"); + + int retval = + idref_map_.bind (id, value); + + pos_map_.bind (value,id); + + if (retval < 0) + throw Config_Error (id.c_str (), + ACE_TEXT ("Failed to bind an IDRef. This likely indicates a name clash.")); + } + + template <typename T> + void + IDREF_Base<T>::bind_next_available (ACE_TString &id) + { + // Note: For this function to compile and work properly, + // T must have the postincrement operator defined. + CIAO_TRACE ("IDREF_Base<T>::bind_next_available"); + // ACE_DEBUG ((LM_DEBUG, "**** Binding %s to %i\n", + // id.c_str (), + // this->next_)); + + int retval = idref_map_.bind (id, this->next_); + + int pos_retval = pos_map_.bind (this->next_, id); + + ++this->next_; + + if (retval < 0 || pos_retval < 0) + throw Config_Error (id.c_str (), + ACE_TEXT ("Failed to bind an IDRef. This likely indicates a name clash")); + + } + + template <typename T> + void + IDREF_Base<T>::find_ref (const ACE_TString& id, T& val) + { + CIAO_TRACE("IDREF_Base<T>::find_ref(C_String, T)"); + + int retval = + idref_map_.find (id, val); + + if (retval < 0) + throw Config_Error (id.c_str (), + ACE_TEXT ("Unable to look up an IDRef.")); + } + + template <typename T> + void + IDREF_Base<T>::find_ref (const T& value, ACE_TString& id) + { + CIAO_TRACE("IDREF_Base<T>::find_ref (T, CString)"); + + int retval = + pos_map_.find (value, id); + + // ACE_ERROR ((LM_ERROR, "**** Looking up value %i\n", + // value)); + + if (retval < 0) + throw Config_Error (ACE_TEXT ("No location information for reverse IDREF lookup"), + id.c_str ()); + } + + template <typename T> + bool + IDREF_Base<T>::unbind_refs (void) + { + CIAO_TRACE("IDREF_Base<T>::unbind_refs"); + + int retval = + idref_map_.unbind_all (); + + pos_map_.unbind_all (); + + this->next_ = 0; + + if (retval < 0) + return false; + + return true; + } + } + + } + +#endif /* IDREF_BASE_CPP */ diff --git a/modules/CIAO/tools/Config_Handlers/IDREF_Base.h b/modules/CIAO/tools/Config_Handlers/IDREF_Base.h new file mode 100644 index 00000000000..3707f66142d --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IDREF_Base.h @@ -0,0 +1,89 @@ +/** +* $Id$ +* @file IDREF_Base.h +* @author Will Otte <wotte@dre.vanderbilt.edu> +* +* Defines the IDREF_Base class, which is an abstract class that serves +* as a base for any config handler that must map IDREFS. +*/ + +#ifndef CIAO_CONFIG_HANDLERS_IDREF_BASE_H +#define CIAO_CONFIG_HANDLERS_IDREF_BASE_H + +#include /**/ "ace/pre.h" + +#include "Common.h" +#include "Config_Handlers_Export.h" +#include "ace/Hash_Map_Manager.h" +#include "ace/Null_Mutex.h" +#include "ace/SString.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ +namespace Config_Handlers +{ + +/** +* @class IDREF_Handler +* @brief Base class for any handler that must process idrefs. +* +*/ +template <typename T> +class IDREF_Base +{ +public: +IDREF_Base () +{ +} + +IDREF_Base (T start_point) +: next_ (start_point) +{ +} + +/// Bind an IDREF to an index + void bind_ref (ACE_TString& id, T value); + +void bind_next_available (ACE_TString &id); + +/// Get the index associated with an IDREF + void find_ref (const ACE_TString& id, T& value); + +/// get the IDREF associated with an index + void find_ref (const T &value, ACE_TString& id); + +/// Unbind all IDREFS +bool +unbind_refs (void); + +typedef ACE_Hash_Map_Manager<ACE_TString, +T, +ACE_Null_Mutex> IDREF_MAP; + + +typedef ACE_Hash_Map_Manager<T, +ACE_TString, +ACE_Null_Mutex> POS_MAP; +protected: +/// The map used to store and look up the indexes of elements +/// referenced by their IDREF. +IDREF_MAP idref_map_; +/// The map used to store and look up the IDREFS of elements +/// referenced by their index. +POS_MAP pos_map_; + +T next_; +}; + +} + +} + +#include "IDREF_Base.cpp" + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IDREF_BASE_H */ diff --git a/modules/CIAO/tools/Config_Handlers/ID_Handler.cpp b/modules/CIAO/tools/Config_Handlers/ID_Handler.cpp new file mode 100644 index 00000000000..463aa2e7bcc --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ID_Handler.cpp @@ -0,0 +1,45 @@ +// $Id$ + +#include "ID_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + ID_Handler::ID_Handler (void) + { + } + + ID_Handler::~ID_Handler (void) + { + } + + + void + ID_Handler::get_ImplementationDependency (const ImplementationDependency& desc, + Deployment::ImplementationDependency& toconfig) + { + + CIAO_TRACE("ID_Handler::get_ImplementationDependency"); + + toconfig.requiredType= + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.requiredType ().c_str ())); + } + + ImplementationDependency + ID_Handler::impl_dependency ( + const ::Deployment::ImplementationDependency& src) + { + CIAO_TRACE("ID_Handler::get_ImplementationDependency - reverse"); + XMLSchema::string< ACE_TCHAR > reqtype (ACE_TEXT_CHAR_TO_TCHAR (src.requiredType)); + + ImplementationDependency id (reqtype); + + return id; + } + + } + +} diff --git a/modules/CIAO/tools/Config_Handlers/ID_Handler.h b/modules/CIAO/tools/Config_Handlers/ID_Handler.h new file mode 100644 index 00000000000..bea6ec2b1a6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ID_Handler.h @@ -0,0 +1,78 @@ + +//============================================================== +/** +* @file ID_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_ID_Handler_H +#define CIAO_CONFIG_HANDLERS_ID_Handler_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include "ace/config-lite.h" + +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + + +namespace Deployment +{ +struct ImplementationDependency; +class ImplementationDependencies; + +} + + +namespace CIAO +{ + +namespace Config_Handlers +{ + +class ImplementationDependency; + + +/* +* @class ID_Handler +* +* @brief Handler class for <ImplementationDependency> types. +* +* This class defines handler methods to map values from +* XSC ImplementationDependency objects, parsed from the descriptor files, to the +* corresponding CORBA IDL Any type. +* +*/ +class Config_Handlers_Export ID_Handler +{ +public: + +ID_Handler (void); +virtual ~ID_Handler (void); + +static void get_ImplementationDependency ( +const ImplementationDependency& desc, +Deployment::ImplementationDependency& toconfig); + +static ImplementationDependency impl_dependency ( +const ::Deployment::ImplementationDependency& src); +}; + +typedef Sequence_Handler < ImplementationDependency, +::Deployment::ImplementationDependencies, +::Deployment::ImplementationDependency, +ID_Handler::get_ImplementationDependency > ID_Functor; + +} +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_ID_Handler_H */ diff --git a/modules/CIAO/tools/Config_Handlers/IRDD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/IRDD_Handler.cpp new file mode 100644 index 00000000000..6b3fe17d249 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IRDD_Handler.cpp @@ -0,0 +1,118 @@ +// $Id$ + +#include "IRDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Property_Handler.h" +#include "ciao/Logger/Log_Macros.h" + + +namespace CIAO +{ + namespace Config_Handlers + { + + IRDD_Handler::IRDD_Handler (void) + { + } + + IRDD_Handler::~IRDD_Handler (void) + { + } + + + void + IRDD_Handler::handle_irdd (const InstanceResourceDeploymentDescription& desc, + Deployment::InstanceResourceDeploymentDescription& toconfig) + { + CIAO_TRACE("IRDD_Handler::instance_resource_deployment_descr"); + + switch (desc.resourceUsage ().integral ()) + { + case ResourceUsageKind::None_l: + toconfig.resourceUsage = Deployment::None; + break; + + case ResourceUsageKind::InstanceUsesResource_l: + toconfig.resourceUsage = Deployment::InstanceUsesResource; + break; + + case ResourceUsageKind::ResourceUsesInstance_l: + toconfig.resourceUsage = Deployment::ResourceUsesInstance; + break; + + case ResourceUsageKind::PortUsesResource_l: + toconfig.resourceUsage = Deployment::PortUsesResource; + break; + + case ResourceUsageKind::ResourceUsesPort_l: + toconfig.resourceUsage = Deployment::ResourceUsesPort; + break; + + default: + throw Config_Error (desc.requirementName (), + ACE_TEXT ("Unknown ResourceUsageKind.")); + break; + } + + toconfig.requirementName = ACE_TEXT_ALWAYS_CHAR ( desc.requirementName ().c_str ()); + + toconfig.resourceName= ACE_TEXT_ALWAYS_CHAR ( desc.resourceName ().c_str ()); + + toconfig.property.length (desc.count_property ()); + std::for_each (desc.begin_property (), + desc.end_property (), + Property_Functor (toconfig.property)); + } + + InstanceResourceDeploymentDescription + IRDD_Handler::instance_resource_deployment_descr (const Deployment::InstanceResourceDeploymentDescription& src) + { + CIAO_TRACE("IRDD_Handler::instance_resource_deployment_descr - reverse"); + + XMLSchema::string< ACE_TCHAR > reqname (ACE_TEXT_CHAR_TO_TCHAR (src.requirementName)); + XMLSchema::string< ACE_TCHAR > resname (ACE_TEXT_CHAR_TO_TCHAR (src.resourceName)); + + InstanceResourceDeploymentDescription irdd (ResourceUsageKind::None, + reqname, + resname); + + switch (src.resourceUsage) + { + case Deployment::None: + irdd.resourceUsage (ResourceUsageKind::None); + break; + + case Deployment::InstanceUsesResource: + irdd.resourceUsage (ResourceUsageKind::InstanceUsesResource); + break; + + case Deployment::ResourceUsesInstance: + irdd.resourceUsage (ResourceUsageKind::ResourceUsesInstance); + break; + + case Deployment::PortUsesResource: + irdd.resourceUsage (ResourceUsageKind::PortUsesResource); + break; + + case Deployment::ResourceUsesPort: + irdd.resourceUsage (ResourceUsageKind::ResourceUsesPort); + break; + + default: + throw Config_Error (ACE_TEXT_CHAR_TO_TCHAR (src.resourceName.in ()), + ACE_TEXT ("Unknown ResourceUsageKind.")); + break; + } + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + { + //irdd.add_property (Property_Handler::get_property (src.property[i])); + } + + + return irdd; + } + } + +} diff --git a/modules/CIAO/tools/Config_Handlers/IRDD_Handler.h b/modules/CIAO/tools/Config_Handlers/IRDD_Handler.h new file mode 100644 index 00000000000..dc4955988ee --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/IRDD_Handler.h @@ -0,0 +1,74 @@ +//============================================================== +/** +* @file IRDD_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_IRDD_Handler_H +#define CIAO_CONFIG_HANDLERS_IRDD_Handler_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include "Common.h" +#include "ace/config-lite.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + + +namespace Deployment +{ + struct InstanceResourceDeploymentDescription; + class InstanceResourceDeploymentDescriptions; +} + + +namespace CIAO +{ + namespace Config_Handlers + { + + class InstanceResourceDeploymentDescription; + + + /* + * @class IRDD_Handler + * + * @brief Handler class for <InstanceResourceDeploymentDescription> types. + * + * This class defines handler methods to map values from + * XSC InstanceResourceDeploymentDescription objects, parsed from the descriptor files, to the + * corresponding CORBA IDL Any type. + * + */ + class Config_Handlers_Export IRDD_Handler { + public: + IRDD_Handler (void); + virtual ~IRDD_Handler (void); + + static void handle_irdd (const InstanceResourceDeploymentDescription& desc, + Deployment::InstanceResourceDeploymentDescription& toconfig) + /*throw (Config_Error)*/; + + static InstanceResourceDeploymentDescription + instance_resource_deployment_descr (const Deployment::InstanceResourceDeploymentDescription& src) + /*throw (Config_Error)*/; + }; + + typedef Sequence_Handler < InstanceResourceDeploymentDescription, + ::Deployment::InstanceResourceDeploymentDescriptions, + ::Deployment::InstanceResourceDeploymentDescription, + IRDD_Handler::handle_irdd > IRDD_Functor; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IRDD_Handler_H */ + diff --git a/modules/CIAO/tools/Config_Handlers/MDD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/MDD_Handler.cpp new file mode 100644 index 00000000000..5e3466351a9 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/MDD_Handler.cpp @@ -0,0 +1,174 @@ +// $Id$ + +#include "MDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ADD_Handler.h" +#include "Property_Handler.h" +#include "Req_Handler.h" +#include "cdp.hpp" +#include "ace/UUID.h" + +namespace CIAO +{ + namespace Config_Handlers + { + IDREF_Base<CORBA::ULong> MDD_Handler::IDREF; + + void + MDD_Handler::mono_deployment_descriptions (const deploymentPlan& src, + Deployment::MonolithicDeploymentDescriptions& dest) + { + CIAO_TRACE("MDD_Handler::mono_deployment_descriptions"); + + deploymentPlan::implementation_const_iterator imp_e = + src.end_implementation (); + CORBA::ULong pos = 0; + dest.length (src.count_implementation ()); + for (deploymentPlan::implementation_const_iterator imp_b = + src.begin_implementation (); + imp_b != imp_e; + ++imp_b) + { + MDD_Handler::mono_deployment_description (*(*imp_b), + dest[pos], + pos); + pos++; + } + } + + void + MDD_Handler::mono_deployment_description (const MonolithicDeploymentDescription& desc, + Deployment::MonolithicDeploymentDescription& toconfig, + CORBA::ULong pos) + { + toconfig.name = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ())); + + MonolithicDeploymentDescription::source_const_iterator me = + desc.end_source (); + + CORBA::ULong len = 0; + toconfig.source.length (desc.count_source ()); + for (MonolithicDeploymentDescription::source_const_iterator se = + desc.begin_source (); + se != me; + ++se) + { + toconfig.source[len++] = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR ((*se)->c_str ())); + } + + MonolithicDeploymentDescription::artifact_const_iterator ae = + desc.end_artifact (); + len = 0; + toconfig.artifactRef.length (desc.count_artifact ()); + for (MonolithicDeploymentDescription::artifact_const_iterator + ab = desc.begin_artifact (); + ae != ab; + ++ab) + { + CORBA::ULong tmp = 0; + + ADD_Handler::IDREF.find_ref (ACE_TString ((*ab)->idref ().id ().c_str ()), + tmp); + + toconfig.artifactRef[len++] = tmp; + } + + MonolithicDeploymentDescription::execParameter_const_iterator epce = + desc.end_execParameter (); + len = 0; + toconfig.execParameter.length (desc.count_execParameter ()); + for (MonolithicDeploymentDescription::execParameter_const_iterator epcb = + desc.begin_execParameter (); + epcb != epce; + ++epcb) + { + Property_Handler::handle_property (*(*epcb), + toconfig.execParameter[len++]); + } + + toconfig.deployRequirement.length (desc.count_deployRequirement ()); + std::for_each (desc.begin_deployRequirement (), + desc.end_deployRequirement (), + Requirement_Functor (toconfig.deployRequirement)); + + // Handle the idref + if (desc.id_p ()) + { + ACE_TString cstr (desc.id ().c_str ()); + + MDD_Handler::IDREF.bind_ref (cstr, pos); + } + else + { + ACE_DEBUG((LM_ERROR, + "(%P|%t) Warning: MDD %s has no idref\n", + desc.name ().c_str ())); + } + } + + + MonolithicDeploymentDescription + MDD_Handler::mono_deployment_description( + const Deployment::MonolithicDeploymentDescription &src) + { + CIAO_TRACE("mono_deployment_description - reverse"); + + //Get the name and instantiate the mdd + XMLSchema::string < ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + MonolithicDeploymentDescription mdd (name); + + //Get the source(s) from the IDL and store them + size_t total = src.source.length(); + for(size_t i = 0; i < total; i++) + { + XMLSchema::string< ACE_TCHAR > curr (ACE_TEXT_CHAR_TO_TCHAR(src.source[i])); + //mdd.add_source(curr); + } + + //Get the artifactRef(s) from the IDL and store them + total = src.artifactRef.length(); + for(size_t j = 0; j < total; j++) + { + ACE_TString tmp; + ADD_Handler::IDREF.find_ref(src.artifactRef[j], tmp); + IdRef idref; + idref.idref (tmp.c_str ()); + //mdd.add_artifact (idref); + } + + //Get the execParameter(s) from the IDL and store them + total = src.execParameter.length(); + for(size_t k = 0; k < total; k++) + { + //mdd.add_execParameter (Property_Handler::get_property (src.execParameter[k])); + } + + //Get the deployRequirement(s) from the IDL and store them + total = src.deployRequirement.length(); + for(size_t l = 0; l < total; l++) + { + //mdd.add_deployRequirement(Req_Handler::get_requirement (src.deployRequirement[l])); + } + + // Generate a UUID to use for the IDREF. + ACE_Utils::UUID uuid; + ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid); + ACE_TString mdd_id (ACE_TEXT ("_")); + mdd_id += ACE_TEXT_CHAR_TO_TCHAR (uuid.to_string ()->c_str ()); + + XMLSchema::ID< ACE_TCHAR > xml_id (mdd_id.c_str ()); + + // Bind the ref and set it in the IDD + MDD_Handler::IDREF.bind_next_available (mdd_id); + + mdd.id (xml_id); + + return mdd; + } + } + +} + diff --git a/modules/CIAO/tools/Config_Handlers/MDD_Handler.h b/modules/CIAO/tools/Config_Handlers/MDD_Handler.h new file mode 100644 index 00000000000..c36efe6885b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/MDD_Handler.h @@ -0,0 +1,68 @@ +//============================================================== +/** + * @file MDD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_MDD_Handler_H +#define CIAO_CONFIG_HANDLERS_MDD_Handler_H +#include /**/ "ace/pre.h" +#include "tao/Basic_Types.h" +#include "Config_Handlers_Export.h" +#include "IDREF_Base.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace Deployment +{ + struct MonolithicDeploymentDescription; + class MonolithicDeploymentDescriptions; +} + + +namespace CIAO +{ + + namespace Config_Handlers + { + class MonolithicDeploymentDescription; + class deploymentPlan; + + /* + * @class MDD_Handler + * + * @brief Handler class for <MonolithicDeploymentDescription> types. + * + * This class defines handler methods to map values from XSC + * MonolithicDeploymentDescription objects, parsed from the + * descriptor files, to the corresponding CORBA IDL types. + * + */ + + class Config_Handlers_Export MDD_Handler + { + public: + static void mono_deployment_descriptions (const deploymentPlan &src, + Deployment::MonolithicDeploymentDescriptions &dest); + + static MonolithicDeploymentDescription mono_deployment_description(const Deployment::MonolithicDeploymentDescription &src); + + static IDREF_Base<CORBA::ULong> IDREF; + + private: + static void mono_deployment_description (const MonolithicDeploymentDescription& desc, + Deployment::MonolithicDeploymentDescription& toconfig, + CORBA::ULong pos); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_MDD_Handler_H */ diff --git a/modules/CIAO/tools/Config_Handlers/PCD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/PCD_Handler.cpp new file mode 100644 index 00000000000..899b388211e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PCD_Handler.cpp @@ -0,0 +1,135 @@ +// $Id$ + +#include "PCD_Handler.h" +#include "Req_Handler.h" +#include "CEPE_Handler.h" +#include "PSPE_Handler.h" +#include "ERE_Handler.h" +#include "CRDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + + PCD_Handler::PCD_Handler (void) + { + } + + PCD_Handler::~PCD_Handler (void) + { + } + + ///This method takes a <Deployment::PlanConnectionDescription> + ///and maps the values from the passed in XSC + ///PlanConnectionDescription to its members. + void PCD_Handler::handle_PlanConnectionDescription (const PlanConnectionDescription& desc, + Deployment::PlanConnectionDescription& toconfig) + { + CIAO_TRACE("PCD_Handler::get_PlanConnectionDescription"); + + toconfig.name =( CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()))); + + //Source is mapped to a string in the schema and a sequence + //in the IDL. We just assign the source string from the xml + //to the first position in the IDL type's sequence. We + //make sure that the source is present before lengthening + //the sequence. + if (desc.source_p ()) + { + // Only one..... + toconfig.source.length (1); + toconfig.source[0] = ACE_TEXT_ALWAYS_CHAR ( desc.source ().c_str ()); + } + + toconfig.deployRequirement.length (desc.count_deployRequirement ()); + std::for_each (desc.begin_deployRequirement (), + desc.end_deployRequirement (), + Requirement_Functor (toconfig.deployRequirement)); + + + //Create the ComponentExternalPortEndpoint handler. + CEPE_Handler::external_port_endpoints (desc, + toconfig.externalEndpoint); + + //Configure the PlanSubcomponentPortEndpoint's. + PSPE_Handler::sub_component_port_endpoints (desc, + toconfig.internalEndpoint); + + //Configure the ExternalReferenceEndpoint's. + ERE_Handler::external_ref_endpoints (desc, + toconfig.externalReference); + + //Configure the resource value. + CRDD_Handler crddhandler; + CORBA::ULong pos = 0; + toconfig.deployedResource.length (desc.count_deployedResource ()); + for(PlanConnectionDescription::deployedResource_const_iterator res = + desc.begin_deployedResource(); + res != desc.end_deployedResource(); + res++) + { + crddhandler.get_ConnectionResourceDeploymentDescription (toconfig.deployedResource[pos++], + *(*res)); + } + + } + + PlanConnectionDescription + PCD_Handler::get_PlanConnectionDescription (const Deployment::PlanConnectionDescription &src) + { + CIAO_TRACE("PCD_Handler::get_PlanConnectionDescription"); + + XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + + PlanConnectionDescription pcd(name); + + //Get the source if it exists + if(src.source.length() != 0) + { + XMLSchema::string< ACE_TCHAR > source(ACE_TEXT_CHAR_TO_TCHAR (src.source[0])); + pcd.source(source); + } + + //Get any externalEndpoint(s) and store them + size_t total = src.externalEndpoint.length(); + for(size_t i = 0; i < total; i++) + { + //pcd.add_externalEndpoint(CEPE_Handler::external_port_endpoint(src.externalEndpoint[i])); + } + + //Get any externalReference(s) and store them + total = src.externalReference.length(); + for(size_t j = 0; j < total; j++) + { + //pcd.add_externalReference(ERE_Handler::external_ref_endpoint(src.externalReference[j])); + } + + //Get any internalEndpoint(s) and store them + total = src.internalEndpoint.length(); + for(size_t k = 0; k < total; k++) + { + //pcd.add_internalEndpoint(PSPE_Handler::sub_component_port_endpoint(src.internalEndpoint[k])); + } + + //Get any deployedResource(s) and store them + total = src.deployedResource.length(); + for(size_t l = 0; l < total; l++) + { + //pcd.add_deployedResource(CRDD_Handler::connection_resource_depl_desc(src.deployedResource[l])); + } + + //Get any deployRequirement(s) and store them + total = src.deployRequirement.length(); + for(size_t m = 0; m < total; m++) + { + //pcd.add_deployRequirement(Req_Handler::get_requirement(src.deployRequirement[m])); + } + + return pcd; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/PCD_Handler.h b/modules/CIAO/tools/Config_Handlers/PCD_Handler.h new file mode 100644 index 00000000000..3813fa2badc --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PCD_Handler.h @@ -0,0 +1,75 @@ +//============================================================== +/** + * @file PCD_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_PCD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PCD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" +#include "Utils/Functors.h" +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct PlanConnectionDescription; + class PlanConnectionDescriptions; +} + +namespace CIAO +{ + + namespace Config_Handlers + { + + class PlanConnectionDescription; + + /* + * @class PCD_Handler + * + * @brief Handler class for <PlanConnectionDescription> types. + * + * This class defines handler methods to map values from + * XSC PlanConnectionDescription objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Export PCD_Handler{ + + public: + + PCD_Handler (void); + virtual ~PCD_Handler (void); + + ///This method takes a <Deployment::PlanConnectionDescription> + ///and maps the values from the passed in XSC + ///PlanConnectionDescription to its members. + static void handle_PlanConnectionDescription (const PlanConnectionDescription& desc, + ::Deployment::PlanConnectionDescription& toconfig); + + //This method takes a <Deployment::PlanConnectionDescription> + //converts it into a <Config_Handler::PlanConnectionDescription> + //and returns the value + static PlanConnectionDescription + get_PlanConnectionDescription (const Deployment::PlanConnectionDescription &src); + }; + + typedef Sequence_Handler < PlanConnectionDescription, + ::Deployment::PlanConnectionDescriptions, + ::Deployment::PlanConnectionDescription, + PCD_Handler::handle_PlanConnectionDescription > PCD_Functor; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_PCD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/PL_Handler.cpp b/modules/CIAO/tools/Config_Handlers/PL_Handler.cpp new file mode 100644 index 00000000000..d7258893f30 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PL_Handler.cpp @@ -0,0 +1,52 @@ +// $Id$ + +#include "PL_Handler.h" +#include "IDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void + PL_Handler::get_PlanLocality (const PlanLocality &desc, + Deployment::PlanLocality &toconfig) + { + CIAO_TRACE ("PL_Handler::get_PlanLocality"); + + switch (desc.constraint ().integral ()) + { + case PlanLocalityKind::SameProcess_l: + toconfig.constraint = Deployment::PlanSameProcess; + break; + + case PlanLocalityKind::DifferentProcess_l: + toconfig.constraint = Deployment::PlanDifferentProcess; + break; + + case PlanLocalityKind::NoConstraint_l: + toconfig.constraint = Deployment::PlanNoConstraint; + break; + } + + + size_t pos = 0; + toconfig.constrainedInstanceRef.length (desc.count_constrainedInstance ()); + + for (PlanLocality::constrainedInstance_const_iterator i = desc.begin_constrainedInstance (); + i != desc.end_constrainedInstance (); + ++i) + { + CORBA::ULong tmp = 0; + IDD_Handler::IDREF.find_ref ((*i)->idref ().id ().c_str (), tmp); + + toconfig.constrainedInstanceRef[pos] = tmp; + ++pos; + } + } + + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/PL_Handler.h b/modules/CIAO/tools/Config_Handlers/PL_Handler.h new file mode 100644 index 00000000000..0511b81be48 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PL_Handler.h @@ -0,0 +1,53 @@ +// $Id$ + +/** + * @file PL_Handler.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * + * Handles PlanLocality elements + * + */ + +#ifndef CIAO_CONFIG_HANDLERS_PL_HANDLER_ +#define CIAO_CONFIG_HANDLERS_PL_HANDLER_ + +#include "Config_Handlers_Export.h" +#include "ace/config-lite.h" + +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{// $Id$ + + struct PlanLocality; + class PlanLocalities; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class PlanLocality; + + class Config_Handlers_Export PL_Handler + { + public: + static void get_PlanLocality (const PlanLocality &desc, + Deployment::PlanLocality &toconfig); + + static PlanLocality plan_locality (const ::Deployment::PlanLocality &src); + }; + + typedef Sequence_Handler < PlanLocality, + ::Deployment::PlanLocalities, + ::Deployment::PlanLocality, + PL_Handler::get_PlanLocality > PL_Functor; + + } +} + +#endif diff --git a/modules/CIAO/tools/Config_Handlers/PSPE_Handler.cpp b/modules/CIAO/tools/Config_Handlers/PSPE_Handler.cpp new file mode 100644 index 00000000000..28d29bf8f34 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PSPE_Handler.cpp @@ -0,0 +1,148 @@ +// $Id$ + +#include "PSPE_Handler.h" +#include "IDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void + PSPE_Handler::sub_component_port_endpoints ( + const PlanConnectionDescription &src, + ::Deployment::PlanSubcomponentPortEndpoints &dest) + { + CIAO_TRACE("PSPE_Handler::sub_component_port_endpoints"); + + PlanConnectionDescription::internalEndpoint_const_iterator iei_e = + src.end_internalEndpoint (); + CORBA::ULong pos = 0; + dest.length (src.count_internalEndpoint ()); + + for (PlanConnectionDescription::internalEndpoint_const_iterator iei_b = + src.begin_internalEndpoint (); + iei_b != iei_e; + ++iei_b) + { + PSPE_Handler::sub_component_port_endpoint (*(*iei_b), + dest[pos++]); + } + } + + void + PSPE_Handler::sub_component_port_endpoint ( + const PlanSubcomponentPortEndpoint &src, + ::Deployment::PlanSubcomponentPortEndpoint &dest) + { + CIAO_TRACE("PSPE_Handler::sub_component_port_endpoint"); + dest.portName = + ACE_TEXT_ALWAYS_CHAR (src.portName ().c_str ()); + + if (src.provider_p ()) + { + dest.provider = src.provider () == ACE_TEXT ("true"); + } + else + { + dest.provider = false; + } + + CORBA::ULong tmp = 0; + + IDD_Handler::IDREF.find_ref (ACE_TString (src.instance ().idref ().id ().c_str ()), + tmp); + + dest.instanceRef = tmp; + + switch (src.kind ().integral ()) + { + case CCMComponentPortKind::Facet_l: + dest.kind = Deployment::Facet; + break; + + case CCMComponentPortKind::SimplexReceptacle_l: + dest.kind = Deployment::SimplexReceptacle; + break; + + case CCMComponentPortKind::MultiplexReceptacle_l: + dest.kind = Deployment::MultiplexReceptacle; + break; + + case CCMComponentPortKind::EventEmitter_l: + dest.kind = Deployment::EventEmitter; + break; + + case CCMComponentPortKind::EventPublisher_l: + dest.kind = Deployment::EventPublisher; + break; + + case CCMComponentPortKind::EventConsumer_l: + dest.kind = Deployment::EventConsumer; + break; + + default: + ACE_DEBUG ((LM_DEBUG, "Invalid port kind in connection\n")); + + } + } + + PlanSubcomponentPortEndpoint + PSPE_Handler::sub_component_port_endpoint ( + const Deployment::PlanSubcomponentPortEndpoint &src) + { // @@MAJO + CIAO_TRACE("PSPE_Handler::sub_component_port_endpoint - reverse"); + XMLSchema::string< ACE_TCHAR > pname (ACE_TEXT_CHAR_TO_TCHAR (src.portName)); + XMLSchema::string< ACE_TCHAR > tval (ACE_TEXT ("true")); + XMLSchema::string< ACE_TCHAR > prov (ACE_TEXT ("")); + ACE_TString id; + IDD_Handler::IDREF.find_ref(src.instanceRef, id); + XMLSchema::IDREF < ACE_TCHAR > idref(id.c_str()); + + if (src.provider) + prov = tval; + + IdRef idr; + idr.idref (idref); + + PlanSubcomponentPortEndpoint pspe (pname, + CCMComponentPortKind::Facet, + idr); + pspe.provider (prov); + + switch (src.kind) + { + case ::Deployment::Facet: + pspe.kind (CCMComponentPortKind::Facet); + break; + + case ::Deployment::SimplexReceptacle: + pspe.kind (CCMComponentPortKind::SimplexReceptacle); + break; + + case ::Deployment::MultiplexReceptacle: + pspe.kind (CCMComponentPortKind::MultiplexReceptacle); + break; + + case ::Deployment::EventEmitter: + pspe.kind (CCMComponentPortKind::EventEmitter); + break; + + case ::Deployment::EventPublisher: + pspe.kind (CCMComponentPortKind::EventPublisher); + break; + + case ::Deployment::EventConsumer: + pspe.kind (CCMComponentPortKind::EventConsumer); + break; + + default: + ACE_ERROR ((LM_ERROR, "Invalid port kind in PSPE\n")); + } + + + return pspe; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/PSPE_Handler.h b/modules/CIAO/tools/Config_Handlers/PSPE_Handler.h new file mode 100644 index 00000000000..aeb92da9eb0 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/PSPE_Handler.h @@ -0,0 +1,65 @@ +//============================================================== +/** +* @file PSPE_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_PSPE_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PSPE_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ +class PlanSubcomponentPortEndpoints; +struct PlanSubcomponentPortEndpoint; +} + +namespace CIAO +{ + +namespace Config_Handlers +{ +class PlanConnectionDescription; +class PlanSubcomponentPortEndpoint; + +/* +* @class PSPE_Handler +* +* @brief Handler class for <PlanSubcomponentPortEndpoint> types. +* +* This class defines handler methods to map values from +* XSC PlanSubcomponentPortEndpoint objects, parsed from +* the descriptor files, to the corresponding CORBA IDL type. +* +*/ +class Config_Handlers_Export PSPE_Handler +{ +public: +static void sub_component_port_endpoints ( +const PlanConnectionDescription &src, +::Deployment::PlanSubcomponentPortEndpoints &dest); + +static PlanSubcomponentPortEndpoint +sub_component_port_endpoint ( +const Deployment::PlanSubcomponentPortEndpoint &src); + +private: +static void sub_component_port_endpoint ( +const PlanSubcomponentPortEndpoint &src, +::Deployment::PlanSubcomponentPortEndpoint &dest); +}; +} +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_PSPE_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp new file mode 100644 index 00000000000..28df2abe65f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp @@ -0,0 +1,271 @@ +// $Id$ + +#include "tao/AnyTypeCode/TypeCode.h" +#include "Package_Handlers/CAD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "cid.hpp" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "Req_Handler.h" +#include "CEPE_Handler.h" +#include "ERE_Handler.h" +#include "Utils/Exceptions.h" + +#include "Package_Handlers/SID_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + struct Packaging_Handlers_Export SPE_Handler + { + static void handle_spe (const SubcomponentPortEndpoint &desc, + ::Deployment::SubcomponentPortEndpoint &toconfig) + { + CIAO_TRACE("SPE_Handler::get_spe"); + + toconfig.portName = ACE_TEXT_ALWAYS_CHAR ( desc.portName ().c_str ()); + + ACE_TString str (desc.instance ().idref ().id ().c_str ()); + CORBA::ULong pos (0); + + SID_Handler::IDREF.find_ref (str, pos); + toconfig.instanceRef = pos; + } + + static SubcomponentPortEndpoint + get_spe (const ::Deployment::SubcomponentPortEndpoint &src) + { + CIAO_TRACE("SPE_Handler::get_spe - reverse"); + ACE_TString str; + SID_Handler::IDREF.find_ref (src.instanceRef, str); + + IdRef xid; + xid.idref (str.c_str ()); + + return SubcomponentPortEndpoint (ACE_TEXT_CHAR_TO_TCHAR (src.portName.in ()), + xid); + } + }; + + typedef Sequence_Handler < SubcomponentPortEndpoint, + ::Deployment::SubcomponentPortEndpoints, + ::Deployment::SubcomponentPortEndpoint, + SPE_Handler::handle_spe > SPE_Functor; + + struct Packaging_Handlers_Export ACD_Handler + { + static void handle_acd (const AssemblyConnectionDescription &desc, + ::Deployment::AssemblyConnectionDescription &toconfig) + { + CIAO_TRACE("ACD_Handler::get_acd"); + + toconfig.name = ACE_TEXT_ALWAYS_CHAR ( desc.name ().c_str ()); + + toconfig.deployRequirement.length (desc.count_deployRequirement ()); + std::for_each (desc.begin_deployRequirement (), + desc.end_deployRequirement (), + Requirement_Functor (toconfig.deployRequirement)); + + toconfig.internalEndpoint.length (desc.count_internalEndpoint ()); + SEQ_HAND_GCC_BUG_WORKAROUND (SPE_Handler::handle_spe, + (*desc.begin_internalEndpoint ()), + toconfig.internalEndpoint); + std::for_each (desc.begin_internalEndpoint (), + desc.end_internalEndpoint (), + SPE_Functor (toconfig.internalEndpoint)); + + toconfig.externalEndpoint.length (desc.count_externalEndpoint ()); + std::for_each (desc.begin_externalEndpoint (), + desc.end_externalEndpoint (), + CEPE_Functor (toconfig.externalEndpoint)); + + toconfig.externalReference.length (desc.count_externalReference ()); + std::for_each (desc.begin_externalReference (), + desc.end_externalReference (), + ERE_Functor (toconfig.externalReference)); + + } + + static AssemblyConnectionDescription + get_acd (const ::Deployment::AssemblyConnectionDescription &src) + { + CIAO_TRACE("ACD_Handler::get_acd - reverse"); + + AssemblyConnectionDescription retval (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.deployRequirement.length (); ++i) + retval.add_deployRequirement (Req_Handler::get_requirement (src.deployRequirement[i])); + + for (CORBA::ULong i = 0; i < src.internalEndpoint.length (); ++i) + retval.add_internalEndpoint + (SPE_Handler::get_spe (src.internalEndpoint[i])); + + for (CORBA::ULong i = 0; i < src.externalEndpoint.length (); ++i) + retval.add_externalEndpoint + (CEPE_Handler::external_port_endpoint (src.externalEndpoint[i])); + + for (CORBA::ULong i = 0; i < src.externalReference.length (); ++i) + retval.add_externalReference + (ERE_Handler::external_ref_endpoint (src.externalReference[i])); +#endif + return retval; + } + }; + + typedef Sequence_Handler < AssemblyConnectionDescription, + ::Deployment::AssemblyConnectionDescriptions, + ::Deployment::AssemblyConnectionDescription, + ACD_Handler::handle_acd > ACD_Functor; + + + struct Packaging_Handlers_Export SPR_Handler + { + static void handle_spr (const SubcomponentPropertyReference &desc, + ::Deployment::SubcomponentPropertyReference &toconfig) + { + CIAO_TRACE("SPR_Handler::get_spr"); + + toconfig.propertyName = ACE_TEXT_ALWAYS_CHAR ( desc.propertyName ().c_str ()); + + ACE_TString str (desc.instance ().idref ().id ().c_str ()); + CORBA::ULong pos (0); + + SID_Handler::IDREF.find_ref (str, pos); + toconfig.instanceRef = pos; + + } + + static SubcomponentPropertyReference + get_spr (const ::Deployment::SubcomponentPropertyReference &src) + { + CIAO_TRACE("SPR_HAndler::get_spr - reverse"); + ACE_TString str; + SID_Handler::IDREF.find_ref (src.instanceRef, str); + + IdRef xid; + xid.idref (str.c_str ()); + return SubcomponentPropertyReference (ACE_TEXT_CHAR_TO_TCHAR (src.propertyName.in ()), + xid); + } + + }; + + typedef Sequence_Handler < SubcomponentPropertyReference, + ::Deployment::SubcomponentPropertyReferences, + ::Deployment::SubcomponentPropertyReference, + SPR_Handler::handle_spr > SPR_Functor; + + struct Packaging_Handlers_Export APM_Handler + { + static void handle_apm (const AssemblyPropertyMapping &desc, + ::Deployment::AssemblyPropertyMapping &toconfig) + { + CIAO_TRACE("APM_Handler::get_apm"); + + toconfig.name = ACE_TEXT_ALWAYS_CHAR ( desc.name ().c_str ()); + toconfig.externalName = ACE_TEXT_ALWAYS_CHAR ( desc.externalName ().c_str ()); + + toconfig.delegatesTo.length (desc.count_delegatesTo ()); + SEQ_HAND_GCC_BUG_WORKAROUND (SPR_Handler::handle_spr, + (*desc.begin_delegatesTo ()), + toconfig.delegatesTo); + std::for_each (desc.begin_delegatesTo (), + desc.end_delegatesTo (), + SPR_Functor (toconfig.delegatesTo)); + } + + static AssemblyPropertyMapping + get_apm (const ::Deployment::AssemblyPropertyMapping &src) + { + CIAO_TRACE("APM_Handler::get_apm - reverse"); + + AssemblyPropertyMapping retval (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()), + ACE_TEXT_CHAR_TO_TCHAR (src.externalName.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.delegatesTo.length (); ++i) + retval.add_delegatesTo (SPR_Handler::get_spr (src.delegatesTo[i])); +#endif + return retval; + } + }; + + typedef Sequence_Handler < AssemblyPropertyMapping, + ::Deployment::AssemblyPropertyMappings, + ::Deployment::AssemblyPropertyMapping, + APM_Handler::handle_apm > APM_Functor; + + void + CAD_Handler::component_assem_descr (const ComponentAssemblyDescription &desc, + ::Deployment::ComponentAssemblyDescription &toconfig) + { + CIAO_TRACE("CAD_Handler::component_assem_descr"); + + toconfig.instance.length (desc.count_instance ()); + std::for_each (desc.begin_instance (), + desc.end_instance (), + SID_Functor (toconfig.instance)); + + /* @@ MAJO: Implement Locality */ + + toconfig.connection.length (desc.count_connection ()); + SEQ_HAND_GCC_BUG_WORKAROUND (ACD_Handler::handle_acd, + (*desc.begin_connection ()), + toconfig.connection); + std::for_each (desc.begin_connection (), + desc.end_connection (), + ACD_Functor (toconfig.connection)); + + toconfig.externalProperty.length (desc.count_externalProperty ()); + SEQ_HAND_GCC_BUG_WORKAROUND (APM_Handler::handle_apm, + (*desc.begin_externalProperty ()), + toconfig.externalProperty); + std::for_each (desc.begin_externalProperty (), + desc.end_externalProperty (), + APM_Functor (toconfig.externalProperty)); + } + + ComponentAssemblyDescription + CAD_Handler::component_assem_descr (const ::Deployment::ComponentAssemblyDescription &/*src*/) + { + CIAO_TRACE("CAD_Handler::component_assem_descr - reverse"); + + ComponentAssemblyDescription retval; +#if 0 + for (CORBA::ULong i = 0; i < src.instance.length (); ++i) + retval.add_instance + (SID_Handler::sub_comp_inst_descr (src.instance[i])); + + for (CORBA::ULong i = 0; i < src.connection.length (); ++i) + retval.add_connection (ACD_Handler::get_acd (src.connection[i])); + + for (CORBA::ULong i = 0; i < src.externalProperty.length (); ++i) + retval.add_externalProperty (APM_Handler::get_apm (src.externalProperty[i])); +#endif + return retval; + + } + + ComponentAssemblyDescription * + CAD_Handler::resolve_cad (const char *) + { + /* xercesc::DOMDocument *dom = + this->xml_helper_->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for CAD"); + + try { + return new ComponentAssemblyDescription + (componentAssemblyDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for CAD"); + */ + return 0; + } + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.h new file mode 100644 index 00000000000..b42f13dcdc3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.h @@ -0,0 +1,59 @@ +/** + * @file CAD_Handler.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + +#ifndef CIAO_PACKAGING_CAD_HANDLER_H +#define CIAO_PACKAGING_CAD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "XML_Typedefs.h" +#include "DAnCE/Deployment/DeploymentC.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ComponentAssemblyDescription; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentAssemblyDescription; + + namespace Packaging + { + + /** + * @class CAD_Handler + * + * @brief Handler class for ComponentAssemblyDescription. + */ + class Packaging_Handlers_Export CAD_Handler + { + public: + static void component_assem_descr (const ComponentAssemblyDescription &desc, + ::Deployment::ComponentAssemblyDescription &toconfig); + + static ComponentAssemblyDescription + component_assem_descr (const ::Deployment::ComponentAssemblyDescription &src); + + private: + static ComponentAssemblyDescription * resolve_cad (const char *uri); + }; + + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_PACKAGING_CAD_HANDLER_H */ + diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp new file mode 100644 index 00000000000..c30ac8e0ae7 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp @@ -0,0 +1,390 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "Package_Handlers/CID_Handler.h" +#include "Package_Handlers/CPD_Handler.h" +#include "Package_Handlers/IAD_Handler.h" +#include "Package_Handlers/CAD_Handler.h" +#include "Package_Handlers/Comp_Intf_Descr_Handler.h" +#include "Package_Handlers/NIA_Handler.h" +#include "SatisfierProperty_Handler.h" +#include "Req_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "XML_Typedefs.h" +#include "Utils/Exceptions.h" + +#include "Deployment.hpp" +#include "Property_Handler.h" + + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + + IDREF_Base<CORBA::ULong> CID_Handler::IDREF; + + struct Capability_Handler + { + static void handle_capability (const Capability &desc, + ::Deployment::Capability &toconfig) + { + CIAO_TRACE ("Capability_Handler::get_capability"); + + toconfig.name = ACE_TEXT_ALWAYS_CHAR ( desc.name ().c_str ()); + + toconfig.resourceType.length (desc.count_resourceType ()); + std::for_each (desc.begin_resourceType (), + desc.end_resourceType (), + String_Seq_Functor (toconfig.resourceType)); + + toconfig.property.length (desc.count_property ()); + std::for_each (desc.begin_property (), + desc.end_property (), + SatisfierProperty_Functor (toconfig.property)); + } + + static Capability get_capability (const ::Deployment::Capability &src) + { + CIAO_TRACE ("Capability_Handler::get_capability - reverse"); + + Capability retval (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.resourceType.length (); ++i) + retval.add_resourceType (src.resourceType[i].in ()); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (SatisfierProperty_Handler::get_sat_property (src.property[i])); +#endif + return retval; + } + }; + + typedef Sequence_Handler < Capability, + ::Deployment::Capabilities, + ::Deployment::Capability, + Capability_Handler::handle_capability > Capability_Functor; + + struct IR_Handler + { + static void handle_ir (const ImplementationRequirement &desc, + ::Deployment::ImplementationRequirement &toconfig) + { + CIAO_TRACE ("IR_Handler::get_ir"); + + if (desc.resourceUsage_p ()) + { + switch (desc.resourceUsage ().integral ()) + { + case ResourceUsageKind::None_l: + toconfig.resourceUsage = Deployment::None; + break; + + case ResourceUsageKind::InstanceUsesResource_l: + toconfig.resourceUsage = Deployment::InstanceUsesResource; + break; + + case ResourceUsageKind::ResourceUsesInstance_l: + toconfig.resourceUsage = Deployment::ResourceUsesInstance; + break; + + case ResourceUsageKind::PortUsesResource_l: + toconfig.resourceUsage = Deployment::PortUsesResource; + break; + + case ResourceUsageKind::ResourceUsesPort_l: + toconfig.resourceUsage = Deployment::ResourceUsesPort; + break; + + default: + throw Config_Error (desc.name (), + ACE_TEXT ("Unknown ResourceUsageKind.")); + break; + } + } + + if (desc.resourcePort_p ()) + toconfig.resourcePort = ACE_TEXT_ALWAYS_CHAR ( desc.resourcePort ().c_str ()); + + if (desc.componentPort_p ()) + toconfig.componentPort = ACE_TEXT_ALWAYS_CHAR ( desc.componentPort ().c_str ()); + + toconfig.resourceType = ACE_TEXT_ALWAYS_CHAR ( desc.resourceType ().c_str ()); + toconfig.name = ACE_TEXT_ALWAYS_CHAR ( desc.name ().c_str ()); + + std::for_each (desc.begin_property (), + desc.end_property (), + Property_Functor (toconfig.property )); + } + + static ImplementationRequirement + get_ir (const ::Deployment::ImplementationRequirement &src) + { + CIAO_TRACE ("IR_Handler::get_ir - reverse"); + + ImplementationRequirement retval (ACE_TEXT_CHAR_TO_TCHAR (src.resourceType.in ()), + ACE_TEXT_CHAR_TO_TCHAR (src.name.in ())); + + if (src.resourceUsage.length () == 1) + switch (src.resourceUsage[0]) + { + case Deployment::None: + retval.resourceUsage (ResourceUsageKind::None); + break; + + case Deployment::InstanceUsesResource: + retval.resourceUsage (ResourceUsageKind::InstanceUsesResource); + break; + + case Deployment::ResourceUsesInstance: + retval.resourceUsage (ResourceUsageKind::ResourceUsesInstance); + break; + + case Deployment::PortUsesResource: + retval.resourceUsage (ResourceUsageKind::PortUsesResource); + break; + + case Deployment::ResourceUsesPort: + retval.resourceUsage (ResourceUsageKind::ResourceUsesPort); + break; + + default: + throw Config_Error (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()), + ACE_TEXT ("Unknown ResourceUsageKind.")); + break; + } + + retval.resourcePort (ACE_TEXT_CHAR_TO_TCHAR (src.resourcePort.in ())); + + retval.componentPort (ACE_TEXT_CHAR_TO_TCHAR (src.componentPort.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (Property_Handler::get_property (src.property[i])); +#endif + return retval; + } + }; + + typedef Sequence_Handler < ImplementationRequirement, + ::Deployment::ImplementationRequirements, + ::Deployment::ImplementationRequirement, + IR_Handler::handle_ir > IR_Functor; + + struct MID_Handler + { + static void handle_mid (const MonolithicImplementationDescription &desc, + ::Deployment::MonolithicImplementationDescription &toconfig) + { + CIAO_TRACE ("MID_Handler::get_mid"); + + toconfig.nodeExecParameter.length (desc.count_nodeExecParameter ()); + std::for_each (desc.begin_nodeExecParameter (), + desc.end_nodeExecParameter (), + Property_Functor (toconfig.nodeExecParameter)); + + toconfig.componentExecParameter.length (desc.count_componentExecParameter ()); + std::for_each (desc.begin_componentExecParameter (), + desc.end_componentExecParameter (), + Property_Functor (toconfig.componentExecParameter)); + + toconfig.deployRequirement.length (desc.count_deployRequirement ()); + while (0) + { + IR_Handler::handle_ir (*(*desc.begin_deployRequirement ()), + toconfig.deployRequirement[0]); + } + std::for_each (desc.begin_deployRequirement (), + desc.end_deployRequirement (), + IR_Functor (toconfig.deployRequirement)); + + toconfig.primaryArtifact.length (desc.count_primaryArtifact ()); + SEQ_HAND_GCC_BUG_WORKAROUND (NIA_Handler::handle_nia, + (*desc.begin_primaryArtifact ()), + toconfig.primaryArtifact); + std::for_each (desc.begin_primaryArtifact (), + desc.end_primaryArtifact (), + NIA_Functor (toconfig.primaryArtifact)); + } + + static MonolithicImplementationDescription + get_mid (const ::Deployment::MonolithicImplementationDescription &/*src*/) + { + CIAO_TRACE ("MID_Handler::get_mid - reverse"); + + MonolithicImplementationDescription retval; +#if 0 + for (CORBA::ULong i = 0; i < src.nodeExecParameter.length (); ++i) + retval.add_nodeExecParameter + (Property_Handler::get_property (src.nodeExecParameter[i])); + + for (CORBA::ULong i = 0; i < src.componentExecParameter.length (); ++i) + retval.add_componentExecParameter + (Property_Handler::get_property (src.componentExecParameter[i])); + + for (CORBA::ULong i = 0; i < src.deployRequirement.length (); ++i) + retval.add_deployRequirement + (IR_Handler::get_ir (src.deployRequirement[i])); + + for (CORBA::ULong i = 0; i < src.primaryArtifact.length (); ++i) + retval.add_primaryArtifact + (NIA_Handler::get_nia (src.primaryArtifact[i])); +#endif + return retval; + } + + }; + + typedef Sequence_Handler < MonolithicImplementationDescription, + ::Deployment::MonolithicImplementationDescriptions, + ::Deployment::MonolithicImplementationDescription, + MID_Handler::handle_mid > MID_Functor; + + + + void + CID_Handler::component_impl_descr ( + const ComponentImplementationDescription &desc, + ::Deployment::ComponentImplementationDescription &toconfig) + { + CIAO_TRACE ("CID_Handler::component_impl_descr"); + + const ComponentImplementationDescription *cid = 0; + std::auto_ptr <ComponentImplementationDescription> xsc_cid; + + if (desc.href_p ()) + { + xsc_cid.reset (CID_Handler::resolve_cid ((desc.href ().c_str ()))); + cid = xsc_cid.get (); + } + else + cid = &desc; + + if (cid->label_p ()) + toconfig.label = ACE_TEXT_ALWAYS_CHAR ( cid->label ().c_str ()); + + if (cid->UUID_p ()) + toconfig.UUID = ACE_TEXT_ALWAYS_CHAR ( cid->UUID ().c_str ()); + + if (cid->implements_p ()) + { // MAJO: We should be able to assume this exists, fix broken interpeters.. + Comp_Intf_Descr_Handler::comp_intf_descr (cid->implements (), + toconfig.implements); + } + + if (cid->assemblyImpl_p ()) + { + toconfig.assemblyImpl.length (1); + CAD_Handler::component_assem_descr (cid->assemblyImpl (), + toconfig.assemblyImpl[0]); + } + else if (cid->monolithicImpl_p ()) + { + toconfig.monolithicImpl.length (1); + MID_Handler::handle_mid (cid->monolithicImpl (), + toconfig.monolithicImpl[0]); + } + else + throw Plan_Error (ACE_TEXT ("ComponentImplementationDescription must have either assemblyImpl or monolithicImpl")); + + // configProperty + toconfig.configProperty.length (cid->count_configProperty ()); + std::for_each (cid->begin_configProperty (), + cid->end_configProperty (), + Property_Functor (toconfig.configProperty)); + + // capability + toconfig.capability.length (cid->count_capability ()); + SEQ_HAND_GCC_BUG_WORKAROUND (Capability_Handler::handle_capability, + (*cid->begin_capability ()), + toconfig.capability); + std::for_each (cid->begin_capability (), + cid->end_capability (), + Capability_Functor (toconfig.capability)); + + // dependsOn + toconfig.dependsOn.length (cid->count_dependsOn ()); + CORBA::ULong pos = 0; + for (ComponentImplementationDescription::dependsOn_const_iterator i = cid->begin_dependsOn (); + i != cid->end_dependsOn (); + ++i) + toconfig.dependsOn[pos++].requiredType = ACE_TEXT_ALWAYS_CHAR ( (*i)->requiredType ().c_str ()); + + // infoProperty + toconfig.infoProperty.length (cid->count_infoProperty ()); + std::for_each (cid->begin_infoProperty (), + cid->end_infoProperty (), + Property_Functor (toconfig.infoProperty)); + + } + + ComponentImplementationDescription + CID_Handler::component_impl_descr (const Deployment::ComponentImplementationDescription& src) + { + CIAO_TRACE ("CID_Handler::component_impl_descr - reverse"); + + ComponentImplementationDescription retval; + + retval.label (ACE_TEXT_CHAR_TO_TCHAR (src.label.in ())); + retval.UUID (ACE_TEXT_CHAR_TO_TCHAR (src.UUID.in ())); + + { + retval.implements (Comp_Intf_Descr_Handler::comp_intf_descr (src.implements)); + } + + if (src.assemblyImpl.length () == 1) + { + retval.assemblyImpl (CAD_Handler::component_assem_descr (src.assemblyImpl[0])); + } + else if (src.monolithicImpl.length () == 1) + { + retval.monolithicImpl (MID_Handler::get_mid (src.monolithicImpl[0])); + } + else + ACE_DEBUG ((LM_WARNING, "Warning: ComponentImplementationDescription lacks " + "either a required assemblyImpl or monolithicImpl, or has too many")); +#if 0 + for (CORBA::ULong i = 0; i < src.configProperty.length (); ++i) + { + retval.add_configProperty ( + Property_Handler::get_property (src.configProperty[i])); + } + + for (CORBA::ULong i = 0; i < src.dependsOn.length (); ++i) + { + retval.add_dependsOn (ImplementationDependency (src.dependsOn[i].requiredType.in ())); + } + + for (CORBA::ULong i = 0; i < src.infoProperty.length (); ++i) + { + retval.add_infoProperty ( + Property_Handler::get_property (src.infoProperty[i])); + } +#endif + return retval; + } + + ComponentImplementationDescription * + CID_Handler::resolve_cid (const ACE_TCHAR *uri) + { + CIAO_TRACE ("CID_Handler::resolve_cid"); + + xercesc::DOMDocument *dom = XML_Helper::XML_HELPER.create_dom (uri); + + if (!dom) + throw Parse_Error (ACE_TEXT ("Unable to create DOM for CID")); + + try { + return new ComponentImplementationDescription + (reader::componentImplementationDescription (dom)); + } + catch (...) { + throw Parse_Error (ACE_TEXT ("Unable to create XSC structure for CID")); + } + } + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.h new file mode 100644 index 00000000000..d00304d8cfe --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.h @@ -0,0 +1,67 @@ +/** + * @file CID_Handler.h + * + * $Id$ + * + * @author William Otte <wotte@dre.vanderbilt.edu + */ + +#ifndef CIAO_PACKAGING_CID_HANDLER_H +#define CIAO_PACKAGING_CID_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "IDREF_Base.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" +#include "tao/Basic_Types.h" + +namespace Deployment +{ + struct ComponentImplementationDescription; +} + + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentImplementationDescription; + + namespace Packaging + { + + /** + * @class CID_Handler + * + * @brief Handler class for <CCMComponentImplementationDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Packaging_Handlers_Export CID_Handler + { + + public: + /// Maps the values from the XSC object + /// <ComponentImplementationDescription> to the CORBA IDL type + /// <Deployment::ComponentImplementationDescription>. + static void component_impl_descr (const ComponentImplementationDescription &desc, + ::Deployment::ComponentImplementationDescription &toconfig); + + static IDREF_Base<CORBA::ULong> IDREF; + + static ComponentImplementationDescription + component_impl_descr (const Deployment::ComponentImplementationDescription& src); + + private: + + static ComponentImplementationDescription * resolve_cid (const ACE_TCHAR *uri); + }; + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_PACKAGING_CID_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp new file mode 100644 index 00000000000..885e76b005a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp @@ -0,0 +1,160 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "Package_Handlers/CPD_Handler.h" +#include "Package_Handlers/CID_Handler.h" +#include "Package_Handlers/Comp_Intf_Descr_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "Deployment.hpp" +#include "Utils/Exceptions.h" +#include "Property_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + struct Packaging_Handlers_Export PCI_Handler + { + static void handle_pci (const PackagedComponentImplementation &desc, + ::Deployment::PackagedComponentImplementation &toconfig) + { + CIAO_TRACE ("PCI_Handler::get_pci"); + toconfig.name = ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + + CID_Handler::component_impl_descr (desc.referencedImplementation (), + toconfig.referencedImplementation); + } + + static PackagedComponentImplementation + get_pci (const ::Deployment::PackagedComponentImplementation &src) + { + CIAO_TRACE ("PCI_Handler::get_pci - reverse"); + return PackagedComponentImplementation (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()), + CID_Handler::component_impl_descr (src.referencedImplementation)); + } + }; + + typedef Sequence_Handler < PackagedComponentImplementation, + ::Deployment::PackagedComponentImplementations, + ::Deployment::PackagedComponentImplementation, + PCI_Handler::handle_pci > PCI_Functor; + + + void + CPD_Handler::handle_component_package_descr (const ComponentPackageDescription &desc, + ::Deployment::ComponentPackageDescription &toconfig) + { + CIAO_TRACE ("CPD_Handler::component_package_descr"); + + auto_ptr < ComponentPackageDescription > xsc_cpd; + const ComponentPackageDescription *cpd = 0; + + if (desc.href_p ()) + { + xsc_cpd.reset (CPD_Handler::resolve_cpd (desc.href ().c_str ())); + cpd = xsc_cpd.get (); + } + else + cpd = &desc; + + if (cpd->label_p ()) + toconfig.label = ACE_TEXT_ALWAYS_CHAR (cpd->label ().c_str ()); + + if (cpd->UUID_p ()) + toconfig.UUID = ACE_TEXT_ALWAYS_CHAR (cpd->UUID ().c_str ()); + + // CID + if (cpd->realizes_p ()) + Comp_Intf_Descr_Handler::comp_intf_descr (cpd->realizes (), + toconfig.realizes); + + // Config Properties + toconfig.configProperty.length (desc.count_configProperty ()); + std::for_each (cpd->begin_infoProperty (), + cpd->end_infoProperty (), + Property_Functor (toconfig.configProperty)); + + // ACE_ERROR ((LM_ERROR, "***** Count of PCIs is %i\n", + // cpd->count_implementation ())); + + // Packaged Component Implementations + toconfig.implementation.length ( cpd->count_implementation ()); + SEQ_HAND_GCC_BUG_WORKAROUND (PCI_Handler::handle_pci, + (*cpd->begin_implementation ()), + toconfig.implementation); + std::for_each (cpd->begin_implementation (), + cpd->end_implementation (), + PCI_Functor (toconfig.implementation)); + + // Info Properties + toconfig.infoProperty.length (cpd->count_infoProperty ()); + std::for_each (cpd->begin_infoProperty (), + cpd->end_infoProperty (), + Property_Functor (toconfig.infoProperty)); + } + + ComponentPackageDescription + CPD_Handler::component_package_descr (const Deployment::ComponentPackageDescription& src) + { + CIAO_TRACE ("CPD_Handler::component_package_descr - reverse"); + ComponentPackageDescription toconfig; + + if (src.label.in () != 0) + toconfig.label (ACE_TEXT_CHAR_TO_TCHAR (src.label.in ())); + + if (src.UUID.in () != 0) + toconfig.UUID (ACE_TEXT_CHAR_TO_TCHAR (src.UUID.in ())); + + { + toconfig.realizes + (Comp_Intf_Descr_Handler::comp_intf_descr (src.realizes)); + } +#if 0 + for (size_t i = 0; i < src.configProperty.length (); ++i) + { + toconfig.add_configProperty ( + Property_Handler::get_property (src.configProperty[i])); + } + + { // Packaged Component Implementations + for (size_t i = 0; i < src.implementation.length (); ++i) + toconfig.add_implementation ( + PCI_Handler::get_pci (src.implementation[i])); + } + + for (size_t i = 0; i < src.infoProperty.length (); ++i) + { + toconfig.add_infoProperty ( + Property_Handler::get_property (src.infoProperty[i])); + } +#endif + return toconfig; + } + + ComponentPackageDescription * CPD_Handler::resolve_cpd (const ACE_TCHAR *uri) + { + CIAO_TRACE ("CPD_Handler::resolve_cpd"); + if (!XML_Helper::XML_HELPER.is_initialized ()) + return 0; + + xercesc::DOMDocument* dom = + XML_Helper::XML_HELPER.create_dom (uri); + + if (!dom) + throw Parse_Error (ACE_TEXT ("Unable to create DOM for component package description")); + + try { + //ACE_ERROR ((LM_ERROR, "Creating new CPD XSC Object\n")); + return new ComponentPackageDescription (reader::componentPackageDescription (dom)); + } + catch (...) { + throw Parse_Error (ACE_TEXT ("Unable to create XSC structure for CID")); + } + } + } + + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.h new file mode 100644 index 00000000000..049b2a72cb2 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.h @@ -0,0 +1,74 @@ +//================================================ +/** + * @file CPD_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_CPD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_CPD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include <memory> +#include "XML_Typedefs.h" +#include "Utils/Functors.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" + +namespace Deployment +{ + struct ComponentPackageDescription; + class ComponentPackageDescriptions; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentPackageDescription; + + namespace Packaging + { + + /* + * @class CPD_Handler + * + * @brief Handler class for <CCMComponentPackageDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Packaging_Handlers_Export CPD_Handler + { + + public: + /// Maps the values from the XSC object + /// <ComponentPackageDescription> to the CORBA IDL type + /// <Deployment::ComponentPackageDescription>. + static void handle_component_package_descr (const ComponentPackageDescription &desc, + ::Deployment::ComponentPackageDescription &toconfig); + + static ComponentPackageDescription + component_package_descr (const Deployment::ComponentPackageDescription& src); + private: + static ComponentPackageDescription * resolve_cpd (const ACE_TCHAR *uri); + + }; + + typedef Sequence_Handler < ComponentPackageDescription, + ::Deployment::ComponentPackageDescriptions, + ::Deployment::ComponentPackageDescription, + CPD_Handler::handle_component_package_descr > CPD_Functor; + + } + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CPD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp new file mode 100644 index 00000000000..424985705d8 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp @@ -0,0 +1,165 @@ +// $Id$ +#include "tao/AnyTypeCode/TypeCode.h" +#include "Comp_Intf_Descr_Handler.h" +#include "XML_Typedefs.h" +#include "Utils/Exceptions.h" +#include "Utils/Functors.h" +#include "DataType_Handler.h" +#include "Property_Handler.h" +#include "Deployment.hpp" +#include "Package_Handlers/CPD_Handler.h" +#include "tools/Config_Handlers/CPD_Handler.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + struct Comp_Prop_Handler + { + static void handle_cpd (const ComponentPropertyDescription &desc, + ::Deployment::ComponentPropertyDescription &toconfig) + { + CIAO_TRACE ("Comp_Prop_Handler::get_cpd"); + + toconfig.name = ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + DataType_Handler::data_type (desc.type (), + toconfig.type); + } + + static ComponentPropertyDescription + get_cpd (const ::Deployment::ComponentPropertyDescription &src) + { + CIAO_TRACE ("Comp_Prop_Handler::get_cpd - reverse"); + + return ComponentPropertyDescription (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()), + DataType_Handler::data_type (src.type)); + } + + }; + + typedef Sequence_Handler < ComponentPropertyDescription, + ::Deployment::ComponentPropertyDescriptions, + ::Deployment::ComponentPropertyDescription, + Comp_Prop_Handler::handle_cpd > Comp_Prop_Functor; + + + void + Comp_Intf_Descr_Handler::comp_intf_descr ( + const ComponentInterfaceDescription &desc, + ::Deployment::ComponentInterfaceDescription &toconfig) + { + CIAO_TRACE ("Comp_Intf_Descr_Handler::comp_intf_descr"); + + const ComponentInterfaceDescription *cid = 0; + std::auto_ptr <ComponentInterfaceDescription> safe_cid; + + if (desc.href_p ()) + { + safe_cid.reset (Comp_Intf_Descr_Handler::resolve_cid (desc.href ().c_str ())); + cid = safe_cid.get (); + } + else + cid = &desc; + + if (cid->label_p ()) + toconfig.label = ACE_TEXT_ALWAYS_CHAR (cid->label ().c_str ()); + + if (cid->UUID_p ()) + toconfig.UUID = ACE_TEXT_ALWAYS_CHAR (cid->UUID ().c_str ()); + + // MAJO: SpecificType should be required. + if (cid->specificType_p ()) + toconfig.specificType = ACE_TEXT_ALWAYS_CHAR (cid->specificType ().c_str ()); + + toconfig.supportedType.length (cid->count_supportedType ()); + std::for_each (cid->begin_supportedType (), + cid->end_supportedType (), + String_Seq_Functor (toconfig.supportedType)); + + toconfig.idlFile.length (cid->count_idlFile ()); + std::for_each (cid->begin_idlFile (), + cid->end_idlFile (), + String_Seq_Functor (toconfig.idlFile)); + + toconfig.configProperty.length (cid->count_configProperty ()); + std::for_each (cid->begin_configProperty (), + cid->end_configProperty (), + Property_Functor (toconfig.configProperty)); + + toconfig.port.length (cid->count_port ()); + std::for_each (cid->begin_port (), + cid->end_port (), + CIAO::Config_Handlers::CPD_Functor (toconfig.port)); + + toconfig.property.length (cid->count_property ()); + SEQ_HAND_GCC_BUG_WORKAROUND (Comp_Prop_Handler::handle_cpd, + (*cid->begin_property ()), + toconfig.property); + std::for_each (cid->begin_property (), + cid->end_property (), + Comp_Prop_Functor (toconfig.property)); + + toconfig.infoProperty.length (cid->count_infoProperty ()); + std::for_each (cid->begin_infoProperty (), + cid->end_infoProperty (), + Property_Functor (toconfig.infoProperty)); + } + + + ComponentInterfaceDescription + Comp_Intf_Descr_Handler::comp_intf_descr ( + const ::Deployment::ComponentInterfaceDescription &src) + { + CIAO_TRACE ("Comp_Intf_Descr_Handler::comp_intf_descr - reverse"); + ComponentInterfaceDescription retval; + + retval.label (ACE_TEXT_CHAR_TO_TCHAR (src.label.in ())); + retval.UUID (ACE_TEXT_CHAR_TO_TCHAR (src.UUID.in ())); + retval.specificType (ACE_TEXT_CHAR_TO_TCHAR (src.specificType.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.supportedType.length (); ++i) + retval.add_supportedType (src.supportedType[i].in ()); + + for (CORBA::ULong i = 0; i < src.idlFile.length (); ++i) + retval.add_idlFile (src.idlFile[i].in ()); + + for (CORBA::ULong i = 0; i < src.configProperty.length (); ++i) + retval.add_configProperty ( + Property_Handler::get_property (src.configProperty[i])); + + for (CORBA::ULong i = 0; i < src.port.length (); ++i) + retval.add_port + (CIAO::Config_Handlers::CPD_Handler::component_port_description (src.port[i])); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (Comp_Prop_Handler::get_cpd (src.property[i])); + + for (CORBA::ULong i = 0; i < src.infoProperty.length (); ++i) + retval.add_infoProperty ( + Property_Handler::get_property (src.infoProperty[i])); +#endif + return retval; + } + + ComponentInterfaceDescription * + Comp_Intf_Descr_Handler::resolve_cid (const ACE_TCHAR *uri) + { + CIAO_TRACE ("Comp_Intf_Descr_Handler::resolve_cid"); + + xercesc::DOMDocument *dom = XML_Helper::XML_HELPER.create_dom (uri); + + if (!dom) + throw Parse_Error (ACE_TEXT ("Unable to create DOM for Component Interface Description.")); + + try { + return new ComponentInterfaceDescription + (reader::componentInterfaceDescription (dom)); + } + catch (...) { + throw Parse_Error (ACE_TEXT ("Unable to create XSC structure for Component Interface Description")); + } + } + } + }} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h new file mode 100644 index 00000000000..4655edfa97b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h @@ -0,0 +1,54 @@ +/** + * @file Comp_Intf_Descr_Handler.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + +#ifndef CIAO_PACKAGING_COMP_INTF_DESCR_HANDLER_H +#define CIAO_PACKAGING_COMP_INTF_DESCR_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "XML_Typedefs.h" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentInterfaceDescription; + + namespace Packaging + { + + /** + * @class Comp_Intf_Descr_Handler + * + * @brief Handler class for ComponentInterfaceDescription. + */ + class Packaging_Handlers_Export Comp_Intf_Descr_Handler + { + public: + static void comp_intf_descr (const ComponentInterfaceDescription &descr, + ::Deployment::ComponentInterfaceDescription &toconfig); + + static ComponentInterfaceDescription + comp_intf_descr (const ::Deployment::ComponentInterfaceDescription &src); + + private: + static ComponentInterfaceDescription *resolve_cid (const ACE_TCHAR *uri); + }; + } + } +} + +#include /**/ "ace/post.h" + +#endif /* CIAO_PACKAGING_COMP_INTF_DESCR_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp new file mode 100644 index 00000000000..0ef8e6bda5f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp @@ -0,0 +1,124 @@ +// $Id$ +#include "Package_Handlers/IAD_Handler.h" +#include "Package_Handlers/NIA_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "Property_Handler.h" +#include "Req_Handler.h" +#include "Utils/Functors.h" +#include "Utils/Exceptions.h" +#include "XML_Typedefs.h" + +#include "Deployment.hpp" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + + void + IAD_Handler::impl_artifact_descr (const ImplementationArtifactDescription &desc, + ::Deployment::ImplementationArtifactDescription &toconfig) + { + CIAO_TRACE ("IAD_Handler::impl_artifact_descr"); + + const ImplementationArtifactDescription *iad = 0; + std::auto_ptr <ImplementationArtifactDescription> safe_iad; + + if (desc.href_p ()) + { + safe_iad.reset (IAD_Handler::resolve_iad (desc.href ().c_str ())); + iad = safe_iad.get (); + } + else + iad = &desc; + + + if (iad->label_p ()) + toconfig.label = ACE_TEXT_ALWAYS_CHAR ( iad->label ().c_str ()); + + if (iad->UUID_p ()) + toconfig.UUID = ACE_TEXT_ALWAYS_CHAR (iad->UUID ().c_str ()); + + toconfig.location.length (iad->count_location ()); + std::for_each (iad->begin_location (), + iad->end_location (), + String_Seq_Functor (toconfig.location)); + + toconfig.dependsOn.length (iad->count_dependsOn ()); + SEQ_HAND_GCC_BUG_WORKAROUND (NIA_Handler::handle_nia, + (*desc.begin_dependsOn ()), + toconfig.dependsOn); + std::for_each (iad->begin_dependsOn (), + iad->end_dependsOn (), + NIA_Functor (toconfig.dependsOn)); + + toconfig.execParameter.length (iad->count_execParameter ()); + std::for_each (iad->begin_execParameter (), + iad->end_execParameter (), + Property_Functor (toconfig.execParameter)); + + toconfig.infoProperty.length (iad->count_infoProperty ()); + std::for_each (iad->begin_infoProperty (), + iad->end_infoProperty (), + Property_Functor (toconfig.infoProperty)); + + toconfig.deployRequirement.length (iad->count_deployRequirement ()); + std::for_each (iad->begin_deployRequirement (), + iad->end_deployRequirement (), + Requirement_Functor (toconfig.deployRequirement )); + } + + ImplementationArtifactDescription + IAD_Handler::impl_artifact_descr (const ::Deployment::ImplementationArtifactDescription &src) + { + CIAO_TRACE ("IAD_Handler::impl_artifact_descr - reverse"); + ImplementationArtifactDescription retval; + + retval.label (ACE_TEXT_CHAR_TO_TCHAR (src.label.in ())); + retval.UUID (ACE_TEXT_CHAR_TO_TCHAR (src.UUID.in ())); +#if 0 + for (CORBA::ULong i = 0; i < src.location.length (); ++i) + retval.add_location (src.location[i].in ()); + + for (CORBA::ULong i = 0; i < src.dependsOn.length (); ++i) + retval.add_dependsOn (NIA_Handler::get_nia (src.dependsOn[i])); + + for (CORBA::ULong i = 0; i < src.execParameter.length (); ++i) + retval.add_execParameter + (Property_Handler::get_property (src.execParameter[i])); + + for (CORBA::ULong i = 0; i < src.infoProperty.length (); ++i) + retval.add_infoProperty + (Property_Handler::get_property ( src.infoProperty[i])); + + for (CORBA::ULong i = 0; i < src.deployRequirement.length (); ++i) + retval.add_deployRequirement + (Req_Handler::get_requirement (src.deployRequirement[i])); +#endif + return retval; + } + + ImplementationArtifactDescription * IAD_Handler::resolve_iad (const ACE_TCHAR *uri) + { + CIAO_TRACE ("IAD_Handler::resolve_iad"); + + xercesc::DOMDocument *dom = XML_Helper::XML_HELPER.create_dom (uri); + + if (!dom) + throw Parse_Error (ACE_TEXT ("Unable to create DOM for IAD")); + + try { + return new ImplementationArtifactDescription + (reader::implementationArtifactDescription (dom)); + } + catch (...) { + throw Parse_Error (ACE_TEXT ("Unable to create XSC structure for IAD")); + } + } + + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.h new file mode 100644 index 00000000000..89fdab073bf --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.h @@ -0,0 +1,66 @@ +//================================================ +/** + * @file IAD_Handler.h + * + * $Id$ + * + * @author William Otte <wotte@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Package_Handlers/Packaging_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ImplementationArtifactDescription; + struct ImplementationArtifactDescriptions; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ImplementationArtifactDescription; + namespace Packaging + { + /* + * @class IAD_Handler + * + * @brief Handler class for <CCMImplementationArtifactDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Packaging_Handlers_Export IAD_Handler + { + public: + /// Maps the values from the XSC object + /// <ImplementationArtifactDescription> to the CORBA IDL type + /// <Deployment::ImplementationArtifactDescription>. + static void + impl_artifact_descr (const ImplementationArtifactDescription &desc, + ::Deployment::ImplementationArtifactDescription &toconfig); + + + static ImplementationArtifactDescription + impl_artifact_descr (const Deployment::ImplementationArtifactDescription& src); + + static ImplementationArtifactDescription * resolve_iad (const ACE_TCHAR *uri); + }; + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/NIA_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/NIA_Handler.h new file mode 100644 index 00000000000..923104dc27b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/NIA_Handler.h @@ -0,0 +1,65 @@ +/** + * @file NIA_Handler.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * $Id$ + */ + +#ifndef CIAO_PACKAGING_NIA_HANDLER_H +#define CIAO_PACKAGING_NIA_HANDLER_H + +#include /**/ "ace/pre.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" +#include "Utils/Functors.h" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "iad.hpp" + +namespace Deployment +{ + struct NamedImplementationArtifact; + class NamedImplementationArtifacts; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class NamedImplementationArtifact; + + namespace Packaging + { + /** + * @class NIA_Handler + * @brief Handler class for NamedImplementationArtifact types. + */ + class Packaging_Handlers_Export NIA_Handler + { + public: + static void handle_nia (const NamedImplementationArtifact &desc, + ::Deployment::NamedImplementationArtifact &toconfig) + { + toconfig.name = ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + IAD_Handler::impl_artifact_descr (desc.referencedArtifact (), + toconfig.referencedArtifact); + } + + + static NamedImplementationArtifact + get_nia (const ::Deployment::NamedImplementationArtifact &src) + { + return NamedImplementationArtifact (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ()), + IAD_Handler::impl_artifact_descr (src.referencedArtifact)); + } + + }; + + typedef Sequence_Handler < NamedImplementationArtifact, + ::Deployment::NamedImplementationArtifacts, + ::Deployment::NamedImplementationArtifact, + NIA_Handler::handle_nia > NIA_Functor; + } + } +} + +#include /**/ "ace/post.h" + +#endif /* CIAO_PACKAGING_NIA_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp new file mode 100644 index 00000000000..f1faaf68295 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp @@ -0,0 +1,165 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "ciao/Logger/Log_Macros.h" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "XML_Typedefs.h" +#include "XML/XercesString.h" +#include "Utils/Exceptions.h" +#include "Package_Handlers/PCD_Handler.h" +#include "Package_Handlers/CPD_Handler.h" +#include "toplevel.hpp" +#include "Deployment.hpp" +#include "Property_Handler.h" +#include "Req_Handler.h" + +#include <memory> + +using CIAO::XML::XStr; + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + void + PCD_Handler::package_config (const ACE_TCHAR *uri, + ::Deployment::PackageConfiguration &toconfig) + { + XERCES_CPP_NAMESPACE::DOMDocument *dom = XML_Helper::XML_HELPER.create_dom (uri); + + if (dom == 0) + { + std::basic_string<ACE_TCHAR> error (ACE_TEXT ("Unable to open file: ")); + error += uri; + throw Parse_Error (error); + } + + XStr root = dom->getDocumentElement ()->getTagName (); + + if (root == XStr (ACE_TEXT ("Deployment:topLevelPackageDescription"))) + { + TopLevelPackageDescription tpd; + + tpd = reader::topLevelPackageDescription (dom); + + PCD_Handler::package_config (*(*tpd.begin_package ()), + toconfig); + } + else if (root == XStr (ACE_TEXT ("Deployment:packageConfiguration"))) + { + PackageConfiguration pcd; + pcd = reader::packageConfiguration (dom); + PCD_Handler::package_config (pcd, toconfig); + } + else + { + std::string error ("Invliad file passed to package_config, has base "); + + char *croot = xercesc::XMLString::transcode (root); + + error += croot; + + delete [] croot; + + throw Plan_Error (ACE_TEXT ("Invalid file passed to package_config, had base")); + } + } + + void + PCD_Handler::package_config (const PackageConfiguration &desc, + ::Deployment::PackageConfiguration &toconfig) + { + CIAO_TRACE ("PCD_Handler::package_config"); + std::auto_ptr < PackageConfiguration > xsc_pcd; + + const PackageConfiguration *pcd; + + if (desc.contentLocation_p ()) + { + // Take ownership of the resolved pcd + xsc_pcd.reset (PCD_Handler::resolve_package_config (desc.contentLocation ().c_str ())); + pcd = xsc_pcd.get (); + } + else + pcd = &desc; + + if (pcd->label_p ()) + toconfig.label = + ACE_TEXT_ALWAYS_CHAR (pcd->label ().c_str ()); + + if (pcd->UUID_p ()) + toconfig.UUID = + ACE_TEXT_ALWAYS_CHAR (pcd->UUID ().c_str ()); + + if (pcd->basePackage_p ()) + { + toconfig.basePackage.length (1); + CPD_Handler::handle_component_package_descr (pcd->basePackage (), + toconfig.basePackage [0]); + } + + // @@ MAJO: Support other elements present here. + + toconfig.configProperty.length (desc.count_configProperty ()); + std::for_each (desc.begin_configProperty (), + desc.end_configProperty (), + Property_Functor (toconfig.configProperty)); + + toconfig.selectRequirement.length (desc.count_selectRequirement ()); + std::for_each (desc.begin_selectRequirement (), + desc.end_selectRequirement (), + Requirement_Functor (toconfig.selectRequirement)); + + } + + PackageConfiguration + PCD_Handler::package_config (const Deployment::PackageConfiguration& src) + { + CIAO_TRACE ("PCD_Handler::package_config - reverse"); + PackageConfiguration pcd = PackageConfiguration (); + + if (src.label.in () != 0) + pcd.label (ACE_TEXT_CHAR_TO_TCHAR (src.label.in ())); + + if (src.UUID.in () != 0) + pcd.UUID (ACE_TEXT_CHAR_TO_TCHAR (src.UUID.in ())); + + if (src.basePackage.length () > 0) + { + ACE_DEBUG ((LM_DEBUG, "5\n")); + pcd.basePackage (CPD_Handler::component_package_descr (src.basePackage[0])); + } +#if 0 + // @@ MAJO: Support other elements present here. + for (CORBA::ULong i = 0; i < src.configProperty.length (); ++i) + pcd.add_configProperty (Property_Handler::get_property (src.configProperty[i])); + + for (CORBA::ULong i = 0; i < src.selectRequirement.length (); ++i) + pcd.add_selectRequirement (Req_Handler::get_requirement (src.selectRequirement[i])); +#endif + return pcd; + + } + + PackageConfiguration * PCD_Handler::resolve_package_config (const ACE_TCHAR *uri) + { + xercesc::DOMDocument* dom = + XML_Helper::XML_HELPER.create_dom (uri); + + if (!dom) + throw Parse_Error (ACE_TEXT ("Unable to create DOM for PackageConfiguration")); + + try { + return new PackageConfiguration (reader::packageConfiguration (dom)); + } + catch (...) { + throw Parse_Error (ACE_TEXT ("Unable to create XSC structure for PackageConfiguration")); + } + + } + + + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.h new file mode 100644 index 00000000000..b1a0c377d9d --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.h @@ -0,0 +1,69 @@ +//================================================ +/** + * @file PCD_Handler.h + * + * $Id$ + * + * @author William Otte <wotte@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_PCD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PCD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Packaging_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct PackageConfiguration; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class PackageConfiguration; + + namespace Packaging + { + /* + * @class PCD_Handler + * + * @brief Handler class for <CCMPackageConfiguration> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Packaging_Handlers_Export PCD_Handler + { + + public: + static void package_config (const ACE_TCHAR *uri, + ::Deployment::PackageConfiguration &toconfig); + + /// Maps the values from the XSC object + /// <PackageConfiguration> to the CORBA IDL type + /// <Deployment::PackageConfiguration>. + static void package_config (const PackageConfiguration &desc, + ::Deployment::PackageConfiguration &toconfig); + + static PackageConfiguration package_config (const Deployment::PackageConfiguration& src); + + private: + static PackageConfiguration *resolve_package_config (const ACE_TCHAR *uri); + }; + } + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.cpp new file mode 100644 index 00000000000..19125aebb92 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.cpp @@ -0,0 +1,75 @@ +// $Id$ + +#include "STD_PC_Intf.h" +#include "Utils/XML_Helper.h" +#include "Deployment.hpp" +#include "STD_PCD_Handler.h" +#include "ciao/Packaging_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + STD_PC_Intf::STD_PC_Intf (const char *file) + { + if (!this->prepare_PC (file)) + throw; + } + + bool + STD_PC_Intf::prepare_PC (const char *file) + { + CIAO_TRACE("STD_PC_Intf::prepare_PC"); + + ACE_Auto_Ptr<XML_Helper> helper (new XML_Helper); + + if (!helper->is_initialized ()) + return false; + + // parse the .pcd (PackageConfigurationDescription) file + xercesc::DOMDocument *dom = + helper->create_dom (file); + + if (!dom) + return false; + + + PackageConfiguration pc = + packageConfiguration (dom); + + + Deployment::PackageConfiguration idl_pc; + + + STD_PCD_Handler pcd_handler (helper.get ()); + + pcd_handler.package_config (pc, + idl_pc); + + + Deployment::PackageConfiguration *p_idl_pc = + new Deployment::PackageConfiguration (idl_pc); + + // let ACE_Auto_Ptr take over + this->idl_pc_.reset (p_idl_pc); + + if (this->idl_pc_.get ()) + return true; + + return false; + } + + ::Deployment::PackageConfiguration const * + STD_PC_Intf::get_PC (void) const + { + return this->idl_pc_.get (); + } + + ::Deployment::PackageConfiguration * + STD_PC_Intf::get_PC (void) + { + return this->idl_pc_.release (); + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.h new file mode 100644 index 00000000000..c15ae0389b9 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.h @@ -0,0 +1,58 @@ +//============================================================== +/** + * @file PC_Intf.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_STD_PC_INTF_H +#define CIAO_CONFIG_STD_PC_INTF_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#include "ace/Auto_Ptr.h" + + +namespace Deployment +{ + struct PackageConfiguration ; +} + +namespace CIAO +{ + namespace Config_Handlers + { + /* + * @class PC_Intf + * + * @brief Wrapper class for PackageConfiguration extraction + * + * This class defines wrapper functions for extracting + * PackageConfiguration IDL structures from XSC structures. + * It serves as the public interface used by application + * developers. + * + */ + class Config_Handlers_Export STD_PC_Intf + { + public: + STD_PC_Intf (const char *file); + + ::Deployment::PackageConfiguration const *get_PC (void) const; + ::Deployment::PackageConfiguration *get_PC (void); + + protected: + bool prepare_PC (const char *file); + + private: + ACE_Auto_Ptr< ::Deployment::PackageConfiguration> idl_pc_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_STD_PC_INTF_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc new file mode 100644 index 00000000000..0f898981ef3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc @@ -0,0 +1,52 @@ +// $Id$ + +project (Package_Config_Handlers) : acelib, dance_deployment_stub, ciao_config_handlers_base, dance, typecodefactory, ciao_output { + sharedname = Package_Config_Handlers + dynamicflags = PACKAGING_HANDLERS_BUILD_DLL + + includes += $(CIAO_ROOT)/ciao + libpaths += $(CIAO_ROOT)/bin + + after += XSC_Config_Handlers_Common \ + XSC_Config_Handlers \ + XSC_DynAny_Handler \ + XSC_XML_Handlers \ + CIAO_XML_Utils \ + + libs += XSC_Config_Handlers_Common \ + XSC_Config_Handlers \ + XSC_DynAny_Handler \ + XSC_XML_Handlers \ + CIAO_XML_Utils \ + + Source_files { + CAD_Handler.cpp + CID_Handler.cpp + Comp_Intf_Descr_Handler.cpp + CPD_Handler.cpp + IAD_Handler.cpp + PCD_Handler.cpp + SID_Handler.cpp + } + + Header_Files { + CAD_Handler.h + CID_Handler.h + Comp_Intf_Descr_Handler.h + CPD_Handler.h + IAD_Handler.h + PCD_Handler.h + SID_Handler.h + } + +} + +project (Package_Config_Handlers_Tests) : dance_deployment_stub, ciao_config_handlers, ifr_client { + exename = test + macros += XML_USE_PTHREADS + requires += dummy_label + + Source_Files { + test.cpp + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/Packaging_Handlers_Export.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Packaging_Handlers_Export.h new file mode 100644 index 00000000000..86193a1a664 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/Packaging_Handlers_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl Packaging_Handlers +// ------------------------------ +#ifndef PACKAGING_HANDLERS_EXPORT_H +#define PACKAGING_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (PACKAGING_HANDLERS_HAS_DLL) +# define PACKAGING_HANDLERS_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && PACKAGING_HANDLERS_HAS_DLL */ + +#if !defined (PACKAGING_HANDLERS_HAS_DLL) +# define PACKAGING_HANDLERS_HAS_DLL 1 +#endif /* ! PACKAGING_HANDLERS_HAS_DLL */ + +#if defined (PACKAGING_HANDLERS_HAS_DLL) && (PACKAGING_HANDLERS_HAS_DLL == 1) +# if defined (PACKAGING_HANDLERS_BUILD_DLL) +# define Packaging_Handlers_Export ACE_Proper_Export_Flag +# define PACKAGING_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define PACKAGING_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* PACKAGING_HANDLERS_BUILD_DLL */ +# define Packaging_Handlers_Export ACE_Proper_Import_Flag +# define PACKAGING_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define PACKAGING_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* PACKAGING_HANDLERS_BUILD_DLL */ +#else /* PACKAGING_HANDLERS_HAS_DLL == 1 */ +# define Packaging_Handlers_Export +# define PACKAGING_HANDLERS_SINGLETON_DECLARATION(T) +# define PACKAGING_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* PACKAGING_HANDLERS_HAS_DLL == 1 */ + +// Set PACKAGING_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (PACKAGING_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define PACKAGING_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define PACKAGING_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !PACKAGING_HANDLERS_NTRACE */ + +#if (PACKAGING_HANDLERS_NTRACE == 1) +# define PACKAGING_HANDLERS_TRACE(X) +#else /* (PACKAGING_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define PACKAGING_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (PACKAGING_HANDLERS_NTRACE == 1) */ + +#endif /* PACKAGING_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp new file mode 100644 index 00000000000..a9947281202 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp @@ -0,0 +1,142 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "Package_Handlers/SID_Handler.h" +#include "cid.hpp" +#include "DAnCE/Deployment/DeploymentC.h" +#include "Package_Handlers/CPD_Handler.h" +#include "Package_Handlers/PCD_Handler.h" +#include "Package_Handlers/Comp_Intf_Descr_Handler.h" +#include "Req_Handler.h" +#include "Property_Handler.h" + +#include "ace/UUID.h" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + IDREF_Base<CORBA::ULong> SID_Handler::IDREF; + + void + SID_Handler::handle_sub_comp_inst_descr (const SubcomponentInstantiationDescription &desc, + ::Deployment::SubcomponentInstantiationDescription &toconfig) + { + CIAO_TRACE ("SID_Handler::sub_comp_inst_descr"); + toconfig.name = ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + + if (desc.basePackage_p ()) + { + toconfig.basePackage.length (1); + CPD_Handler::handle_component_package_descr (desc.basePackage (), + toconfig.basePackage[0]); + } + else if (desc.specializedConfig_p ()) + { + toconfig.specializedConfig.length (1); + PCD_Handler::package_config (desc.specializedConfig (), + toconfig.specializedConfig[0]); + } + else if (desc.importedPackage_p ()) + { + toconfig.importedPackage.length (1); + toconfig.importedPackage[0].location.length (desc.importedPackage ().count_location ()); + + std::for_each (desc.importedPackage ().begin_location (), + desc.importedPackage ().end_location (), + String_Seq_Functor (toconfig.importedPackage[0].location)); + } + else if (desc.referencedPackage_p ()) + { + toconfig.referencedPackage.length (1); + + if (desc.referencedPackage ().requiredUUID_p ()) + toconfig.referencedPackage[0].requiredUUID = + ACE_TEXT_ALWAYS_CHAR (desc.referencedPackage ().requiredUUID ().c_str ()); + + if (desc.referencedPackage ().requiredName_p ()) + toconfig.referencedPackage[0].requiredName = + ACE_TEXT_ALWAYS_CHAR (desc.referencedPackage ().requiredName ().c_str ()); + + Comp_Intf_Descr_Handler::comp_intf_descr (desc.referencedPackage ().requiredType (), + toconfig.referencedPackage[0].requiredType); + + } + + toconfig.selectRequirement.length (desc.count_selectRequirement ()); + std::for_each (desc.begin_selectRequirement (), + desc.end_selectRequirement (), + Requirement_Functor (toconfig.selectRequirement)); + + toconfig.configProperty.length (desc.count_configProperty ()); + std::for_each (desc.begin_configProperty (), + desc.end_configProperty (), + Property_Functor (toconfig.configProperty)); + + if (desc.id_p ()) + { + ACE_TString str (desc.id ().c_str ()); + SID_Handler::IDREF.bind_next_available (str); + } + else + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Warning: SID With Name %s has no ID\n"), + desc.name ().c_str ())); + + } + + SubcomponentInstantiationDescription + SID_Handler::sub_comp_inst_descr (const Deployment::SubcomponentInstantiationDescription &src) + { + CIAO_TRACE ("SID_Handler::sub_comp_inst_descr - reverse"); + SubcomponentInstantiationDescription retval (ACE_TEXT_CHAR_TO_TCHAR (src.name.in ())); + + if (src.basePackage.length () == 1) + retval.basePackage + (CPD_Handler::component_package_descr (src.basePackage[0])); + else if (src.specializedConfig.length () == 1) + retval.specializedConfig + (PCD_Handler::package_config (src.specializedConfig[0])); + else if (src.importedPackage.length () == 1) + { + ComponentPackageImport ci; +#if 0 + for (CORBA::ULong i = 0; i < src.importedPackage[0].location.length (); ++i) + ci.add_location (src.importedPackage[0].location[i].in ()); +#endif + retval.importedPackage (ci); + } + else if (src.referencedPackage.length () == 1) + { + ComponentPackageReference cpr (Comp_Intf_Descr_Handler::comp_intf_descr (src.referencedPackage[0].requiredType)); + cpr.requiredUUID (ACE_TEXT_CHAR_TO_TCHAR (src.referencedPackage[0].requiredUUID.in ())); + cpr.requiredName (ACE_TEXT_CHAR_TO_TCHAR (src.referencedPackage[0].requiredName.in ())); + + retval.referencedPackage (cpr); + } +#if 0 + for (CORBA::ULong i = 0; i < src.selectRequirement.length (); ++i) + retval.add_selectRequirement + (Req_Handler::get_requirement (src.selectRequirement[i])); + + for (CORBA::ULong i = 0; i < src.configProperty.length (); ++i) + retval.add_configProperty + (Property_Handler::get_property (src.configProperty[i])); +#endif + // @@MAJO This is not a good way of binding reverse IDREFS. + std::auto_ptr <ACE_Utils::UUID> safe_uuid ( + ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID ()); + ACE_TString uuid ( ACE_TEXT_CHAR_TO_TCHAR (safe_uuid->to_string ()->c_str ())); + + // ACE_ERROR ((LM_ERROR, "*** Binding to %s\n", + // uuid.c_str ())); + + SID_Handler::IDREF.bind_next_available (uuid); + + return retval; + } + + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.h b/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.h new file mode 100644 index 00000000000..2083b91b9b6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.h @@ -0,0 +1,71 @@ +/** + * @file SID_Handler.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + + +#ifndef CIAO_PACKAGING_SID_HANDLER_H +#define CIAO_PACKAGING_SID_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "XML_Typedefs.h" +#include "Utils/Functors.h" +#include "IDREF_Base.h" +#include "Package_Handlers/Packaging_Handlers_Export.h" + +namespace Deployment +{ + struct SubcomponentInstantiationDescription; + class SubcomponentInstantiationDescriptions; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class SubcomponentInstantiationDescription; + + namespace Packaging + { + /** + * @class SID_Handler + * @brief Handler class for SubcomponentInstantiationDescription + */ + class Packaging_Handlers_Export SID_Handler + { + SID_Handler (XML_Helper *xml_helper) + : xml_helper_ (xml_helper) + { + + } + + public: + static void handle_sub_comp_inst_descr (const SubcomponentInstantiationDescription &desc, + ::Deployment::SubcomponentInstantiationDescription &toconfig); + + static SubcomponentInstantiationDescription + sub_comp_inst_descr (const ::Deployment::SubcomponentInstantiationDescription &src); + + static IDREF_Base< CORBA::ULong > IDREF; + + private: + static SubcomponentInstantiationDescription *resolve_sid (const char *uri); + + XML_Helper *xml_helper_; + + }; + + typedef Sequence_Handler < SubcomponentInstantiationDescription, + ::Deployment::SubcomponentInstantiationDescriptions, + ::Deployment::SubcomponentInstantiationDescription, + SID_Handler::handle_sub_comp_inst_descr > SID_Functor; + + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_PACKAGING_SID_HANDLER_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/test.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/test.cpp new file mode 100644 index 00000000000..c107fed4a77 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/test.cpp @@ -0,0 +1,113 @@ +// $Id$ + +#include <iostream> + +#include "Deployment.hpp" +#include "PCD_Handler.h" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "SID_Handler.h" +#include "ace/Get_Opt.h" +#include "Utils/XML_Helper.h" +#include "tao/ORB.h" +#include "Utils/Exceptions.h" + +static const char *input_file = "BasicSP.cdp"; + + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "i:"); + + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'i': + input_file = get_opts.opt_arg (); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-i <input file> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command-line + return 0; +} + +// Check to see if SRD was imported. +void check_srd (const Deployment::DeploymentPlan &); + +using namespace CIAO::Config_Handlers; + + +int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) +{ + try + { + + if (parse_args (argc, argv) != 0) + return 1; + + // Initialize an ORB so Any will work + CORBA::ORB_ptr orb = CORBA::ORB_init (argc, argv); + ACE_UNUSED_ARG (orb); + + + if (xercesc::DOMDocument *doc = XML_HELPER->create_dom (input_file)) + { + + ::Deployment::PackageConfiguration idl_pc; + { + // //Read in the XSC type structure from the DOMDocument + //PackageConfiguration pc = packageConfiguration (doc); + //std::cerr << "XML to XSC conversion succeeded. Converting to IDL...\n"; + + //Convert the XSC to an IDL datatype + Packaging::PCD_Handler::package_config (input_file, idl_pc); + std::cout << "Instance document import succeeded. Dumping contents to file\n"; + } + + // Clear SID_Handler's IDREF Table + Packaging::SID_Handler::IDREF.unbind_refs (); + + std::cerr << "Performing IDL->XSC transformation...\n"; + + PackageConfiguration out_pc (Packaging::PCD_Handler::package_config (idl_pc)); + + //Create a new DOMDocument for writing the XSC into XML + xercesc::DOMDocument* the_xsc (XML_HELPER->create_dom("Deployment:packageConfiguration", + "http://www.omg.org/Deployment")); + + //Serialize the XSC into a DOMDocument + packageConfiguration(out_pc, the_xsc); + + + //Write it to test.xml + XML_HELPER->write_DOM(the_xsc, "test.xml"); + + //Cleanliness is next to Godliness + delete doc; + } + + std::cout << "Test completed!\n"; + } + catch (CIAO::Config_Handlers::Plan_Error &excep) + { + std::cerr << "Plan Error exception caught: " << excep.reason_ << std::endl; + } + catch (CIAO::Config_Handlers::Config_Error &excep) + { + std::cerr << "Config Error " << excep.name_ << ": " << excep.error_ << std::endl; + } + + + return 0; +} + + diff --git a/modules/CIAO/tools/Config_Handlers/Property_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Property_Handler.cpp new file mode 100644 index 00000000000..0f81f8c6d82 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Property_Handler.cpp @@ -0,0 +1,56 @@ +//$Id$ + +#include "Property_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + + Property_Handler::Property_Handler (void) + { + } + + Property_Handler::~Property_Handler (void) + { + } + + void + Property_Handler::handle_property (const Property& desc, + Deployment::Property& toconfig) + { + CIAO_TRACE("Property_Handler::get_property"); + + try + { + toconfig.name = + CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ())); + + Any_Handler::extract_into_any (desc.value (), + toconfig.value); + } + catch (Config_Error &ex) + { + ex.name_ = desc.name (); + throw ex; + } + } + + Property + Property_Handler::get_property (const Deployment::Property& src) + { + CIAO_TRACE("Property_Handler::get_property - reverse"); + + ::XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR(src.name)); + Any value (Any_Handler::get_any (src.value)); + + Property prop (name,value); + + return prop; + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Property_Handler.h b/modules/CIAO/tools/Config_Handlers/Property_Handler.h new file mode 100644 index 00000000000..422aa1d4a44 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Property_Handler.h @@ -0,0 +1,70 @@ +//================================================ +/** + * @file Property_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_PROPERTY_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PROPERTY_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct Property; + class Properties; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class Property; + + /* + * @class Property_Handler + * + * @brief Handler class for <CCMComponentPortDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + + class Config_Handlers_Common_Export Property_Handler + { + public: + Property_Handler (void); + virtual ~Property_Handler (void); + + /// This method maps the values from the XSC object + /// <CIAO::Config_Handlers::Property> to the CORBA IDL type + /// <Deployment::Property>. + static void handle_property (const Property& desc, + ::Deployment::Property& toconfig); + static Property get_property (const ::Deployment::Property& src); + }; + + + typedef Sequence_Handler < Property, + ::Deployment::Properties, + ::Deployment::Property, + Property_Handler::handle_property > Property_Functor; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_PROPERTY_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/RDD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/RDD_Handler.cpp new file mode 100644 index 00000000000..de4c06368d1 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/RDD_Handler.cpp @@ -0,0 +1,55 @@ +// $Id$ + +#include "RDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Any_Handler.h" +#include "ciao/Logger/Log_Macros.h" +#include "Property_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + void + RDD_Handler::resource_deployment_descr ( + const ResourceDeploymentDescription &src, + ::Deployment::ResourceDeploymentDescription &dest) + { + CIAO_TRACE("RDD_Handler::resource_deployment_descr"); + + dest.requirementName = ACE_TEXT_ALWAYS_CHAR ( src.requirementName ().c_str ()); + + dest.resourceName= ACE_TEXT_ALWAYS_CHAR (src.resourceName ().c_str ()); + + std::for_each (src.begin_property (), + src.end_property (), + Property_Functor (dest.property)); + + } + + ResourceDeploymentDescription + RDD_Handler::resource_deployment_descr ( + const ::Deployment::ResourceDeploymentDescription &src) + { + CIAO_TRACE("RDD_Handler::resource_deployment_descr - reverse"); + + XMLSchema::string< ACE_TCHAR > reqname (ACE_TEXT_CHAR_TO_TCHAR (src.requirementName)); + XMLSchema::string< ACE_TCHAR > resname (ACE_TEXT_CHAR_TO_TCHAR (src.resourceName.in ())); + + ResourceDeploymentDescription rdd (reqname,resname); + + for (CORBA::ULong i = 0; + i != src.property.length (); + ++i) + { + //rdd.add_property (Property_Handler::get_property (src.property[i])); + } + + return rdd; + } + + + } + +} diff --git a/modules/CIAO/tools/Config_Handlers/RDD_Handler.h b/modules/CIAO/tools/Config_Handlers/RDD_Handler.h new file mode 100644 index 00000000000..e0d19c58ee2 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/RDD_Handler.h @@ -0,0 +1,63 @@ + +//============================================================== +/** +* @file RDD_Handler.h +* +* $Id$ +* +* @author Jules White <jules@dre.vanderbilt.edu> +*/ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_RDD_Handler_H +#define CIAO_CONFIG_HANDLERS_RDD_Handler_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + + +namespace Deployment +{ +struct ResourceDeploymentDescription; +} + + +namespace CIAO +{ + +namespace Config_Handlers +{ +class ResourceDeploymentDescription; + +/* +* @class RDD_Handler +* +* @brief Handler class for <ResourceDeploymentDescription> types. +* +* This class defines handler methods to map values from XSC +* ResourceDeploymentDescription objects, parsed from the +* descriptor files, to the corresponding CORBA IDL Any type. +* +*/ + +class Config_Handlers_Export RDD_Handler +{ +public: +static void resource_deployment_descr ( +const ResourceDeploymentDescription& desc, +::Deployment::ResourceDeploymentDescription& toconfig); +static ResourceDeploymentDescription +resource_deployment_descr ( +const ::Deployment::ResourceDeploymentDescription &src); + +}; +} +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_RDD_Handler_H */ diff --git a/modules/CIAO/tools/Config_Handlers/Req_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Req_Handler.cpp new file mode 100644 index 00000000000..3d0b4f47ea5 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Req_Handler.cpp @@ -0,0 +1,57 @@ +// $Id$ + +#include "Req_Handler.h" +#include "Property_Handler.h" +#include "DAnCE/Deployment/Deployment_BaseC.h" +#include "ciao/Logger/Log_Macros.h" +namespace CIAO +{ + namespace Config_Handlers + { + + Req_Handler::Req_Handler (void) + { + } + + Req_Handler::~Req_Handler (void) + { + } + + void + Req_Handler::handle_requirement (const Requirement& desc, + Deployment::Requirement& toconfig) + { + CIAO_TRACE("Req_Handler::get_Requirement"); + + //Map the basic string types to their Deployment::Req + //counterparts. + toconfig.name = ACE_TEXT_ALWAYS_CHAR ( desc.name ().c_str ()); + toconfig.resourceType = ACE_TEXT_ALWAYS_CHAR ( desc.resourceType ().c_str ()); + + toconfig.property.length (desc.count_property ()); + std::for_each (desc.begin_property (), + desc.end_property (), + Property_Functor (toconfig.property)); + } + + Requirement + Req_Handler::get_requirement (const Deployment::Requirement& src) + { + CIAO_TRACE("Req_Handler::get_requirement - reverse"); + + //Get the values for name and res + XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR (src.name)); + XMLSchema::string< ACE_TCHAR > res (ACE_TEXT_CHAR_TO_TCHAR (src.resourceType)); + + //Instantiate the Requirement + Requirement req (name,res); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + { + //req.add_property (Property_Handler::get_property (src.property[i])); + } + + return req; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/Req_Handler.h b/modules/CIAO/tools/Config_Handlers/Req_Handler.h new file mode 100644 index 00000000000..3955b85a55f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Req_Handler.h @@ -0,0 +1,71 @@ +//============================================================== +/** + * @file Req_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_HANDLERS_REQ_HANDLER_H +#define CIAO_CONFIG_HANDLERS_REQ_HANDLER_H +#include /**/ "ace/pre.h" + +#include "Basic_Deployment_Data.hpp" +#include "Config_Handlers_Common_Export.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct Requirement; + class Requirements; +} + +namespace CIAO +{ + + namespace Config_Handlers + { + /* + * @class REQ_Handler + * + * @brief Handler class for <Requirement> types. + * + * This class defines handler methods to map values from + * XSC Requirement objects, parsed from + * the descriptor files, to the corresponding CORBA IDL type. + * + */ + + class Config_Handlers_Common_Export Req_Handler + { + public: + + Req_Handler (void); + virtual ~Req_Handler (void); + + ///This method takes a <Deployment::Requirement> + ///and maps the values from the passed in XSC + ///Requirement to its members. + static void handle_requirement (const Requirement& desc, + Deployment::Requirement& toconfig); + static Requirement + get_requirement (const Deployment::Requirement& src); + }; + + typedef Sequence_Handler < Requirement, + ::Deployment::Requirements, + ::Deployment::Requirement, + Req_Handler::handle_requirement > Requirement_Functor; + + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_REQ_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.cpp b/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.cpp new file mode 100644 index 00000000000..d0bd4e92904 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.cpp @@ -0,0 +1,173 @@ +// $Id$ +#include "STD_CID_Handler.h" +#include "STD_CPD_Handler.h" +#include "STD_IAD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Utils/XML_Helper.h" +#include "Deployment.hpp" +#include "Property_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + IDREF_Base<CORBA::ULong> STD_CID_Handler::IDREF; + + bool + STD_CID_Handler::component_impl_descr ( + const ComponentImplementationDescription &desc, + ::Deployment::ComponentImplementationDescription &toconfig) + { + toconfig.label = + desc.label ().c_str (); + + toconfig.UUID = + desc.UUID ().c_str (); + + + if (desc.assemblyImpl_p ()) + { + Deployment::ComponentAssemblyDescription idl_cad; + ComponentAssemblyDescription cad = + desc.assemblyImpl (); + + // @@: handle <assemblyImpl> + for (ComponentAssemblyDescription::instance_const_iterator iter = + cad.begin_instance (); + iter != cad.end_instance (); + iter++) + { + CORBA::ULong len = + idl_cad.instance.length (); + idl_cad.instance.length (len + 1); + idl_cad.instance [len].name = + (*iter).name ().c_str (); + + // Bind the instance id with the index + if ((*iter).id_p ()) + { + ACE_CString cstr ((*iter).id ().c_str ()); + + STD_CID_Handler::IDREF.bind_ref (cstr,len); + } + + if (!this->xml_helper_->is_initialized ()) + return false; + + // parse the .cpd (ComponentPackageDescription) file + // that <package> links to + xercesc::DOMDocument* dom = + this->xml_helper_->create_dom (((*iter).package ()).href ().c_str ()); + + if (!dom) + return false; + + ComponentPackageDescription cpd = + componentPackageDescription (dom); + + Deployment::ComponentPackageDescription idl_cpd; + + STD_CPD_Handler cpd_handler (this->xml_helper_); + + cpd_handler.component_package_descr (cpd, + idl_cpd); + + idl_cad.instance [len].package.length (1); + idl_cad.instance [len].package [0] = idl_cpd; + } + + // @@: handle <connection> + for (ComponentAssemblyDescription::connection_const_iterator conn_iter = + cad.begin_connection (); + conn_iter != cad.end_connection (); + conn_iter++) + { + CORBA::ULong conn_len = + idl_cad.connection.length (); + + idl_cad.connection.length (conn_len + 1); + idl_cad.connection [conn_len].name = + (*conn_iter).name ().c_str (); + + + for (AssemblyConnectionDescription::internalEndpoint_const_iterator ep_iter = + (*conn_iter).begin_internalEndpoint (); + ep_iter != (*conn_iter).end_internalEndpoint (); + ep_iter++) + { + CORBA::ULong endp_len = + idl_cad.connection [conn_len].internalEndpoint.length (); + idl_cad.connection [conn_len].internalEndpoint.length (endp_len + 1); + idl_cad.connection [conn_len].internalEndpoint [endp_len].portName = + (*ep_iter).portName ().c_str (); + + CORBA::ULong tmp = 0; + STD_CID_Handler::IDREF.find_ref (ACE_CString ((((*ep_iter).instance ()).id ()).c_str ()), + tmp); + CORBA::ULong ref = tmp; + idl_cad.connection[conn_len].internalEndpoint [endp_len].instanceRef = ref; + } + } + + toconfig.assemblyImpl.length (1); + toconfig.assemblyImpl [0] = idl_cad; + } + + // handle <monolithicImpl> + if (desc.monolithicImpl_p ()) + { + Deployment::MonolithicImplementationDescription idl_mid; + MonolithicImplementationDescription mid = + desc.monolithicImpl (); + + for (MonolithicImplementationDescription::primaryArtifact_const_iterator iter = + mid.begin_primaryArtifact (); + iter != mid.end_primaryArtifact (); + iter++) + { + CORBA::ULong len = + idl_mid.primaryArtifact.length (); + idl_mid.primaryArtifact.length (len + 1); + idl_mid.primaryArtifact [len].name = (*iter).name ().c_str (); + + if (!this->xml_helper_->is_initialized ()) + return false; + + // parse the .iad (ImplementationArtifactDescription) file + // that the <referencedArtifact> links to + xercesc::DOMDocument* dom = + this->xml_helper_->create_dom (((*iter).referencedArtifact ()).href ().c_str ()); // here location indicates .iad file + + if (!dom) + return false; + + ImplementationArtifactDescription iad = + implementationArtifactDescription (dom); + + Deployment::ImplementationArtifactDescription idl_iad; + + STD_IAD_Handler::impl_artifact_descr (iad, + idl_iad); + + idl_mid.primaryArtifact [len].referencedArtifact = idl_iad; + + } + toconfig.monolithicImpl.length (1); + toconfig.monolithicImpl [0] = idl_mid; + } + + // handle <configProperty> + if (desc.configProperty_p ()) + { + Property p = desc.configProperty (); + Deployment::Property idl_p; + Property_Handler::get_property (p, idl_p); + toconfig.configProperty.length (1); + toconfig.configProperty [0] = idl_p; + } + + return true; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.h b/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.h new file mode 100644 index 00000000000..c875d05edba --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_CID_Handler.h @@ -0,0 +1,75 @@ +//================================================ +/** + * @file STD_CID_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_CID_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_CID_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "IDREF_Base.h" +#include "Config_Handlers_Export.h" +#include "DAnCE/Deployment/DeploymentC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentImplementationDescription; + + /* + * @class STD_CID_Handler + * + * @brief Handler class for <CCMComponentImplementationDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Config_Handlers_Export STD_CID_Handler + { + + public: + + STD_CID_Handler (void) + { + } + + /// Maps the values from the XSC object + /// <ComponentImplementationDescription> to the CORBA IDL type + /// <Deployment::ComponentImplementationDescription>. + bool component_impl_descr ( + const ComponentImplementationDescription &desc, + ::Deployment::ComponentImplementationDescription &toconfig); + + static IDREF_Base<CORBA::ULong> IDREF; + +//@@Note: This part has yet to be added in the future +// ComponentImplementationDescription +// component_port_description ( +// const Deployment::ComponentImplementationDescription& src); + + private: + // disable the default constructor + STD_CID_Handler () + :xml_helper_ (0) + { + } + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_CID_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp new file mode 100644 index 00000000000..c9fa40f0258 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp @@ -0,0 +1,59 @@ +// $Id$ +#include "STD_CPD_Handler.h" +#include "STD_CID_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Deployment.hpp" +#include "Utils/XML_Typedefs.h" + +namespace CIAO +{ + namespace Config_Handlers + { + bool + STD_CPD_Handler::component_package_descr ( + const ComponentPackageDescription &desc, + ::Deployment::ComponentPackageDescription &toconfig) + { + toconfig.label = + desc.label ().c_str (); + + toconfig.UUID = + desc.UUID ().c_str (); + + PackagedComponentImplementation pci = desc.implementation (); + Deployment::PackagedComponentImplementation idl_pci; + idl_pci.name = + pci.name ().c_str (); + + if (XML_Helper::XML_HELPER.is_initialized ()) + return false; + + // parse the .cid (ComponentImplementationDescription) file + // that <referencedImplementation> links to + xercesc::DOMDocument* dom = + XML_Helper::XML_HELPER.create_dom + ((pci.referencedImplementation ()).href ().c_str ()); // here location indicates .pcd file + + if (!dom) + return false; + + ComponentImplementationDescription cid = + componentImplementationDescription (dom); + + Deployment::ComponentImplementationDescription idl_cid; + + STD_CID_Handler cid_handler; + + cid_handler.component_impl_descr (cid, + idl_cid); + + idl_pci.referencedImplementation = idl_cid; + + toconfig.implementation.length (1); + toconfig.implementation [0] = idl_pci; + + return true; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.h b/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.h new file mode 100644 index 00000000000..654fb0155ca --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_CPD_Handler.h @@ -0,0 +1,78 @@ +//================================================ +/** + * @file STD_CPD_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_CPD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_CPD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Utils/XML_Helper.h" +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ComponentPackageDescription; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentPackageDescription; + + /* + * @class STD_CPD_Handler + * + * @brief Handler class for <CCMComponentPackageDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Config_Handlers_Export STD_CPD_Handler + { + + public: + + STD_CPD_Handler (XML_Helper *xml_helper) + :xml_helper_ (xml_helper) + { + } + + /// Maps the values from the XSC object + /// <ComponentPackageDescription> to the CORBA IDL type + /// <Deployment::ComponentPackageDescription>. + bool component_package_descr( + const ComponentPackageDescription &desc, + ::Deployment::ComponentPackageDescription &toconfig); + + //@@Note: This part has yet to be added in the future + // ComponentPortDescription + // component_package_descr ( + // const Deployment::ComponentPortDescription& src); + private: + // disable the default constructor + STD_CPD_Handler () + :xml_helper_ (0) + { + } + + XML_Helper *xml_helper_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CPD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.cpp new file mode 100644 index 00000000000..020396582d3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.cpp @@ -0,0 +1,46 @@ +// $Id$ +#include "STD_IAD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "ciao/Packaging_DataC.h" +#include "Property_Handler.h" + +#include "iad.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool + STD_IAD_Handler::impl_artifact_descr ( + const ImplementationArtifactDescription &desc, + ::Deployment::ImplementationArtifactDescription &toconfig) + { + toconfig.label = + desc.label ().c_str (); + + toconfig.UUID = + desc.UUID ().c_str (); + + for (ImplementationArtifactDescription::location_const_iterator iter = + desc.begin_location (); + iter != desc.end_location (); + iter++) + { + CORBA::ULong len = + toconfig.location.length (); + toconfig.location.length (len + 1); + toconfig.location [len] = (*iter).c_str (); + } + + if (desc.execParameter_p ()) + { + Property p = desc.execParameter (); + Deployment::Property idl_p; + Property_Handler::get_property (p, idl_p); + toconfig.execParameter.length (1); + toconfig.execParameter [0] = idl_p; + } + return true; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.h b/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.h new file mode 100644 index 00000000000..3523526f5be --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_IAD_Handler.h @@ -0,0 +1,64 @@ +//================================================ +/** + * @file STD_IAD_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct ImplementationArtifactDescription; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class ImplementationArtifactDescription; + + /* + * @class STD_IAD_Handler + * + * @brief Handler class for <CCMImplementationArtifactDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Config_Handlers_Export STD_IAD_Handler + { + + public: + /// Maps the values from the XSC object + /// <ImplementationArtifactDescription> to the CORBA IDL type + /// <Deployment::ImplementationArtifactDescription>. + static bool + impl_artifact_descr ( + const ImplementationArtifactDescription &desc, + ::Deployment::ImplementationArtifactDescription &toconfig); + +//@@Note: The reverse part has yet to be handed in the future +// ImplementationArtifactDescription +// impl_artifact_descr ( +// const Deployment::ComponentPortDescription& src); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.cpp b/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.cpp new file mode 100644 index 00000000000..5a65826f340 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.cpp @@ -0,0 +1,52 @@ +// $Id$ +#include "STD_PCD_Handler.h" +#include "STD_CPD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "ciao/Packaging_DataC.h" +#include "Deployment.hpp" + + +namespace CIAO +{ + namespace Config_Handlers + { + + bool + STD_PCD_Handler::package_config ( + const PackageConfiguration &desc, + ::Deployment::PackageConfiguration &toconfig) + { + toconfig.label = + desc.label ().c_str (); + + toconfig.UUID = + desc.UUID ().c_str (); + + if (!XML_Helper::XML_HELPER.is_initialized ()) + return false; + + // parse the .cpd (ComponentPackageDescription) file + // that <basePackage> links to + xercesc::DOMDocument* dom = + XML_Helper::XML_HELPER.create_dom ((desc.basePackage()).href ().c_str ()); + + if (!dom) + return false; + + ComponentPackageDescription cpc = + componentPackageDescription (dom); + + Deployment::ComponentPackageDescription idl_cpc; + + STD_CPD_Handler cpd_handler; + + cpd_handler.component_package_descr (cpc, + idl_cpc); + + toconfig.basePackage.length (1); + toconfig.basePackage [0] = idl_cpc; + + return true; + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.h b/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.h new file mode 100644 index 00000000000..8c65f6eb6f3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_PCD_Handler.h @@ -0,0 +1,74 @@ +//================================================ +/** + * @file STD_PCD_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct PackageConfiguration; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class PackageConfiguration; + + /* + * @class STD_PCD_Handler + * + * @brief Handler class for <CCMPackageConfiguration> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class Config_Handlers_Export STD_PCD_Handler + { + + public: + STD_PCD_Handler () + { + } + + /// Maps the values from the XSC object + /// <PackageConfiguration> to the CORBA IDL type + /// <Deployment::PackageConfiguration>. + bool package_config ( + const PackageConfiguration &desc, + ::Deployment::PackageConfiguration &toconfig); + +//@@Note: This part has yet to be added in the future +// PackageConfiguration +// package_config ( +// const Deployment::ComponentPortDescription& src); + + private: + // Disable the default constructor + STD_PCD_Handler () + { + } + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.cpp b/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.cpp new file mode 100644 index 00000000000..4a865f19603 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.cpp @@ -0,0 +1,71 @@ +// $Id$ + +#include "STD_PC_Intf.h" +#include "Utils/XML_Typedefs.h" +#include "Deployment.hpp" +#include "STD_PCD_Handler.h" +#include "ciao/Packaging_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + STD_PC_Intf::STD_PC_Intf (const char *file) + { + if (!this->prepare_PC (file)) + throw; + } + + bool + STD_PC_Intf::prepare_PC (const char *file) + { + CIAO_TRACE("STD_PC_Intf::prepare_PC"); + + + // parse the .pcd (PackageConfigurationDescription) file + xercesc::DOMDocument *dom = + XML_Helper::XML_HELPER.create_dom (file); + + if (!dom) + return false; + + + PackageConfiguration pc = + packageConfiguration (dom); + + + Deployment::PackageConfiguration idl_pc; + + + STD_PCD_Handler pcd_handler; + + pcd_handler.package_config (pc, + idl_pc); + + + Deployment::PackageConfiguration *p_idl_pc = + new Deployment::PackageConfiguration (idl_pc); + + // let ACE_Auto_Ptr take over + this->idl_pc_.reset (p_idl_pc); + + if (this->idl_pc_.get ()) + return true; + + return false; + } + + ::Deployment::PackageConfiguration const * + STD_PC_Intf::get_PC (void) const + { + return this->idl_pc_.get (); + } + + ::Deployment::PackageConfiguration * + STD_PC_Intf::get_PC (void) + { + return this->idl_pc_.release (); + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.h b/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.h new file mode 100644 index 00000000000..2e07e1922eb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/STD_PC_Intf.h @@ -0,0 +1,62 @@ +//============================================================== +/** + * @file STD_PC_Intf.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_STD_PC_INTF_H +#define CIAO_CONFIG_STD_PC_INTF_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/Auto_Ptr.h" + + +namespace Deployment +{ + struct PackageConfiguration ; +} + +namespace CIAO +{ + namespace Config_Handlers + { + /* + * @class STD_PC_Intf + * + * @brief Wrapper class for PackageConfiguration extraction + * + * This class defines wrapper functions for extracting + * PackageConfiguration IDL structures from XSC structures. + * It serves as the public interface used by application + * developers. + * + */ + class Config_Handlers_Export STD_PC_Intf + { + public: + STD_PC_Intf (const char *file); + + ::Deployment::PackageConfiguration const *get_PC (void) const; + ::Deployment::PackageConfiguration *get_PC (void); + + protected: + bool prepare_PC (const char *file); + + private: + ACE_Auto_Ptr< ::Deployment::PackageConfiguration> idl_pc_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_STD_PC_INTF_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp b/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp new file mode 100644 index 00000000000..7cac0b919ea --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp @@ -0,0 +1,126 @@ +//$Id$ + +#include "SatisfierProperty_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" +#include "Utils/Exceptions.h" +namespace CIAO +{ + namespace Config_Handlers + { + + SatisfierProperty_Handler::SatisfierProperty_Handler (void) + { + } + + SatisfierProperty_Handler::~SatisfierProperty_Handler (void) + { + } + + void + SatisfierProperty_Handler::handle_sat_property ( + const SatisfierProperty& desc, + Deployment::SatisfierProperty& toconfig) + { + CIAO_TRACE("SatisfierProperty_Handler::get_sat_property"); + + toconfig.name = ACE_TEXT_ALWAYS_CHAR (desc.name ().c_str ()); + + switch (desc.kind ().integral ()) + { + case SatisfierPropertyKind::Quantity_l: + toconfig.kind = Deployment::Quantity; + break; + + case SatisfierPropertyKind::Capacity_l: + toconfig.kind = Deployment::Capacity; + break; + + case SatisfierPropertyKind::Minimum_l: + toconfig.kind = Deployment::Minimum; + break; + + case SatisfierPropertyKind::Maximum_l: + toconfig.kind = Deployment::Maximum; + break; + + // case SatisfierPropertyKind::Attribute_l: + //toconfig.kind = Deployment::_Attribute; + //break; + + case SatisfierPropertyKind::Selection_l: + toconfig.kind = Deployment::Selection; + break; + + default: + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unknown SatisfierPropertyKind\n"))); + throw Config_Error (desc.name (), ACE_TEXT ("Unknown SatisfierPropertyKind")); + + } + + toconfig.dynamic = desc.dynamic (); + + try + { + Any_Handler::extract_into_any (desc.value (), + toconfig.value); + } + catch (Config_Error &ex) + { + ex.name_ = desc.name (); + throw ex; + } + } + + SatisfierProperty + SatisfierProperty_Handler::get_sat_property ( + const Deployment::SatisfierProperty& src) + { + CIAO_TRACE("SatisfierProperty_Handler::get_sat_property - reverse"); + + ::XMLSchema::string< ACE_TCHAR > name (ACE_TEXT_CHAR_TO_TCHAR ((src.name))); + SatisfierPropertyKind::Value kind; + + const SatisfierPropertyKind *spk = 0; + + switch (src.kind) + { + case Deployment::Quantity: + spk = &SatisfierPropertyKind::Quantity; + break; + + case Deployment::Capacity: + spk = &SatisfierPropertyKind::Capacity; + break; + + case Deployment::Minimum: + spk = &SatisfierPropertyKind::Minimum; + break; + + case Deployment::Maximum: + spk = &SatisfierPropertyKind::Maximum; + break; + + // case Deployment::_Attribute: + //kind = SatisfierPropertyKind::Attribute_l; + //break; + + case Deployment::Selection: + kind = SatisfierPropertyKind::Selection_l; + break; + + default: + throw Plan_Error (ACE_TEXT ("Invalid SatisfierPropertyKind")); + } + + bool dynamic = src.dynamic; + + Any value (Any_Handler::get_any (src.value)); + + return SatisfierProperty (name, *spk, dynamic, value); + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.h b/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.h new file mode 100644 index 00000000000..e166b341d9f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.h @@ -0,0 +1,69 @@ +//================================================ +/** + * @file SatisfierProperty_Handler.h + * + * $Id$ + * + * @author Jules White <jules@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_SATIS_PROPERTY_HANDLER_H +#define CIAO_CONFIG_HANDLERS_SATIS_PROPERTY_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Common_Export.h" +#include "Utils/Functors.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace Deployment +{ + struct SatisfierProperty; + class SatisfierProperties; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class SatisfierProperty; + + /* + * @class SatisfierProperty_Handler + * + * @brief Handler class for <CCMComponentPortDescription> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + + class Config_Handlers_Common_Export SatisfierProperty_Handler + { + public: + SatisfierProperty_Handler (void); + virtual ~SatisfierProperty_Handler (void); + + /// This method maps the values from the XSC object + /// <CIAO::Config_Handlers::SatisfierProperty> to the CORBA IDL type + /// <Deployment::SatisfierProperty>. + static void handle_sat_property (const SatisfierProperty& desc, + ::Deployment::SatisfierProperty& toconfig); + static SatisfierProperty get_sat_property (const ::Deployment::SatisfierProperty& src); + }; + + typedef Sequence_Handler < SatisfierProperty, + ::Deployment::SatisfierProperties, + ::Deployment::SatisfierProperty, + SatisfierProperty_Handler::handle_sat_property> SatisfierProperty_Functor; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_SATIS_PROPERTY_HANDLER_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/Utils/Exceptions.h b/modules/CIAO/tools/Config_Handlers/Utils/Exceptions.h new file mode 100644 index 00000000000..63b3563c879 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Utils/Exceptions.h @@ -0,0 +1,39 @@ +// $Id$ +/** + * @file Exceptions.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * + * Defines exceptions that may be thrown during the XSC<=>IDL translation process. + */ +#include <string> + +namespace CIAO +{ + namespace Config_Handlers + { + struct Parse_Error + { + Parse_Error (const std::basic_string<ACE_TCHAR> &reason) + : reason_ (reason) + { + } + + std::basic_string<ACE_TCHAR> reason_; + }; + + struct Plan_Error + { + Plan_Error (const std::basic_string<ACE_TCHAR> &reason) + : reason_ (reason) + { + } + + std::basic_string<ACE_TCHAR> reason_; + }; + + } +} + + + + diff --git a/modules/CIAO/tools/Config_Handlers/Utils/Functors.h b/modules/CIAO/tools/Config_Handlers/Utils/Functors.h new file mode 100644 index 00000000000..41121241572 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Utils/Functors.h @@ -0,0 +1,87 @@ +#ifndef CONFIG_HANDLERS_FUNCTORS_H +#define CONFIG_HANDLERS_FUNCTORS_H + +/** + * @file Functors.h + * @author William Otte <wotte@dre.vanderbilt.edu> + * $Id$ + * Functors useful in the config handlers + */ +#include <iterator> + +#include "tao/Basic_Types.h" // For CORBA::ULong +#include "tao/StringSeqC.h" + +#include "XMLSchema/Types.hpp" +namespace CIAO +{ + namespace Config_Handlers + { + template <typename Source, + typename Dest, + typename Dest_Type, +#if defined (__BORLANDC__) // && (__BORLANDC__ == 0x564) + void (Func)(const Source &, Dest_Type &)> +#else + void (&Func)(const Source &, Dest_Type &)> +#endif + struct Sequence_Handler + { + Sequence_Handler (Dest &dest, CORBA::ULong pos = 0) + : dest_ (dest), + pos_ (pos) + { + } + + void operator() (const ACE_Refcounted_Auto_Ptr <Source, ACE_Null_Mutex> &src) + { + Func (*src, dest_[pos_++]); + } + + private: + Dest &dest_; + CORBA::ULong pos_; + }; + + /* + * This is a workaround for a GCC bug that for some reason causes + * functions that appear ONLY in a Sequence_Handler typedef to not + * be present in the compiled object file. + * This bug was first observed in GCC 4.02. + * + * W: The function we want to be defined + * X: First argument to the function + * Y: Second argument to the function + */ +#define SEQ_HAND_GCC_BUG_WORKAROUND(W, X, Y) \ + while(0) { \ + W (*X, Y[0]); \ + } + + + template <typename Dest, typename Dest_Type> + struct String_Seq_Handler + { + String_Seq_Handler (Dest &dest, CORBA::ULong pos = 0) + : dest_ (dest), + pos_ (pos) + { + } + + void operator() (const ACE_Refcounted_Auto_Ptr < ::XMLSchema::string<ACE_TCHAR>, ACE_Null_Mutex> &src) + { + dest_[pos_++] = ACE_TEXT_ALWAYS_CHAR (src->c_str ()); + } + + private: + Dest &dest_; + CORBA::ULong pos_; + }; + + typedef String_Seq_Handler < ::CORBA::StringSeq, + ::CORBA::String_var > String_Seq_Functor; + + } +} + +#endif /* CONFIG_HANDLERS_FUNCTORS_H */ diff --git a/modules/CIAO/tools/Config_Handlers/XMI.cpp b/modules/CIAO/tools/Config_Handlers/XMI.cpp new file mode 100644 index 00000000000..66c0ee02f0e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMI.cpp @@ -0,0 +1,888 @@ +/* $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 "XMI.hpp" + +namespace XMI +{ + // Extension + // + + Extension:: + Extension () + : + regulator__ () + { + } + + Extension:: + Extension (Extension const& s) + : XSCRT::Type (), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + uuid_ (s.uuid_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.uuid_) : 0), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + idref_ (s.idref_.get () ? new ::XMLSchema::IDREF< ACE_TCHAR > (*s.idref_) : 0), + version_ (s.version_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.version_) : 0), + extender_ (s.extender_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.extender_) : 0), + extenderID_ (s.extenderID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.extenderID_) : 0), + regulator__ () + { + if (id_.get ()) id_->container (this); + if (label_.get ()) label_->container (this); + if (uuid_.get ()) uuid_->container (this); + if (href_.get ()) href_->container (this); + if (idref_.get ()) idref_->container (this); + if (version_.get ()) version_->container (this); + if (extender_.get ()) extender_->container (this); + if (extenderID_.get ()) extenderID_->container (this); + } + + Extension& Extension:: + operator= (Extension const& s) + { + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + if (s.label_.get ()) label (*(s.label_)); + else label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.uuid_.get ()) uuid (*(s.uuid_)); + else uuid_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.idref_.get ()) idref (*(s.idref_)); + else idref_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (0); + + if (s.version_.get ()) version (*(s.version_)); + else version_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.extender_.get ()) extender (*(s.extender_)); + else extender_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.extenderID_.get ()) extenderID (*(s.extenderID_)); + else extenderID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // Extension + // + bool Extension:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& Extension:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& Extension:: + id () + { + return *id_; + } + + void Extension:: + 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); + } + } + + // Extension + // + bool Extension:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + label () const + { + return *label_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + label () + { + return *label_; + } + + void Extension:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // Extension + // + bool Extension:: + uuid_p () const + { + return uuid_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + uuid () const + { + return *uuid_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + uuid () + { + return *uuid_; + } + + void Extension:: + uuid (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (uuid_.get ()) + { + *uuid_ = e; + } + + else + { + uuid_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + uuid_->container (this); + } + } + + // Extension + // + bool Extension:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + href () + { + return *href_; + } + + void Extension:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + + // Extension + // + bool Extension:: + idref_p () const + { + return idref_.get () != 0; + } + + ::XMLSchema::IDREF< ACE_TCHAR > const& Extension:: + idref () const + { + return *idref_; + } + + ::XMLSchema::IDREF< ACE_TCHAR >& Extension:: + idref () + { + return *idref_; + } + + ::XSCRT::Type* Extension:: + idref_ptr () + { + std::basic_string<ACE_TCHAR> temp (idref().id()); + return this->get_idref(temp.c_str()); + } + + + void Extension:: + idref (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + if (idref_.get ()) + { + *idref_ = e; + } + + else + { + idref_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + idref_->container (this); + } + } + + // Extension + // + bool Extension:: + version_p () const + { + return version_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + version () const + { + return *version_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + version () + { + return *version_; + } + + void Extension:: + version (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (version_.get ()) + { + *version_ = e; + } + + else + { + version_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + version_->container (this); + } + } + + // Extension + // + bool Extension:: + extender_p () const + { + return extender_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + extender () const + { + return *extender_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + extender () + { + return *extender_; + } + + void Extension:: + extender (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (extender_.get ()) + { + *extender_ = e; + } + + else + { + extender_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + extender_->container (this); + } + } + + // Extension + // + bool Extension:: + extenderID_p () const + { + return extenderID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Extension:: + extenderID () const + { + return *extenderID_; + } + + ::XMLSchema::string< ACE_TCHAR >& Extension:: + extenderID () + { + return *extenderID_; + } + + void Extension:: + extenderID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (extenderID_.get ()) + { + *extenderID_ = e; + } + + else + { + extenderID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + extenderID_->container (this); + } + } +} + +namespace XMI +{ + // Extension + // + + Extension:: + Extension (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + 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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else if (n == ACE_TEXT ("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + label (t); + } + + else if (n == ACE_TEXT ("uuid")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + uuid (t); + } + + else if (n == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (t); + } + + else if (n == ACE_TEXT ("idref")) + { + ::XMLSchema::IDREF< ACE_TCHAR > t (a); + idref (t); + std::basic_string<ACE_TCHAR> temp ((*idref_).id().c_str()); + + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_idref(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else if (n == ACE_TEXT ("version")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + version (t); + } + + else if (n == ACE_TEXT ("extender")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + extender (t); + } + + else if (n == ACE_TEXT ("extenderID")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + extenderID (t); + } + + else + { + } + } + } +} + +namespace XMI +{ + namespace reader + { + ::XMI::Extension + extension (xercesc::DOMDocument const* d) + { + //Initiate our Singleton as an ACE_TSS object (ensures thread + //specific storage + ID_Map::TSS_ID_Map* TSS_ID_Map (ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance()); + + + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == ACE_TEXT("extension")) + { + ::XMI::Extension r (e); + + (*TSS_ID_Map)->resolve_idref(); + + return r; + } + + else + { + throw 1; + } + } + } +} + +#include "XMLSchema/TypeInfo.hpp" + +namespace XMI +{ + namespace + { + ::XMLSchema::TypeInfoInitializer < ACE_TCHAR > XMLSchemaTypeInfoInitializer_ (::XSCRT::extended_type_info_map ()); + + struct ExtensionTypeInfoInitializer + { + ExtensionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::XMI::Extension)); + ::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)); + } + }; + + ExtensionTypeInfoInitializer ExtensionTypeInfoInitializer_; + } +} + +namespace XMI +{ + namespace Traversal + { + // Extension + // + // + + void Extension:: + traverse (Type& o) + { + pre (o); + if (o.id_p ()) id (o); + else id_none (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.uuid_p ()) uuid (o); + else uuid_none (o); + if (o.href_p ()) href (o); + else href_none (o); + if (o.idref_p ()) idref (o); + else idref_none (o); + if (o.version_p ()) version (o); + else version_none (o); + if (o.extender_p ()) extender (o); + else extender_none (o); + if (o.extenderID_p ()) extenderID (o); + else extenderID_none (o); + post (o); + } + + void Extension:: + traverse (Type const& o) + { + pre (o); + if (o.id_p ()) id (o); + else id_none (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.uuid_p ()) uuid (o); + else uuid_none (o); + if (o.href_p ()) href (o); + else href_none (o); + if (o.idref_p ()) idref (o); + else idref_none (o); + if (o.version_p ()) version (o); + else version_none (o); + if (o.extender_p ()) extender (o); + else extender_none (o); + if (o.extenderID_p ()) extenderID (o); + else extenderID_none (o); + post (o); + } + + void Extension:: + pre (Type&) + { + } + + void Extension:: + pre (Type const&) + { + } + + void Extension:: + id (Type& o) + { + dispatch (o.id ()); + } + + void Extension:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void Extension:: + id_none (Type&) + { + } + + void Extension:: + id_none (Type const&) + { + } + + void Extension:: + label (Type& o) + { + dispatch (o.label ()); + } + + void Extension:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void Extension:: + label_none (Type&) + { + } + + void Extension:: + label_none (Type const&) + { + } + + void Extension:: + uuid (Type& o) + { + dispatch (o.uuid ()); + } + + void Extension:: + uuid (Type const& o) + { + dispatch (o.uuid ()); + } + + void Extension:: + uuid_none (Type&) + { + } + + void Extension:: + uuid_none (Type const&) + { + } + + void Extension:: + href (Type& o) + { + dispatch (o.href ()); + } + + void Extension:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void Extension:: + href_none (Type&) + { + } + + void Extension:: + href_none (Type const&) + { + } + + void Extension:: + idref (Type& o) + { + dispatch (o.idref ()); + } + + void Extension:: + idref (Type const& o) + { + dispatch (o.idref ()); + } + + void Extension:: + idref_none (Type&) + { + } + + void Extension:: + idref_none (Type const&) + { + } + + void Extension:: + version (Type& o) + { + dispatch (o.version ()); + } + + void Extension:: + version (Type const& o) + { + dispatch (o.version ()); + } + + void Extension:: + version_none (Type&) + { + } + + void Extension:: + version_none (Type const&) + { + } + + void Extension:: + extender (Type& o) + { + dispatch (o.extender ()); + } + + void Extension:: + extender (Type const& o) + { + dispatch (o.extender ()); + } + + void Extension:: + extender_none (Type&) + { + } + + void Extension:: + extender_none (Type const&) + { + } + + void Extension:: + extenderID (Type& o) + { + dispatch (o.extenderID ()); + } + + void Extension:: + extenderID (Type const& o) + { + dispatch (o.extenderID ()); + } + + void Extension:: + extenderID_none (Type&) + { + } + + void Extension:: + extenderID_none (Type const&) + { + } + + void Extension:: + post (Type&) + { + } + + void Extension:: + post (Type const&) + { + } + } +} + +namespace XMI +{ + namespace Writer + { + // Extension + // + // + + Extension:: + Extension (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Extension:: + Extension () + { + } + + void Extension:: + traverse (Type const& o) + { + Traversal::Extension::traverse (o); + } + + void Extension:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("id"), ACE_TEXT ("http://www.omg.org/XMI"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::id (o); + attr_ (0); + } + + void Extension:: + label (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("label"), ACE_TEXT ("http://www.omg.org/XMI"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::label (o); + attr_ (0); + } + + void Extension:: + uuid (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("uuid"), ACE_TEXT ("http://www.omg.org/XMI"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::uuid (o); + attr_ (0); + } + + void Extension:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::href (o); + attr_ (0); + } + + void Extension:: + idref (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("idref"), ACE_TEXT ("http://www.omg.org/XMI"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::idref (o); + attr_ (0); + } + + void Extension:: + version (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("version"), ACE_TEXT ("http://www.omg.org/XMI"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::version (o); + attr_ (0); + } + + void Extension:: + extender (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("extender"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::extender (o); + attr_ (0); + } + + void Extension:: + extenderID (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("extenderID"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::Extension::extenderID (o); + attr_ (0); + } + } +} + +namespace XMI +{ + namespace writer + { + void + extension (::XMI::Extension const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != ACE_TEXT ("extension")) + { + throw 1; + } + + struct W : virtual ::XMI::Writer::Extension, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::XMLSchema::Writer::IDREF< ACE_TCHAR >, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/XMI.hpp b/modules/CIAO/tools/Config_Handlers/XMI.hpp new file mode 100644 index 00000000000..143691b8d4a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMI.hpp @@ -0,0 +1,397 @@ +/* $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 + +#ifndef XMI_HPP +#define XMI_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace XMI +{ + class Extension; +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +namespace XMI +{ + class XSC_XML_Handlers_Export Extension : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Extension, ACE_Null_Mutex > _ptr; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + ::XMLSchema::string< ACE_TCHAR >& label (); + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // uuid + // + public: + bool uuid_p () const; + ::XMLSchema::string< ACE_TCHAR > const& uuid () const; + ::XMLSchema::string< ACE_TCHAR >& uuid (); + void uuid (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > uuid_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + // idref + // + public: + bool idref_p () const; + ::XMLSchema::IDREF< ACE_TCHAR > const& idref () const; + ::XMLSchema::IDREF< ACE_TCHAR >& idref (); + void idref (::XMLSchema::IDREF< ACE_TCHAR > const& ); + ::XSCRT::Type* idref_ptr (); + + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > idref_; + + // version + // + public: + bool version_p () const; + ::XMLSchema::string< ACE_TCHAR > const& version () const; + ::XMLSchema::string< ACE_TCHAR >& version (); + void version (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > version_; + + // extender + // + public: + bool extender_p () const; + ::XMLSchema::string< ACE_TCHAR > const& extender () const; + ::XMLSchema::string< ACE_TCHAR >& extender (); + void extender (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > extender_; + + // extenderID + // + public: + bool extenderID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& extenderID () const; + ::XMLSchema::string< ACE_TCHAR >& extenderID (); + void extenderID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > extenderID_; + + public: + Extension (); + + Extension (::XSCRT::XML::Element< ACE_TCHAR > const&); + Extension (Extension const& s); + + Extension& + operator= (Extension const& s); + + private: + char regulator__; + }; +} + +namespace XMI +{ + namespace reader + { + XSC_XML_Handlers_Export + ::XMI::Extension + extension (xercesc::DOMDocument const*); + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace XMI +{ + namespace Traversal + { + struct XSC_XML_Handlers_Export Extension : ::XMLSchema::Traversal::Traverser< ::XMI::Extension > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + uuid (Type&); + + virtual void + uuid (Type const&); + + virtual void + uuid_none (Type&); + + virtual void + uuid_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + idref (Type&); + + virtual void + idref (Type const&); + + virtual void + idref_none (Type&); + + virtual void + idref_none (Type const&); + + virtual void + version (Type&); + + virtual void + version (Type const&); + + virtual void + version_none (Type&); + + virtual void + version_none (Type const&); + + virtual void + extender (Type&); + + virtual void + extender (Type const&); + + virtual void + extender_none (Type&); + + virtual void + extender_none (Type const&); + + virtual void + extenderID (Type&); + + virtual void + extenderID (Type const&); + + virtual void + extenderID_none (Type&); + + virtual void + extenderID_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } +} + +#include "XMLSchema/Writer.hpp" + +namespace XMI +{ + namespace Writer + { + struct Extension : Traversal::Extension, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::XMI::Extension Type; + Extension (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + uuid (Type &o) + { + this->uuid (const_cast <Type const &> (o)); + } + + virtual void + uuid (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + virtual void + idref (Type &o) + { + this->idref (const_cast <Type const &> (o)); + } + + virtual void + idref (Type const&); + + virtual void + version (Type &o) + { + this->version (const_cast <Type const &> (o)); + } + + virtual void + version (Type const&); + + virtual void + extender (Type &o) + { + this->extender (const_cast <Type const &> (o)); + } + + virtual void + extender (Type const&); + + virtual void + extenderID (Type &o) + { + this->extenderID (const_cast <Type const &> (o)); + } + + virtual void + extenderID (Type const&); + + protected: + Extension (); + }; + } +} + +namespace XMI +{ + namespace writer + { + XSC_XML_Handlers_Export + void + extension (::XMI::Extension const&, xercesc::DOMDocument*); + } +} + +#endif // XMI_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp new file mode 100644 index 00000000000..24fa7a9eb6e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp @@ -0,0 +1,77 @@ +// file : XMLSchema/Traversal.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XMLSCHEMA_TRAVERSAL_HPP +#define XMLSCHEMA_TRAVERSAL_HPP + +#include <XSCRT/Traversal.hpp> +#include <XMLSchema/Types.hpp> + +namespace XMLSchema +{ + namespace Traversal + { + // Automatic traversal of IDREFs. + // + // + struct IDREF : + XSCRT::Traversal::Traverser<XMLSchema::IDREF_Base, XSCRT::Type> + { + virtual void + traverse (XMLSchema::IDREF_Base& r) + { + if (r.get ()) dispatch (*(r.get ())); + } + + virtual void + traverse (XMLSchema::IDREF_Base const& r) + { + if (r.get ()) dispatch (*(r.get ())); + } + }; + + + template <typename T> + struct Traverser : XSCRT::Traversal::Traverser<T, XSCRT::Type> + { + }; + + typedef Traverser<byte> byte; + typedef Traverser<unsignedByte> unsignedByte; + + typedef Traverser<short_> short_; + typedef Traverser<unsignedShort> unsignedShort; + + typedef Traverser<int_> int_; + typedef Traverser<unsignedInt> unsignedInt; + + typedef Traverser<long_> long_; + typedef Traverser<unsignedLong> unsignedLong; + + typedef Traverser<boolean> boolean; + + typedef Traverser<float_> float_; + typedef Traverser<double_> double_; + + template <typename C> + struct string : Traverser<XMLSchema::string<C> > + { + }; + + template <typename C> + struct ID : Traverser<XMLSchema::ID<C> > + { + }; + + template <typename C> + struct anyURI : Traverser <XMLSchema::anyURI<C> > + { + }; + } +} + +#include <XMLSchema/Traversal.ipp> +#include <XMLSchema/Traversal.tpp> + +#endif // XMLSCHEMA_TRAVERSAL_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.ipp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.ipp new file mode 100644 index 00000000000..a5c614182a3 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.ipp @@ -0,0 +1,10 @@ +// file : XMLSchema/Traversal.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + namespace Traversal + { + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.tpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.tpp new file mode 100644 index 00000000000..d79c13630fb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Traversal.tpp @@ -0,0 +1,11 @@ +// file : XMLSchema/Traversal.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + namespace Traversal + { + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.hpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.hpp new file mode 100644 index 00000000000..e4fa52dbb9c --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.hpp @@ -0,0 +1,22 @@ +// file : XMLSchema/TypeInfo.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XMLSCHEMA_TYPE_INFO_HPP +#define XMLSCHEMA_TYPE_INFO_HPP + +#include <XSCRT/ExtendedTypeInfo.hpp> + +namespace XMLSchema +{ + template <typename C> + struct TypeInfoInitializer + { + TypeInfoInitializer (XSCRT::ExtendedTypeInfoMap&); + }; +} + +#include <XMLSchema/TypeInfo.ipp> +#include <XMLSchema/TypeInfo.tpp> + +#endif // XMLSCHEMA_TYPE_INFO_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.ipp b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.ipp new file mode 100644 index 00000000000..5b9422f38c8 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.ipp @@ -0,0 +1,7 @@ +// file : XMLSchema/TypeInfo.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp new file mode 100644 index 00000000000..918197937b7 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp @@ -0,0 +1,98 @@ +// file : XMLSchema/TypeInfo.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + //@@ VC6 + // + template<typename T> + void + add_info (XSCRT::ExtendedTypeInfoMap& map, T*) + { + using XSCRT::TypeId; + using XSCRT::ExtendedTypeInfo; + + TypeId id (typeid (T)); + ExtendedTypeInfo info (id); + + info.add_base (ExtendedTypeInfo::Access::public_, + false, + typeid (XSCRT::Type)); + + map.insert (std::make_pair (id, info)); + } + + + template <typename C> + inline + TypeInfoInitializer<C>:: + TypeInfoInitializer (XSCRT::ExtendedTypeInfoMap& map) + { + using XSCRT::TypeId; + using XSCRT::ExtendedTypeInfo; + + // XSCRT::Type + // + { + TypeId id (typeid (XSCRT::Type)); + map.insert (std::make_pair (id, ExtendedTypeInfo (id))); + } + + //@@ VC6 + + add_info<byte> (map, 0); + add_info<unsignedByte> (map, 0); + + add_info<short_> (map, 0); + add_info<unsignedShort> (map, 0); + + add_info<int_> (map, 0); + add_info<unsignedInt> (map, 0); + + add_info<long_> (map, 0); + add_info<unsignedLong> (map, 0); + + add_info<boolean> (map, 0); + + add_info<float_> (map, 0);; + add_info<double_> (map, 0); + + add_info<string<C> > (map, 0); + + add_info<normalizedString<C> > (map, 0); + add_info<token<C> > (map, 0); + add_info<NMTOKEN<C> > (map, 0); + add_info<Name<C> > (map, 0); + add_info<NCName<C> > (map, 0); + add_info<QName<C> > (map, 0); + + add_info<ID<C> > (map, 0); + + // IDREF_Base + // + { + TypeId id (typeid (IDREF_Base)); + ExtendedTypeInfo info (id); + + info.add_base (ExtendedTypeInfo::Access::public_, + false, + typeid (XSCRT::Type)); + + map.insert (std::make_pair (id, info)); + } + + // IDREF + // + { + TypeId id (typeid (IDREF<C>)); + ExtendedTypeInfo info (id); + + info.add_base (ExtendedTypeInfo::Access::public_, + false, + typeid (IDREF_Base)); + + map.insert (std::make_pair (id, info)); + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp new file mode 100644 index 00000000000..9f4ea91f3c4 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp @@ -0,0 +1,670 @@ +// file : XMLSchema/Types.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XMLSCHEMA_TYPES_HPP +#define XMLSCHEMA_TYPES_HPP + +#include <string> +#include "XSCRT/Elements.hpp" + +#include "ace/Basic_Types.h" +/** + * @@ HACK: VC7 + * + * Disabled the warning about using this in the base member initialization section. + * Our use in this file is fine. + */ +#ifdef _MSC_VER +# pragma warning ( disable: 4355 ) +#endif +namespace XMLSchema +{ + typedef XSCRT::FundamentalType<ACE_INT8> byte; + typedef XSCRT::FundamentalType<ACE_UINT8> unsignedByte; + + typedef XSCRT::FundamentalType<ACE_INT16> short_; + typedef XSCRT::FundamentalType<ACE_UINT16> unsignedShort; + + typedef XSCRT::FundamentalType<ACE_INT32> int_; + typedef XSCRT::FundamentalType<ACE_UINT32> unsignedInt; + + typedef XSCRT::FundamentalType<ACE_INT64> long_; + typedef XSCRT::FundamentalType<ACE_UINT64> unsignedLong; + + //@@ It would be nice to use some arbitrary-length integer class. + // + typedef long_ decimal; + typedef decimal integer; + typedef integer nonPositiveInteger; + typedef integer nonNegativeInteger; + typedef nonNegativeInteger positiveInteger; + typedef nonPositiveInteger negativeInteger; + + + typedef XSCRT::FundamentalType<bool> boolean; + + typedef XSCRT::FundamentalType<float> float_; + typedef XSCRT::FundamentalType<double> double_; + + // Just to make GCC 3.3 and other broken compilers shutup. + // + using std::basic_string; + + + template <typename C> + class string : public XSCRT::Type, public basic_string<C> + { + protected: + typedef basic_string<C> Base__ ; + + public: + // typedef ACE_Refcounted_Auto_Ptr < string, ACE_Null_Mutex > _ptr; + + //@@ VC6 does not inject XSCRT::Type into the scope so I have + // to qualify it all the time. + // + + string () + { + } + + string (XSCRT::XML::Element<C> const& e) + : Base__ (e.value ()) + { + } + + string (XSCRT::XML::Attribute<C> const& a) + : Base__ (a.value ()) + { + } + + string (Base__ const& x) + : Base__ (x) + { + } + + string (C const* x) + : Base__ (x) + { + } + + string& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class normalizedString : public string<C> + { + protected: + typedef typename string<C>::Base__ Base__; + + public: + normalizedString () + { + } + + normalizedString (XSCRT::XML::Element<C> const& e) + : string<C> (e) + { + } + + normalizedString (XSCRT::XML::Attribute<C> const& a) + : string<C> (a) + { + } + + normalizedString (Base__ const& x) + : string<C> (x) + { + } + + normalizedString (C const* x) + : string<C> (x) + { + } + + normalizedString& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class token : public normalizedString<C> + { + protected: + typedef typename normalizedString<C>::Base__ Base__; + + public: + token () + { + } + + token (XSCRT::XML::Element<C> const& e) + : normalizedString<C> (e) + { + } + + token (XSCRT::XML::Attribute<C> const& a) + : normalizedString<C> (a) + { + } + + token (Base__ const& x) + : normalizedString<C> (x) + { + } + + token (C const* x) + : normalizedString<C> (x) + { + } + + token& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class NMTOKEN : public token<C> + { + protected: + typedef typename token<C>::Base__ Base__; + + public: + NMTOKEN () + { + } + + NMTOKEN (XSCRT::XML::Element<C> const& e) + : token<C> (e) + { + } + + NMTOKEN (XSCRT::XML::Attribute<C> const& a) + : token<C> (a) + { + } + + NMTOKEN (Base__ const& x) + : token<C> (x) + { + } + + NMTOKEN (C const* x) + : token<C> (x) + { + } + + NMTOKEN& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + class Name: public token<C> + { + protected: + typedef typename token<C>::Base__ Base__; + + public: + Name() + { + } + + Name(XSCRT::XML::Element<C> const& e) + : token<C> (e) + { + } + + Name(XSCRT::XML::Attribute<C> const& a) + : token<C> (a) + { + } + + Name(Base__ const& x) + : token<C> (x) + { + } + + Name (C const* x) + : token<C> (x) + { + } + + Name& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class NCName: public Name<C> + { + protected: + typedef typename Name<C>::Base__ Base__; + + public: + NCName() + { + } + + NCName(XSCRT::XML::Element<C> const& e) + : Name<C> (e) + { + } + + NCName(XSCRT::XML::Attribute<C> const& a) + : Name<C> (a) + { + } + + NCName(Base__ const& x) + : Name<C> (x) + { + } + + NCName (C const* x) + : Name<C> (x) + { + } + + NCName& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + class QName: public Name<C> + { + protected: + typedef typename Name<C>::Base__ Base__; + + public: + QName() + { + } + + QName(XSCRT::XML::Element<C> const& e) + : Name<C> (e) + { + } + + QName(XSCRT::XML::Attribute<C> const& a) + : Name<C> (a) + { + } + + QName(Base__ const& x) + : Name<C> (x) + { + } + + QName (C const* x) + : Name<C> (x) + { + } + + QName& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + struct IdentityProvider : XSCRT::IdentityProvider + { + IdentityProvider (NCName<C> const& id) + : id_ (id) + { + } + + virtual ~IdentityProvider (void) + { + } + + virtual bool + before (XSCRT::IdentityProvider const& y) const + { + return id_ < dynamic_cast<IdentityProvider const&> (y).id_; + } + + private: + NCName<C> const& id_; + + private: + IdentityProvider (IdentityProvider const&); + + IdentityProvider& + operator= (IdentityProvider const&); + }; + + + template <typename C> + class ID : public NCName<C> + { + protected: + typedef typename NCName<C>::Base__ Base__; + + public: + ~ID() + { + unregister_id (); + } + + ID () + : id_provider_ (*this) + { + } + + ID (XSCRT::XML::Element<C> const& e) + : NCName<C> (e), id_provider_ (*this) + { + } + + ID (XSCRT::XML::Attribute<C> const& a) + : NCName<C> (a), id_provider_ (*this) + { + } + + ID (ID const& x) + : NCName<C> (x), id_provider_ (*this) + { + } + + ID (Base__ const& x) + : NCName<C> (x), id_provider_ (*this) + { + } + + ID (C const* x) + : NCName<C> (x), id_provider_ (*this) + { + } + + ID& + operator= (Base__ const& x) + { + unregister_id (); + + static_cast<NCName<C>&>(*this) = x; + + register_id (); + + return *this; + } + + ID& + operator= (ID const& x) + { + unregister_id (); + + static_cast<NCName<C>&>(*this) = static_cast<NCName<C> const&>(x); + + register_id (); + + return *this; + } + + public: + using NCName<C>::container; + + virtual void + container (XSCRT::Type* c) + { + unregister_id (); + + NCName<C>::container (c); + + register_id (); + } + + private: + using NCName<C>::empty; + using NCName<C>::root; + + void + register_id () + { + if (NCName<C>::container () != this && !empty ()) + { + //std::wcerr << "registering " << container () + // << " as '" << *this + // << "' on " << container () << std::endl; + NCName<C>::container ()->register_id (id_provider_, + NCName<C>::container ()); + } + } + + void + unregister_id () + { + if (NCName<C>::container () != this && !empty ()) + { + //std::wcerr << "un-registering " << container () + // << " as '" << *this + // << "' on " << container () << std::endl; + NCName<C>::container ()->unregister_id (id_provider_); + } + } + + private: + IdentityProvider<C> id_provider_; + }; + + struct IDREF_Base : public XSCRT::Type + { + virtual XSCRT::Type const* + get () const = 0; + + virtual XSCRT::Type* + get () = 0; + }; + + template <typename C> + class IDREF : public IDREF_Base + { + public: + typedef C CDR_Type__; + IDREF () + : id_provider_ (id_) + { + } + + IDREF (XSCRT::XML::Element<C> const& e) + : id_ (e), id_provider_ (id_) + { + } + + IDREF (XSCRT::XML::Attribute<C> const& a) + : id_ (a), id_provider_ (id_) + { + } + + IDREF (IDREF const& x) + : XMLSchema::IDREF_Base (), + id_ (x.id_), id_provider_ (id_) + { + } + + IDREF (basic_string<C> const& id) + : id_ (id), id_provider_ (id_) + { + } + + IDREF (C const* id) + : id_ (id), id_provider_ (id_) + { + } + + IDREF& + operator= (IDREF const& x) + { + id_ = x.id_; + return *this; + } + + IDREF& + operator= (basic_string<C> const& x) + { + id_ = x; + return *this; + } + + public: + NCName<C> + id () const + { + return id_; + } + + public: + XSCRT::Type const* + operator-> () const + { + return get (); + } + + XSCRT::Type* + operator-> () + { + return get (); + } + + XSCRT::Type const& + operator* () const + { + return *(get ()); + } + + XSCRT::Type& + operator* () + { + return *(get ()); + } + + virtual XSCRT::Type const* + get () const + { + if (!id_.empty () && container () != this) + { + return root ()->lookup_id (id_provider_); + } + else + { + return 0; + } + } + + virtual XSCRT::Type* + get () + { + if (!id_.empty () && container () != this) + { + return root ()->lookup_id (id_provider_); + } + else + { + return 0; + } + } + + // conversion to bool + // + typedef void (IDREF::*bool_convertable)(); + + operator bool_convertable () const + { + return get () ? &IDREF::true_ : 0; + } + + private: + void true_ () + { + } + + private: + NCName<C> id_; + IdentityProvider<C> id_provider_; + }; + + template <typename C> + class anyURI : public XSCRT::Type, public basic_string <C> + { + protected: + typedef basic_string <C> Base__ ; + + public: + // Trait for marshaling string + typedef C CDR_Type__; + + //@@ VC6 does not inject XSCRT::Type into the scope so I have + // to qualify it all the time. + // + + anyURI (void) + { + } + + anyURI (XSCRT::XML::Element<C> const& e) + : Base__ (e.value ()) + { + } + + anyURI (XSCRT::XML::Attribute<C> const& a) + : Base__ (a.value ()) + { + } + + anyURI (Base__ const& x) + : Base__ (x) + { + } + + anyURI (C const * x) + : Base__ (x) + { + } + + anyURI (const anyURI& s) + : Base__ (s) + { + + } + + anyURI & operator= (Base__ const& x) + { + static_cast <Base__ &> (*this) = x; + return *this; + } + }; +} + +#include "XMLSchema/Types.ipp" +#include "XMLSchema/Types.tpp" + +#endif // XMLSCHEMA_TYPES_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.ipp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.ipp new file mode 100644 index 00000000000..6b749260f55 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.ipp @@ -0,0 +1,8 @@ +// file : XMLSchema/Types.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.tpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.tpp new file mode 100644 index 00000000000..4a8bddcf597 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Types.tpp @@ -0,0 +1,9 @@ +// file : XMLSchema/Types.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + +} + diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.hpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.hpp new file mode 100644 index 00000000000..4a0c1603efa --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.hpp @@ -0,0 +1,159 @@ +// file : XMLSchema/Writer.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XMLSCHEMA_WRITER_HPP +#define XMLSCHEMA_WRITER_HPP + +#include <sstream> + +#include <XSCRT/Writer.hpp> + +#include <XMLSchema/Types.hpp> +#include <XMLSchema/Traversal.hpp> + +#include <iostream> + +namespace XMLSchema +{ + namespace Writer + { + template <typename T, typename C> + struct FundamentalType : Traversal::Traverser<T>, + virtual XSCRT::Writer<C> + { + FundamentalType (XSCRT::XML::Element<C>& e) + : XSCRT::Writer<C> (e) + { + } + + using XSCRT::Writer<C>::top_; + using XSCRT::Writer<C>::attr_; + + virtual void + traverse (T const& o) + { + using namespace XSCRT::XML; + + std::basic_ostringstream<C> os; + + os << o; + + if (Attribute<C>* a = attr_ ()) + { + a->value (os.str ()); + } + else + { + top_().value (os.str ()); + } + } + + protected: + virtual void + traverse (T &t) + { + Traversal::Traverser<T>::traverse (t); + } + + FundamentalType () + { + } + }; + + template<typename C> + struct FundamentalType <XSCRT::FundamentalType<bool>, C> : + Traversal::Traverser<XSCRT::FundamentalType<bool> >, + virtual XSCRT::Writer<C> + { + FundamentalType (XSCRT::XML::Element<C> &e) + : XSCRT::Writer<C> (e) + { + } + + using XSCRT::Writer<C>::top_; + using XSCRT::Writer<C>::attr_; + + virtual void + traverse (XSCRT::FundamentalType<bool> const &o) + { + using namespace XSCRT::XML; + + std::basic_ostringstream<C> os; + + if (o) + { + os << "true"; + } + else + { + os << "false"; + } + + if (Attribute<C>* a = attr_ ()) + { + a->value (os.str ()); + } + else + { + top_().value (os.str ()); + } + } + + protected: + virtual void + traverse (XSCRT::FundamentalType<bool> &t) + { + Traversal::Traverser<XSCRT::FundamentalType<bool> >::traverse (t); + } + + FundamentalType () + { + } + }; + + + template <typename C> + struct IDREF : Traversal::Traverser<XMLSchema::IDREF<C> >, + virtual XSCRT::Writer<C> + { + IDREF (XSCRT::XML::Element<C>& e) + : XSCRT::Writer<C> (e) + { + } + + virtual void + traverse ( + typename Traversal::Traverser<XMLSchema::IDREF<C> >::Type const& o) + { + using namespace XSCRT::XML; + + if (Attribute<C>* a = XSCRT::Writer<C>::attr_ ()) + { + a->value (o.id ()); + } + else + { + XSCRT::Writer<C>::top_().value (o.id ()); + } + } + + protected: + + virtual void + traverse (typename Traversal::Traverser<XMLSchema::IDREF<C> >::Type &o) + { + Traversal::Traverser<XMLSchema::IDREF<C> >::traverse (o); + } + + IDREF () + { + } + }; + } +} + +#include <XMLSchema/Writer.ipp> +#include <XMLSchema/Writer.tpp> + +#endif // XMLSCHEMA_WRITER_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.ipp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.ipp new file mode 100644 index 00000000000..2b7c9a4b939 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.ipp @@ -0,0 +1,10 @@ +// file : XMLSchema/Writer.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + namespace Writer + { + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.tpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.tpp new file mode 100644 index 00000000000..6c57de04d81 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/Writer.tpp @@ -0,0 +1,10 @@ +// file : XMLSchema/Writer.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XMLSchema +{ + namespace Writer + { + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XMLSchema/id_map.hpp b/modules/CIAO/tools/Config_Handlers/XMLSchema/id_map.hpp new file mode 100644 index 00000000000..a2843d44693 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XMLSchema/id_map.hpp @@ -0,0 +1,138 @@ +// -*- C++ -*- +// $Id$ + +//============================================================================= +/** + * @file id_map.hpp + * + * This file contains the ID_Map class which has the responsibility of linking + * XML IDREF objects to their XML ID counterparts. In the output files, this + * means that a <IDREF name>_ptr() will return a pointer to the identified + * object. + * + * Exception NULL_PTR_Entry is thrown when a program attempts to add a NULL_PTR + * to either the id_map or idref_map. + * + * Exception Unresolved_IDREF is thrown if an element in an XML document attempts + * to reference an ID that does not exist. + * + * @author Jason R. Cody <jason.r.cody@vanderbilt.edu; jason.r.cody@gmail.com> + */ +//============================================================================= + +#ifndef _ID_MAP_H +#define _ID_MAP_H + +//ID_Map makes use of the Types::idref_ data member to set it to the appropriate +//object created during parsing +#include "XMLSchema/Types.hpp" + +//The ID_Map is a Thread Specific Storage element. +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" + + /** + * @class ID_Map + * + * @brief A class that handles the mapping of IDREF objects to objects with the + * respective ID. + */ + class ID_Map + { + public: + + //Trait to allow for ease of thread specific storage. + typedef ACE_TSS<ID_Map> TSS_ID_Map; + typedef std::map<std::basic_string<ACE_TCHAR>, XSCRT::Type*>::iterator id_iterator; + typedef std::multimap<std::basic_string<ACE_TCHAR>, XSCRT::Type*>::iterator idref_iterator; + typedef std::map<std::basic_string<ACE_TCHAR>, XSCRT::Type*> ID_MAP; + typedef std::multimap<std::basic_string<ACE_TCHAR>, XSCRT::Type*> IDREF_MAP; + + + //Exception Classes + //NULL_PTR_Entry thrown when a NULL PTR is added to the + //ID_Map + class NULL_PTR_Entry {}; + + //Unresolved_IDREF thrown when there are IDREF's in the + //XML document. + class Unresolved_IDREF {}; + + //Only a default constructor and destructor are needed + //Constructor + ID_Map () + { + } + + //Destructor + ~ID_Map () + { + } + + //Add an ID to the ID map + void add_id (std::basic_string<ACE_TCHAR> id, XSCRT::Type *obj_ref) + { + if (obj_ref) + { + this->id_map_.insert (ID_MAP::value_type(id, obj_ref)); + } + else + { + throw NULL_PTR_Entry(); + } + return; + } + + //Add an IDREF to the IDREF map + void add_idref (std::basic_string<ACE_TCHAR> idref, XSCRT::Type *obj_ref) + { + if (obj_ref) + { + this->idref_map_.insert (IDREF_MAP::value_type(idref, obj_ref)); + } + else + { + throw NULL_PTR_Entry(); + } + return; + } + + //Sets the referencing elements XSCRT::Type::idref_ to point to the + //referenced element. + //Note: The pointer is of type "XSCRT::Type*" + void resolve_idref ( void ) + { + //Declare iterators to navigate the maps + ID_Map::id_iterator id_iterator; + ID_Map::idref_iterator idref_iterator; + + for (idref_iterator = this->idref_map_.begin(); + idref_iterator != this->idref_map_.end(); + ++idref_iterator) + { + //Find the ID that matches the IDREF element + id_iterator = this->id_map_.find(idref_iterator->first); + if (id_iterator != this->id_map_.end()) + { + //Add the IDREF identifier and the reference to the + //identified object + std::basic_string<ACE_TCHAR> temp_id = id_iterator->first; + idref_iterator->second->set_idref(temp_id, id_iterator->second); + } + else + { + //throw Unresolved_IDREF(); + } + } + } + + private: + //id_map_: maps the ID string to the element with the + // ID attribute + //idref_map_: multimap that maps the IDREF string to the + // element with the IDREF attribute + ID_MAP id_map_; + IDREF_MAP idref_map_; + }; + +#endif /* _ID_MAP_HPP */ diff --git a/modules/CIAO/tools/Config_Handlers/XML_File_Intf.cpp b/modules/CIAO/tools/Config_Handlers/XML_File_Intf.cpp new file mode 100644 index 00000000000..e6c514eebad --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XML_File_Intf.cpp @@ -0,0 +1,103 @@ +// $Id$ + +#include "XML_File_Intf.h" +#include "XML_Typedefs.h" +#include "Deployment.hpp" +#include "DP_Handler.h" +#include "Common.h" + +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/Logger/Log_Macros.h" + +namespace CIAO +{ + namespace Config_Handlers + { + XML_File_Intf::XML_File_Intf (const ACE_TCHAR *file) + : file_ (file), + idl_dp_ (0) + { + } + + bool + XML_File_Intf::read_process_file (const ACE_TCHAR *file) + { + CIAO_TRACE("XML_File_Intf::read_process_file"); + + try + { + if (!XML_Helper::XML_HELPER.is_initialized ()) + return false; + + CIAO_DEBUG ((LM_TRACE, CLINFO "XML_File_Intf::read_process_file - " + "Constructing DOM\n")); + XERCES_CPP_NAMESPACE::DOMDocument *dom = + XML_Helper::XML_HELPER.create_dom ((file)); + + if (dom == 0) + { + CIAO_DEBUG ((LM_TRACE, CLINFO "XML_File_Intf::read_process_file - " + "Failed to open file %s\n", file)); + return false; + } + + XERCES_CPP_NAMESPACE::DOMElement *foo = dom->getDocumentElement (); + CIAO_DEBUG ((LM_TRACE, CLINFO "XML_File_Intf::read_process_file - " + "DOMElement pointer: %u\n", foo)); + + CIAO_DEBUG ((LM_TRACE, CLINFO "XML_File_Intf::read_process_file - " + "Parsing XML file with XSC\n")); + deploymentPlan dp = + CIAO::Config_Handlers::reader::DeploymentPlan (dom); + + CIAO_DEBUG ((LM_TRACE, CLINFO "XML_File_Intf::read_process_file - " + "Processing using config handlers\n")); + DP_Handler dp_handler (dp); + + this->idl_dp_.reset (dp_handler.plan ()); + + if (this->idl_dp_.get ()) + return true; + } + catch (const Config_Error &ex) + { + CIAO_ERROR ((LM_ERROR, CLINFO "XML_File_Intf::error at %C: %C\n", + ex.name_.c_str (), ex.error_.c_str ())); + } + catch (...) + { + CIAO_ERROR ((LM_ERROR, CLINFO "XML_File_Intf::caught - " + "Unexpected exception whilst parsing XML into IDL.\n")); + } + + return false; + } + + ::Deployment::DeploymentPlan const * + XML_File_Intf::get_plan (void) + { + CIAO_TRACE("get_plan"); + if (this->idl_dp_.get () == 0 && !this->read_process_file (this->file_.c_str ())) + return 0; + + return this->idl_dp_.get (); + } + + ::Deployment::DeploymentPlan * + XML_File_Intf::release_plan (void) + { + CIAO_TRACE("XML_File_Intf::get_plan"); + if (this->idl_dp_.get () == 0 && !this->read_process_file (this->file_.c_str ())) + return 0; + return this->idl_dp_.release (); + } + + void + XML_File_Intf::add_search_path (const ACE_TCHAR *environment, + const ACE_TCHAR *relpath) + { + XML_Helper::_path_resolver.add_path (environment, relpath); + } + + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XML_File_Intf.h b/modules/CIAO/tools/Config_Handlers/XML_File_Intf.h new file mode 100644 index 00000000000..fd086836b78 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XML_File_Intf.h @@ -0,0 +1,56 @@ +//============================================================== +/** + * @file XML_File_Intf.h + * + * $Id$ + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//================================================================ + +#ifndef CIAO_CONFIG_XML_FILE_INTF_H +#define CIAO_CONFIG_XML_FILE_INTF_H +#include /**/ "ace/pre.h" + +#include "Config_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/Auto_Ptr.h" + +#include <string> + +namespace Deployment +{ + struct DeploymentPlan ; +} + +namespace CIAO +{ + namespace Config_Handlers + { + class Config_Handlers_Export XML_File_Intf + { + public: + XML_File_Intf (const ACE_TCHAR *file); + + ::Deployment::DeploymentPlan const *get_plan (void); + ::Deployment::DeploymentPlan *release_plan (void); + + void add_search_path (const ACE_TCHAR *environment, + const ACE_TCHAR *relpath); + + protected: + + bool read_process_file (const ACE_TCHAR *file); + + private: + std::basic_string <ACE_TCHAR> file_; + ACE_Auto_Ptr< ::Deployment::DeploymentPlan> idl_dp_; + }; + } +} +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_XML_FILE_INTF_H*/ diff --git a/modules/CIAO/tools/Config_Handlers/XML_Typedefs.cpp b/modules/CIAO/tools/Config_Handlers/XML_Typedefs.cpp new file mode 100644 index 00000000000..9d57ac17e92 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XML_Typedefs.cpp @@ -0,0 +1,14 @@ +// $Id$ + +#include "XML_Typedefs.h" + +namespace CIAO +{ + namespace Config_Handlers + { + XML_Helper::PATH_RESOLVER XML_Helper::_path_resolver; + XML_Helper::XML_RESOLVER XML_Helper::_xml_resolver (XML_Helper::_path_resolver); + XML_Helper::ERROR_HANDLER XML_Helper::_xml_error_handler; + XML_Helper::HELPER XML_Helper::XML_HELPER (XML_Helper::_xml_resolver, XML_Helper::_xml_error_handler); + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XML_Typedefs.h b/modules/CIAO/tools/Config_Handlers/XML_Typedefs.h new file mode 100644 index 00000000000..f0054df2e57 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XML_Typedefs.h @@ -0,0 +1,38 @@ +/** + * @file XML_Typedefs.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * $Id$ + * Typedefs from the XML Utilities. + */ +#ifndef XML_TYPEDEFS_H +#define XML_TYPEDEFS_H + +#include "XSC_XML_Handlers_Export.h" +#include "XML/XML_Helper.h" +#include "XML/XML_Schema_Resolver.h" +#include "XML/XML_Error_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export XML_Helper + { + public: + typedef ::CIAO::XML::Environment_Resolver PATH_RESOLVER; + typedef ::CIAO::XML::XML_Schema_Resolver< ::CIAO::XML::Environment_Resolver > XML_RESOLVER; + typedef ::CIAO::XML::XML_Error_Handler ERROR_HANDLER; + typedef ::CIAO::XML::XML_Helper< XML_RESOLVER, ERROR_HANDLER > HELPER; + + static PATH_RESOLVER _path_resolver; + static XML_RESOLVER _xml_resolver; + static ERROR_HANDLER _xml_error_handler; + + public: + static HELPER XML_HELPER; + }; + } +} + + +#endif /* XML_TYPEDEFS_H */ diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.hpp new file mode 100644 index 00000000000..0c8b6979282 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.hpp @@ -0,0 +1,572 @@ +// file : XSCRT/Elements.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_ELEMENTS_HPP +#define XSCRT_ELEMENTS_HPP + +#include <map> +#include <string> +#include <sstream> +#include "ace/ace_wchar.h" +// #include <iostream> //@@ tmp + +#include <XSCRT/Parser.hpp> +#include "ace/Refcounted_Auto_Ptr.h" + +namespace XSCRT +{ + struct IdentityProvider + { + virtual bool + before (IdentityProvider const&) const = 0; + + virtual ~IdentityProvider (void) + { + + } + }; + + class Type + { + public: + + virtual ~Type (void) + { + } + + protected: + Type (void) + : container_ (0) + { + } + + template <typename C> + Type (XML::Element<C> const&) + : container_ (0) + { + } + + template <typename C> + Type (XML::Attribute<C> const&) + : container_ (0) + { + } + + Type (Type const&) + : container_ (0) + { + } + + Type& + operator= (Type const&) + { + //@@ I don't need this. + //if (map_.get ()) map_->clear (); // Flush the map. + return *this; + } + + public: + Type const* + container () const + { + return container_ ? container_ : this; + } + + Type* + container () + { + return container_ ? container_ : this; + } + + + Type const* + root () const + { + Type const* r = container (); + + //@@ VC6 can't handle this inside the loop. + // + Type const* c = r->container (); + + for (; c != r; c = c->container ()) r = c; + + return r; + } + + Type* + root () + { + Type* r = container (); + + for (Type* c = r->container (); c != r; c = c->container ()) r = c; + + return r; + } + + //@@ + //protected: + + public: + virtual void + container (Type* c) + { + if (container_ == c) return; + + // Revoke registrations from our old container. + // + if (container_ != 0 && map_.get ()) + { + for (Map_::iterator i (map_->begin ()); i != map_->end (); ++i) + { + //std::wcerr << "revoking " << i->second + // << " to " << container_ << std::endl; + + container_->unregister_id (*(i->first)); + } + } + + // Copy registrations to our new container. + // + if (c != 0 && map_.get ()) + { + for (Map_::iterator i (map_->begin ()); i != map_->end (); ++i) + { + //std::wcerr << "copying " << i->second + // << " to " << c << std::endl; + + c->register_id (*(i->first), i->second); + } + } + + container_ = c; + } + + //@@ + //protected: + + public: + void + register_id (IdentityProvider const& id, Type* t) + { + if (map_.get () == 0) + { + map_ = std::auto_ptr<Map_> (new Map_); + } + + if (!map_->insert ( + std::pair<IdentityProvider const*, Type*> (&id, t)).second) + { + throw 1; + } + + if (container () != this) container ()->register_id (id, t); + } + + void + unregister_id (IdentityProvider const& id) + { + if (map_.get ()) + { + Map_::iterator it (map_->find (&id)); + + if (it != map_->end ()) + { + map_->erase (it); + + if (container () != this) container ()->unregister_id (id); + + return; + } + } + + throw 1; + } + + Type* + lookup_id (IdentityProvider const& id) const + { + if (map_.get ()) + { + Map_::const_iterator it (map_->find (&id)); + + if (it != map_->end ()) + { + return it->second; + } + } + + return 0; + } + + //Get and set methods for the idref_map_ data member + Type* get_idref (const char* name) + { + std::basic_string<ACE_TCHAR> name_string (ACE_TEXT_CHAR_TO_TCHAR(name)); + std::map<std::basic_string<ACE_TCHAR>, XSCRT::Type*>::iterator i = + this->idref_map_.find(name_string); + if (i != idref_map_.end()) + { + return i->second; + } + else + { + return 0; + } + } + + Type* get_idref (const wchar_t *name) + { + std::basic_string<ACE_TCHAR> name_string (ACE_TEXT_WCHAR_TO_TCHAR(name)); + std::map<std::basic_string<ACE_TCHAR>, XSCRT::Type*>::iterator i = + this->idref_map_.find(name_string); + if (i != idref_map_.end()) + { + return i->second; + } + else + { + return 0; + } + } + + + void set_idref (std::basic_string<ACE_TCHAR> name, Type* new_idref) + { + this->idref_map_.insert(std::pair<std::basic_string<ACE_TCHAR>,Type*>(name, new_idref)); + return; + } + + private: + + //Data member to handle unbounded IDREF attributes and elements + std::map<std::basic_string<ACE_TCHAR>, XSCRT::Type*> idref_map_; + + Type* container_; + + struct IdentityComparator + { + bool operator () (IdentityProvider const* x, + IdentityProvider const* y) const + { + return x->before (*y); + } + }; + + typedef + std::map<IdentityProvider const*, Type*, IdentityComparator> + Map_; + + std::auto_ptr<Map_> map_; + }; + + // Fundamental types template. + // + // + template <typename X> + class FundamentalType : public Type + { + public: + // Trait for marshaling a FundamentalType X + typedef X CDR_Type__; +#if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x620) + typedef ACE_Refcounted_Auto_Ptr < FundamentalType, ACE_Null_Mutex > _ptr; +#endif /* !__BORLANDC__ */ + + FundamentalType () + { + } + + template<typename C> + FundamentalType (XML::Element<C> const& e) + { + std::basic_stringstream<C> s; + s << e.value (); + s >> x_; + } + + template<typename C> + FundamentalType (XML::Attribute<C> const& a) + { + std::basic_stringstream<C> s; + s << a.value (); + s >> x_; + } + + FundamentalType (X const& x) + : x_ (x) + { + } + + FundamentalType& + operator= (X const& x) + { + x_ = x; + return *this; + } + + public: + operator X const& () const + { + return x_; + } + + operator X& () + { + return x_; + } + + protected: + X x_; + }; + +#if !((defined (__GNUC__) && (__GNUC__ == 3 && (__GNUC_MINOR__ < 3))) || \ + (defined (__BORLANDC__) && (__BORLANDC__ < 0x620)) || \ + (defined (__SUNPRO_CC) && (__SUNPRO_CC <= 0x5100))) + + // Stuff for normal compilers. + // + + // Specialization for `signed char' + // + // + template<> + template<typename C> + inline + FundamentalType<signed char>:: + FundamentalType (XML::Element<C> const& e) + { + std::basic_stringstream<C> s; + s << e.value (); + + short t; + s >> t; + + x_ = static_cast<signed char> (t); + } + + template<> + template<typename C> + inline + FundamentalType<signed char>:: + FundamentalType (XML::Attribute<C> const& a) + { + std::basic_stringstream<C> s; + s << a.value (); + + short t; + s >> t; + + x_ = static_cast<signed char> (t); + } + + // Specialization for `unsigned char' + // + // + template<> + template<typename C> + inline + FundamentalType<unsigned char>:: + FundamentalType (XML::Element<C> const& e) + { + std::basic_stringstream<C> s; + s << e.value (); + + unsigned short t; + s >> t; + + x_ = static_cast<unsigned char> (t); + } + + template<> + template<typename C> + inline + FundamentalType<unsigned char>:: + FundamentalType (XML::Attribute<C> const& a) + { + std::basic_stringstream<C> s; + s << a.value (); + + unsigned short t; + s >> t; + + x_ = static_cast<unsigned char> (t); + } + +#else + + // Stuff for broken VC6 & gcc < 3.3. Don't like what you see - use better + // compiler! + // + + // Specialization for signed char. + // + template <> + class FundamentalType<signed char> : public Type + { + public: + FundamentalType () + { + } + + template<typename C> + FundamentalType (XML::Element<C> const& e) + { + std::basic_stringstream<C> s; + s << e.value (); + + short t; + s >> t; + + x_ = static_cast<signed char> (t); + } + + template<typename C> + FundamentalType (XML::Attribute<C> const& a) + { + std::basic_stringstream<C> s; + s << a.value (); + + short t; + s >> t; + + x_ = static_cast<signed char> (t); + } + + FundamentalType (signed char const& x) + : x_ (x) + { + } + + FundamentalType& + operator= (signed char const& x) + { + x_ = x; + return *this; + } + + public: + operator signed char const& () const + { + return x_; + } + + operator signed char& () + { + return x_; + } + + protected: + signed char x_; + }; + + // Specialization for unsigned char. + // + template <> + class FundamentalType<unsigned char> : public Type + { + public: + FundamentalType () + { + } + + template<typename C> + FundamentalType (XML::Element<C> const& e) + { + std::basic_stringstream<C> s; + s << e.value (); + + unsigned short t; + s >> t; + + x_ = static_cast<unsigned char> (t); + } + + template<typename C> + FundamentalType (XML::Attribute<C> const& a) + { + std::basic_stringstream<C> s; + s << a.value (); + + unsigned short t; + s >> t; + + x_ = static_cast<unsigned char> (t); + } + + FundamentalType (unsigned char const& x) + : x_ (x) + { + } + + FundamentalType& + operator= (unsigned char const& x) + { + x_ = x; + return *this; + } + + public: + operator unsigned char const& () const + { + return x_; + } + + operator unsigned char& () + { + return x_; + } + + protected: + unsigned char x_; + }; + +#endif + + + // Specialization for bool. + // + // + + template<> + template<> + inline + FundamentalType<bool>:: + FundamentalType (XML::Element<char> const& e) + { + x_ = (e.value () == "true") || (e.value () == "1"); + } + + template<> + template<> + inline + FundamentalType<bool>:: + FundamentalType (XML::Element<wchar_t> const& e) + { + x_ = (e.value () == L"true") || (e.value () == L"1"); + } + + template<> + template<> + inline + FundamentalType<bool>:: + FundamentalType (XML::Attribute<char> const& a) + { + x_ = (a.value () == "true") || (a.value () == "1"); + } + + template<> + template<> + inline + FundamentalType<bool>:: + FundamentalType (XML::Attribute<wchar_t> const& a) + { + x_ = (a.value () == L"true") || (a.value () == L"1"); + } + +} + +#include <XSCRT/Elements.ipp> +#include <XSCRT/Elements.tpp> + +#endif // XSCRT_ELEMENTS_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.ipp new file mode 100644 index 00000000000..414f03eb031 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.ipp @@ -0,0 +1,7 @@ +// file : XSC/Elements.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSC +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.tpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.tpp new file mode 100644 index 00000000000..7539a36d75f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Elements.tpp @@ -0,0 +1,7 @@ +// file : XSC/Elements.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSC +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp new file mode 100644 index 00000000000..e2ab4b64956 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp @@ -0,0 +1,182 @@ +// file : XSCRT/ExtendedTypeInfo.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_EXTENDED_TYPE_INFO_HPP +#define XSCRT_EXTENDED_TYPE_INFO_HPP + +#include <map> +#include <vector> +#include <typeinfo> + +namespace XSCRT +{ + // + // + // + class TypeId + { + public: + template<typename T> + TypeId (T const& t); + + TypeId (std::type_info const& tid); + + public: + bool + operator == (TypeId const& other) const; + + bool + operator != (TypeId const& other) const; + + bool + operator < (TypeId const& other) const; + + /* + friend std::ostream& + operator << (std::ostream& os, TypeId const& t); + */ + + public: + char const* + name () const + { + return tid_->name (); + } + + private: + std::type_info const* tid_; + }; + + + // + // + // + class ExtendedTypeInfo + { + public: + + // + // + // + struct Access + { + enum Value + { + private_, + protected_, + public_ + }; + }; + + + // + // + // + class BaseInfo + { + public: + BaseInfo (Access::Value access, bool virtual_base, TypeId const& tid); + + public: + ExtendedTypeInfo const& + type_info () const; + + Access::Value + access () const; + + bool + virtual_base () const; + + private: + TypeId tid_; + mutable ExtendedTypeInfo const* ti_; + bool virtual_base_; + Access::Value access_; + }; + + private: + typedef + std::vector<BaseInfo> + BaseInfoList; + + public: + typedef + BaseInfoList::const_iterator + BaseIterator; + + public: + ExtendedTypeInfo (TypeId const& tid); + + TypeId + type_id () const; + + BaseIterator + begin_base () const; + + BaseIterator + end_base () const; + + void + add_base (Access::Value access, bool virtual_base, TypeId const& tid); + + private: + TypeId tid_; + BaseInfoList base_; + }; + + typedef + std::map<TypeId, ExtendedTypeInfo> + ExtendedTypeInfoMap; + + + ExtendedTypeInfoMap& + extended_type_info_map (); + + + class NotAvailable {}; + + + template<typename T> + ExtendedTypeInfo const& + extended_type_info (T const& t) + { + return extended_type_info (typeid (t)); + } + + template<typename T> + ExtendedTypeInfo const& + extended_type_info () + { + return extended_type_info (typeid (T)); + } + + //@@ Had to use function template specialization because VC6 + // cannot handle simply overloaded functions. + // + + template <> + inline + ExtendedTypeInfo const& + extended_type_info<TypeId> (TypeId const& tid) + { + ExtendedTypeInfoMap::const_iterator i ( + extended_type_info_map ().find (tid)); + + if (i == extended_type_info_map ().end ()) throw NotAvailable (); + + return i->second; + } + + template <> + inline + ExtendedTypeInfo const& + extended_type_info<std::type_info> (std::type_info const& tid) + { + return extended_type_info (TypeId (tid)); + } +} + +#include <XSCRT/ExtendedTypeInfo.ipp> + +#endif // XSCRT_EXTENDED_TYPE_INFO_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp new file mode 100644 index 00000000000..6c4fba2cf88 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp @@ -0,0 +1,141 @@ +// file : XSCRT/ExtendedTypeInfo.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + + +/* + * @@HACK: Visual Studio. + * I think the return value for operator== for type_info + * in VC7 (perhaps others) is int when is should be bool. + * This causes a warning about converting the return value from + * int to bool. + */ +#ifdef _MSC_VER +# pragma warning( disable: 4800 ) +#endif + +namespace XSCRT +{ + // TypeId + // + // + inline + TypeId:: + TypeId (std::type_info const& tid) + : tid_ (&tid) + { + } + + inline + bool TypeId:: + operator == (TypeId const& other) const + { + return *tid_ == *other.tid_; + } + + inline + bool TypeId:: + operator != (TypeId const& other) const + { + return *tid_ != *other.tid_; + } + + inline + bool TypeId:: + operator < (TypeId const& other) const + { + return tid_->before (*other.tid_); + } + + + // ExtendedTypeInfo::BaseInfo + // + // + + inline + ExtendedTypeInfo::BaseInfo:: + BaseInfo (Access::Value access, bool virtual_base, TypeId const& tid) + : tid_ (tid), + ti_ (0), + virtual_base_ (virtual_base), + access_ (access) + { + } + + inline + ExtendedTypeInfo const& ExtendedTypeInfo::BaseInfo:: + type_info () const + { + if (ti_ == 0) ti_ = &(extended_type_info (tid_)); + + return *ti_; + } + + + inline + ExtendedTypeInfo::Access::Value ExtendedTypeInfo::BaseInfo:: + access () const + { + return access_; + } + + inline + bool ExtendedTypeInfo::BaseInfo:: + virtual_base () const + { + return virtual_base_; + } + + + // ExtendedTypeInfo + // + // + inline + ExtendedTypeInfo:: + ExtendedTypeInfo (TypeId const& tid) + : tid_ (tid) + { + } + + inline + TypeId ExtendedTypeInfo:: + type_id () const + { + return tid_; + } + + inline + ExtendedTypeInfo::BaseIterator ExtendedTypeInfo:: + begin_base () const + { + return base_.begin (); + } + + + inline + ExtendedTypeInfo::BaseIterator ExtendedTypeInfo:: + end_base () const + { + return base_.end (); + } + + inline + void ExtendedTypeInfo:: + add_base (Access::Value access, bool virtual_base, TypeId const& tid) + { + base_.push_back (BaseInfo (access, virtual_base, tid)); + } + + // ExtendedTypeInfoMap + // + // + + inline + ExtendedTypeInfoMap& + extended_type_info_map () + { + static ExtendedTypeInfoMap extended_type_info_map_; + + return extended_type_info_map_; + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.hpp new file mode 100644 index 00000000000..5fa1e827f8d --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.hpp @@ -0,0 +1,67 @@ +// file : XSCRT/Parser.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_PARSER_HPP +#define XSCRT_PARSER_HPP + +#include <string> + +#include "XSCRT/XML.hpp" + +namespace XSCRT +{ + template <typename C> + class Parser + { + public: + Parser (XML::Element<C> const& e) + : e_ (e.dom_element ()->getChildNodes ()), ei_ (0), + a_ (e.dom_element ()->getAttributes ()), ai_ (0) + { + } + + bool + more_elements () const + { + return e_->getLength () > ei_; + } + + XML::Element<C> + next_element () + { + return XML::Element<C> (XML::dom_cast <xercesc::DOMElement*> (e_->item (ei_++))); + } + + bool + more_attributes () const + { + return a_->getLength () > ai_; + } + + XML::Attribute<C> + next_attribute () + { + return XML::Attribute<C> ( + XML::dom_cast <xercesc::DOMAttr*> (a_->item (ai_++))); + } + + private: + xercesc::DOMNodeList const* e_; + unsigned long ei_; + + xercesc::DOMNamedNodeMap const* a_; + unsigned long ai_; + + private: + Parser (Parser const&); + + void + operator= (Parser const&); + }; +} + +#include "XSCRT/Parser.ipp" +#include "XSCRT/Parser.tpp" + +#endif // XSCRT_PARSER_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.ipp new file mode 100644 index 00000000000..f7de09602ae --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.ipp @@ -0,0 +1,7 @@ +// file : XSCRT/Parser.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.tpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.tpp new file mode 100644 index 00000000000..75b9f48eb1f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Parser.tpp @@ -0,0 +1,7 @@ +// file : XSCRT/Parser.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp new file mode 100644 index 00000000000..482d5fc77e1 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp @@ -0,0 +1,266 @@ +// file : XSCRT/Traversal.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_TRAVERSAL_HPP +#define XSCRT_TRAVERSAL_HPP + +#include <map> +#include <set> +#include <vector> + +#include "XSCRT/ExtendedTypeInfo.hpp" + +namespace XSCRT +{ + namespace Traversal + { + // + // + // + template<typename B> + class TraverserBase + { + protected: + virtual + ~TraverserBase (); + + //@@ VC6 + public: + virtual void + trampoline (B& n) = 0; + + virtual void + trampoline (B const& n) = 0; + }; + + + // + // + // + template <typename B> + class DispatcherBase + { + public: + virtual + ~DispatcherBase (); + + virtual void + dispatch (B& n); + + virtual void + dispatch (B const& n); + + void + map (TypeId id, TraverserBase<B>& t) + { + //wcerr << "map for " << id.name () << " to " << &t + // << " in " << &traversal_map_ << endl; + + //@@ VC6 + Traversers& traversers = traversal_map_[id]; + traversers.push_back (&t); + } + + public: + typedef + std::vector<TraverserBase<B>*> + Traversers; + + typedef + std::map<TypeId, Traversers> + TraversalMap; + + typedef + typename TraversalMap::const_iterator + Iterator; + + Iterator + begin () const + { + return traversal_map_.begin (); + } + + Iterator + end () const + { + return traversal_map_.end (); + } + + private: + struct TypeInfoComparator + { + bool + operator () (ExtendedTypeInfo const& x, + ExtendedTypeInfo const& y) const + { + return x.type_id () < y.type_id (); + } + }; + + typedef + std::map<ExtendedTypeInfo, unsigned long, TypeInfoComparator> + LevelMap; + + typedef + std::set<ExtendedTypeInfo, TypeInfoComparator> + TypeInfoSet; + + static unsigned long + compute_levels (ExtendedTypeInfo const& ti, + unsigned long cur, + LevelMap& map); + + static void + flatten_tree (ExtendedTypeInfo const& ti, TypeInfoSet& set); + + private: + TraversalMap traversal_map_; + }; + + + // + // + // + template <typename B> + class Dispatcher : public virtual DispatcherBase<B> + { + public: + Dispatcher () + : merge_ (true) + { + } + + void + traverser (DispatcherBase<B>& d) + { + for (typename DispatcherBase<B>::Iterator + i (d.begin ()), end (d.end ()); + i != end; ++i) + { + for (typename DispatcherBase<B>::Traversers::const_iterator + t (i->second.begin ()), end (i->second.end ()); + t != end; ++t) + { + dispatcher_.map (i->first, **t); + } + } + } + + public: + virtual void + dispatch (B& n) + { + merge (); + dispatcher_.dispatch (n); + } + + virtual void + dispatch (B const& n) + { + merge (); + dispatcher_.dispatch (n); + } + + using DispatcherBase<B>::begin; + using DispatcherBase<B>::end; + + private: + void + merge () + { + if (merge_) + { + for (typename DispatcherBase<B>::Iterator + i (begin ()), e (end ()); i != e; ++i) + { + for (typename DispatcherBase<B>::Traversers::const_iterator + t (i->second.begin ()), e (i->second.end ()); t != e; ++t) + { + dispatcher_.map (i->first, **t); + } + } + + merge_ = false; + } + } + + protected: + // DispatcherBase<B>& + // traverser () + // { + // return dispatcher_; + // } + + template <typename X, typename A, typename I> + void + iterate_and_dispatch (I begin, I end, X& x, void (X::*next)(A&), A& a) + { + for (; begin != end;) + { + dispatch (*begin); + + if (++begin != end) (x.*next) (a); + } + } + + private: + bool merge_; + DispatcherBase<B> dispatcher_; + }; + + + + // + // + // + template <typename T, typename B> + struct Traverser : TraverserBase<B>, virtual Dispatcher<B> + { + typedef + T + Type; + + Traverser () + { + map (typeid (Type), *this); + } + + virtual void + traverse (Type&) + { + abort (); + } + + virtual void + traverse (Type const&) + { + abort (); + } + + protected: + virtual void + trampoline (B& n) + { + //wcerr << "trampoline for " << &n << " to type " + // << typeid (Type).name () << endl; + + traverse (dynamic_cast<Type&> (n)); + } + + virtual void + trampoline (B const& n) + { + //wcerr << "trampoline for " << &n << " to type " + // << typeid (Type).name () << endl; + + traverse (dynamic_cast<Type const&> (n)); + } + }; + } +} + +#include <XSCRT/Traversal.ipp> +#include <XSCRT/Traversal.tpp> + +#endif // XSCRT_TRAVERSAL_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.ipp new file mode 100644 index 00000000000..bc2a462334a --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.ipp @@ -0,0 +1,7 @@ +// file : XSCRT/Traversal.ixx +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.tpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.tpp new file mode 100644 index 00000000000..51889c0fb9b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Traversal.tpp @@ -0,0 +1,195 @@ +// file : XSCRT/Traversal.txx +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ + namespace Traversal + { + // TraverserBase + // + // + + template<typename B> + TraverserBase<B>:: + ~TraverserBase () + { + } + + // DispatcherBase + // + // + + template <typename B> + DispatcherBase<B>:: + ~DispatcherBase () + { + } + + //@@ merge after dropping VC6 + // + // + template <typename B> + void DispatcherBase<B>:: + dispatch (B& n) + { + LevelMap levels; + + //@@ VC6 + ExtendedTypeInfo const& ti = extended_type_info (n); + + unsigned long max = compute_levels (ti, 0, levels); + + + //wcerr << "starting dispatch process for " + // << typeid (n).name () << " with " + // << max << " levels" << endl; + + for (unsigned long l = 0; l < max + 1; ++l) + { + TypeInfoSet dispatched; + + for (typename LevelMap::const_iterator + i (levels.begin ()), e (levels.end ()); + i != e; ++i) + { + if (i->second == l) + { + typename TraversalMap::const_iterator v ( + traversal_map_.find (i->first.type_id ())); + + if (v != traversal_map_.end ()) + { + //wcerr << "dispatching traversers for " + // << typeid (n).name () << " as " + // << i->first.type_id ().name () << endl; + + //@@ VC6 + Traversers const& traversers = v->second; + for (typename Traversers::const_iterator + ti (traversers.begin ()), te (traversers.end ()); + ti != te; ++ti) + { + (*ti)->trampoline (n); + } + + flatten_tree (i->first, dispatched); + } + } + } + + // Remove traversed types from the level map. + // + //@@ VC6 + { + for (typename TypeInfoSet::const_iterator i = dispatched.begin (); + i != dispatched.end (); + ++i) + { + levels.erase (*i); + } + } + } + } + + template <typename B> + void DispatcherBase<B>:: + dispatch (B const& n) + { + LevelMap levels; + + //@@ VC6 + ExtendedTypeInfo const& ti = extended_type_info (n); + + unsigned long max = compute_levels (ti, 0, levels); + + + //wcerr << "starting dispatch process for " + // << typeid (n).name () << " with " + // << max << " levels" << endl; + + //wcerr << "using " << &traversal_map_ << " traversal map" << endl; + + for (unsigned long l = 0; l < max + 1; ++l) + { + TypeInfoSet dispatched; + + for (typename LevelMap::const_iterator + i (levels.begin ()), e (levels.end ()); + i != e; ++i) + { + if (i->second == l) + { + typename TraversalMap::const_iterator v ( + traversal_map_.find (i->first.type_id ())); + + if (v != traversal_map_.end ()) + { + //wcerr << "dispatching traversers for " + // << typeid (n).name () << " as " + // << i->first.type_id ().name () << endl; + + //@@ VC6 + Traversers const& traversers = v->second; + for (typename Traversers::const_iterator + ti (traversers.begin ()), te (traversers.end ()); + ti != te; ++ti) + { + (*ti)->trampoline (n); + } + + flatten_tree (i->first, dispatched); + } + } + } + + // Remove traversed types from the level map. + // + //@@ VC6 + { + for (typename TypeInfoSet::const_iterator i = dispatched.begin (); + i != dispatched.end (); + ++i) + { + levels.erase (*i); + } + } + } + } + + template <typename B> + unsigned long DispatcherBase<B>:: + compute_levels (ExtendedTypeInfo const& ti, + unsigned long cur, + LevelMap& map) + { + unsigned long ret = cur; + + if (map.find (ti) == map.end () || map[ti] < cur) map[ti] = cur; + + for (ExtendedTypeInfo::BaseIterator i = ti.begin_base (); + i != ti.end_base (); + i++) + { + unsigned long t = compute_levels (i->type_info (), cur + 1, map); + if (t > ret) ret = t; + } + + return ret; + } + + template <typename B> + void DispatcherBase<B>:: + flatten_tree (ExtendedTypeInfo const& ti, TypeInfoSet& set) + { + set.insert (ti); + + for (ExtendedTypeInfo::BaseIterator i = ti.begin_base (); + i != ti.end_base (); + i++) + { + flatten_tree (i->type_info (), set); + } + } + } +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.hpp new file mode 100644 index 00000000000..6fdd82f6f3e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.hpp @@ -0,0 +1,81 @@ +// file : XSCRT/Writer.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_WRITER_HPP +#define XSCRT_WRITER_HPP + +#include <stack> +#include <string> + +#include "XSCRT/XML.hpp" + +namespace XSCRT +{ + template <typename C> + class Writer + { + public: + Writer (XML::Element<C>& e) + : attr__ (0) + { + push_ (e); + } + + protected: + // This c-tor should never be called. + // + Writer () + { + abort (); + } + + public: + void + push_ (XML::Element<C> const& e) + { + stack_.push (e); + } + + void + pop_ () + { + stack_.pop (); + } + + XML::Element<C>& + top_ () + { + return stack_.top (); + } + + public: + XML::Attribute<C>* + attr_ () + { + return attr__; + } + + void + attr_ (XML::Attribute<C>* a) + { + attr__ = a; + } + + private: + std::stack<XML::Element<C> > stack_; + + XML::Attribute<C>* attr__; + + private: + Writer (Writer const&); + + void + operator= (Writer const&); + }; +} + +#include <XSCRT/Writer.ipp> +#include <XSCRT/Writer.tpp> + +#endif // XSCRT_WRITER_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.ipp new file mode 100644 index 00000000000..caa9fc99235 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.ipp @@ -0,0 +1,7 @@ +// file : XSCRT/Writer.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.tpp b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.tpp new file mode 100644 index 00000000000..8593004687f --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/Writer.tpp @@ -0,0 +1,7 @@ +// file : XSCRT/Writer.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/XML.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.hpp new file mode 100644 index 00000000000..d0fdd30affe --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.hpp @@ -0,0 +1,493 @@ +// file : XSCRT/XML.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + + +#ifndef XSCRT_XML_HPP +#define XSCRT_XML_HPP + +#include <string> + +#include <xercesc/dom/DOM.hpp> +#include <xercesc/util/XMLString.hpp> + +namespace XSCRT +{ + namespace XML + { + //@@ VC6 + // + template <typename C> + std::basic_string<C> + transcode (XMLCh const* s, C*); + + template <typename C> + XMLCh* + transcode (std::basic_string<C> const& s); + + // + // + // + class string + { + public : + template <typename C> + string (std::basic_string<C> const& s) + : s_ (XSCRT::XML::transcode<C> (s)) + { + } + + template <typename C> + string (C const* s) + : s_ (XSCRT::XML::transcode<C> (s)) + { + } + + ~string () + { + delete[] s_; + } + + XMLCh const* + c_str () const + { + return s_; + } + + private : + XMLCh* s_; + }; + + + template <> + inline + std::basic_string<char> + transcode<char> (XMLCh const* s, char*) + { + if (s == 0) return std::basic_string<char> (); + + char* buf = xercesc::XMLString::transcode (s); + + std::basic_string<char> r (buf); + + xercesc::XMLString::release (&buf); + + return r; + } + + template <> + inline + std::basic_string<wchar_t> + transcode<wchar_t> (XMLCh const* s, wchar_t*) + { + if (s == 0) return std::basic_string<wchar_t> (); + + // std::wcerr << s << std::endl; + + std::basic_string<wchar_t> r (xercesc::XMLString::stringLen (s), L'0'); + + for (std::size_t i (0); *s != XMLCh (0); ++s, ++i) + { + r[i] = *s; + } + + return r; + } + + template <> + inline + XMLCh* + transcode (std::basic_string<char> const& s) + { + return xercesc::XMLString::transcode (s.c_str ()); + } + + template <> + inline + XMLCh* + transcode (std::basic_string<wchar_t> const& s) + { + //@@ VC6 + std::size_t l = s.length (); + + //@@ VC6 + XMLCh* r = new XMLCh[l + 1]; + XMLCh* ir = r; + + for (std::size_t i (0); i < l; ++ir, ++i) + { + *ir = static_cast<XMLCh>(s[i]); + //std::wcerr << s[i] << "->" << *ir << std::endl; + } + + *ir = XMLCh (0); + + // std::wcerr << r << std::endl; + + return r; + } + + + template <typename C> + class Element; + + template <typename C> + std::basic_string<C> + ns_prefix (std::basic_string<C> const& ns, Element<C> const& e); + + // Casting helpers, made necessary by the Xerces project's braindead + // avoidance of RTTI. + template <typename DERIVED> struct dom_traits; + + // Specializations for different node types + template <> + struct dom_traits<xercesc::DOMElement *> + { + static const xercesc::DOMNode::NodeType node_type = xercesc::DOMNode::ELEMENT_NODE; + }; + + template <> + struct dom_traits<xercesc::DOMAttr *> + { + static const xercesc::DOMNode::NodeType node_type = xercesc::DOMNode::ATTRIBUTE_NODE; + }; + + template <typename DERIVED_PTR> + DERIVED_PTR dom_cast (xercesc::DOMNode *node) + { + DERIVED_PTR elem = 0; + if ((node != 0) && + (node->getNodeType () == dom_traits<DERIVED_PTR>::node_type)) + { + elem = reinterpret_cast <DERIVED_PTR> (node); + } + return elem; + } + + template <typename C> + class Element + { + typedef std::basic_string<C> string_; + + public: + Element (xercesc::DOMElement const* e) + : e_ (0), + ce_ (e), + name_ (transcode<C> (e->getLocalName (), 0)), + namespace__ (transcode<C> (e->getNamespaceURI (), 0)) + { + } + + Element (xercesc::DOMElement* e) + : e_ (e), + ce_ (e), + name_ (transcode<C> (e->getLocalName (), 0)), + namespace__ (transcode<C> (e->getNamespaceURI (), 0)) + { + } + + Element (string_ const& name, Element& parent) + : e_ (0), + ce_ (0), + name_ (name) + { + xercesc::DOMDocument* doc ( + parent.dom_element ()->getOwnerDocument ()); + + e_ = doc->createElement (string (name).c_str ()); + + parent.dom_element ()->appendChild (e_); + + ce_ = e_; + } + + Element (string_ const& name, string_ const& ns, Element& parent) + : e_ (0), + ce_ (0), + name_ (name), + namespace__ (ns) + { + string_ prefix (ns_prefix (ns, parent)); + + xercesc::DOMDocument* doc ( + parent.dom_element ()->getOwnerDocument ()); + + e_ = doc->createElementNS ( + string (ns).c_str (), + string (prefix.empty () + ? name + : prefix + string_ (1, ':') + name).c_str ()); + + parent.dom_element ()->appendChild (e_); + + ce_ = e_; + } + + public: + string_ + name () const + { + return name_; + } + + string_ + namespace_ () const + { + return namespace__; + } + + public: + Element<C> + parent () const + { + return dom_cast <xercesc::DOMElement const*>(ce_->getParentNode ()); + } + + public: + string_ + value () const + { + return XML::transcode<C> (dom_element ()->getTextContent (), 0); + } + + void + value (string_ const& v) + { + xercesc::DOMText* text ( + dom_element ()->getOwnerDocument ()->createTextNode( + string (v).c_str ())); + + dom_element ()->appendChild (text); + } + + public: + string_ + operator[] (string_ const& s) const + { + //@@ VC6 + XMLCh const* value = ce_->getAttribute (string (s).c_str ()); + + return transcode<C> (value, 0); + } + + public: + xercesc::DOMElement const* + dom_element () const + { + return ce_; + } + + xercesc::DOMElement* + dom_element () + { + return e_; + } + + private: + xercesc::DOMElement* e_; + xercesc::DOMElement const* ce_; + + string_ name_; + string_ namespace__; + }; + + + template <typename C> + class Attribute + { + typedef std::basic_string<C> string_; + + public: + Attribute (xercesc::DOMAttr const* a) + : a_ (0), + ca_ (a), + name_ (transcode<C> (a->getLocalName (), 0)), + value_ (transcode<C> (a->getValue (), 0)) + { + } + + Attribute (xercesc::DOMAttr* a) + : a_ (a), + ca_ (a), + name_ (transcode<C> (a->getLocalName (), 0)), + value_ (transcode<C> (a->getValue (), 0)) + { + } + + Attribute (string_ const& name, + string_ const& v, + Element<C>& parent) + : a_ (0), + ca_ (0), + name_ (name), + value_ () + { + xercesc::DOMDocument* doc ( + parent.dom_element ()->getOwnerDocument ()); + + a_ = doc->createAttribute (string (name).c_str ()); + + value (v); + + parent.dom_element ()->setAttributeNode (a_); + + ca_ = a_; + } + + Attribute (string_ const& name, + string_ const& ns, + string_ const& v, + Element<C>& parent) + : a_ (0), + ca_ (0), + name_ (name), + value_ () + { + string_ prefix (ns_prefix (ns, parent)); + + xercesc::DOMDocument* doc ( + parent.dom_element ()->getOwnerDocument ()); + + a_ = doc->createAttributeNS ( + string (ns).c_str (), + string (prefix.empty () + ? name + : prefix + string_ (1, ':') + name).c_str ()); + + value (v); + + parent.dom_element ()->setAttributeNodeNS (a_); + + ca_ = a_; + } + + string_ + name () const + { + return name_; + } + + string_ + value () const + { + return value_; + } + + void + value (string_ const& v) + { + value_ = v; + a_->setValue (string (v).c_str ()); + } + + public: + xercesc::DOMAttr const* + dom_attribute () const + { + return ca_; + } + + xercesc::DOMAttr* + dom_attribute () + { + return a_; + } + + private: + + private: + xercesc::DOMAttr* a_; + xercesc::DOMAttr const* ca_; + + string_ name_; + string_ value_; + }; + + template <typename C> + std::basic_string<C> + prefix (std::basic_string<C> const& n) + { + std::size_t i (0); + while (i < n.length () && n[i] != ':') ++i; + + //std::wcerr << "prefix " << n << " " + // << std::wstring (n, i == n.length () ? i : 0, i) << std::endl; + + return std::basic_string<C> (n, i == n.length () ? i : 0, i); + } + + template <typename C> + std::basic_string<C> + uq_name (std::basic_string<C> const& n) + { + std::size_t i (0); + while (i < n.length () && n[i] != ':') ++i; + + return std::basic_string<C> (n.c_str () + (i == n.length () ? 0 : i + 1)); + } + + template <typename C> + std::basic_string<C> + ns_name (Element<C> const& e, std::basic_string<C> const& n) + { + std::basic_string<C> wp (prefix (n)); + + //@@ VC6 + XMLCh const* xns = e.dom_element ()->lookupNamespaceURI ( + wp.empty () ? 0 : string (wp).c_str ()); + + + std::basic_string<C> ns ( + xns ? transcode<C> (xns, 0) : std::basic_string<C> ()); + + return ns; + + } + + template <typename C> + std::basic_string<C> + fq_name (Element<C> const& e, std::basic_string<C> const& n) + { + std::basic_string<C> ns (ns_name (e, n)); + std::basic_string<C> un (uq_name (n)); + + return ns.empty () ? un : (ns + C ('#') + un); + } + + class no_prefix {}; + + template <typename C> + std::basic_string<C> + ns_prefix (std::basic_string<C> const& ns, Element<C> const& e) + { + string xns (ns); + +#if defined(XERCES_VERSION_MAJOR) && XERCES_VERSION_MAJOR > 2 + XMLCh const* p (e.dom_element ()->lookupPrefix (xns.c_str ())); +#else + XMLCh const* p (e.dom_element ()->lookupNamespacePrefix (xns.c_str (), false)); +#endif + + if (p == 0) + { + bool r (e.dom_element ()->isDefaultNamespace (xns.c_str ())); + + if (r) + { + return std::basic_string<C> (); + } + else + { + throw no_prefix (); + } + } + + return transcode<C> (p, 0); + } + } +} + +#include "XSCRT/XML.ipp" +#include "XSCRT/XML.tpp" + +#endif // XSCRT_XML_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/XML.ipp b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.ipp new file mode 100644 index 00000000000..4a7b83efd1c --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.ipp @@ -0,0 +1,7 @@ +// file : XSCRT/XML.ipp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/XML.tpp b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.tpp new file mode 100644 index 00000000000..63023a05d28 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/XML.tpp @@ -0,0 +1,7 @@ +// file : XSCRT/XML.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace XSCRT +{ +} diff --git a/modules/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp b/modules/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp new file mode 100644 index 00000000000..95575267eee --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp @@ -0,0 +1,588 @@ +// file : XSCRT/XMLSchema.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef XSCRT_XMLSCHEMA_HPP +#define XSCRT_XMLSCHEMA_HPP + +#include <string> +// #include <iostream> //@@ tmp + +#include "XSCRT/Elements.hpp" + +namespace XMLSchema +{ + typedef XSCRT::FundamentalType<signed char> byte; + typedef XSCRT::FundamentalType<unsigned char> unsignedByte; + + typedef XSCRT::FundamentalType<short> short_; + typedef XSCRT::FundamentalType<unsigned short> unsignedShort; + + typedef XSCRT::FundamentalType<int> int_; + typedef XSCRT::FundamentalType<unsigned int> unsignedInt; + + typedef XSCRT::FundamentalType<long long> long_; + typedef XSCRT::FundamentalType<unsigned long long> unsignedLong; + + //@@ It would be nice to use some arbitrary-length integer class. + // + typedef long_ decimal; + typedef decimal integer; + typedef integer nonPositiveInteger; + typedef integer nonNegativeInteger; + typedef nonNegativeInteger positiveInteger; + typedef nonPositiveInteger negativeInteger; + + + typedef XSCRT::FundamentalType<bool> boolean; + + typedef XSCRT::FundamentalType<float> float_; + typedef XSCRT::FundamentalType<double> double_; + + // Just to make GCC 3.3 and other broken compilers shutup. + // + using std::basic_string; + + + template <typename C> + class string : public XSCRT::Type, public basic_string<C> + { + protected: + typedef basic_string<C> Base__ ; + + public: + + //@@ VC6 does not inject XSCRT::Type into the scope so I have + // to qualify it all the time. + // + + string () + { + } + + string (XSCRT::XML::Element<C> const& e) + : Base__ (e.value ()) + { + } + + string (XSCRT::XML::Attribute<C> const& a) + : Base__ (a.value ()) + { + } + + string (Base__ const& x) + : Base__ (x) + { + } + + string& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class normalizedString : public string<C> + { + protected: + typedef typename string<C>::Base__ Base__; + + public: + normalizedString () + { + } + + normalizedString (XSCRT::XML::Element<C> const& e) + : string<C> (e) + { + } + + normalizedString (XSCRT::XML::Attribute<C> const& a) + : string<C> (a) + { + } + + normalizedString (Base__ const& x) + : string<C> (x) + { + } + + normalizedString& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class token : public normalizedString<C> + { + protected: + typedef typename normalizedString<C>::Base__ Base__; + + public: + token () + { + } + + token (XSCRT::XML::Element<C> const& e) + : normalizedString<C> (e) + { + } + + token (XSCRT::XML::Attribute<C> const& a) + : normalizedString<C> (a) + { + } + + token (Base__ const& x) + : normalizedString<C> (x) + { + } + + token& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class NMTOKEN : public token<C> + { + protected: + typedef typename token<C>::Base__ Base__; + + public: + NMTOKEN () + { + } + + NMTOKEN (XSCRT::XML::Element<C> const& e) + : token<C> (e) + { + } + + NMTOKEN (XSCRT::XML::Attribute<C> const& a) + : token<C> (a) + { + } + + NMTOKEN (Base__ const& x) + : token<C> (x) + { + } + + NMTOKEN& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + class Name: public token<C> + { + protected: + typedef typename token<C>::Base__ Base__; + + public: + Name() + { + } + + Name(XSCRT::XML::Element<C> const& e) + : token<C> (e) + { + } + + Name(XSCRT::XML::Attribute<C> const& a) + : token<C> (a) + { + } + + Name(Base__ const& x) + : token<C> (x) + { + } + + Name& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + + template <typename C> + class NCName: public Name<C> + { + protected: + typedef typename Name<C>::Base__ Base__; + + public: + NCName() + { + } + + NCName(XSCRT::XML::Element<C> const& e) + : Name<C> (e) + { + } + + NCName(XSCRT::XML::Attribute<C> const& a) + : Name<C> (a) + { + } + + NCName(Base__ const& x) + : Name<C> (x) + { + } + + NCName& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + class QName: public Name<C> + { + protected: + typedef typename Name<C>::Base__ Base__; + + public: + QName() + { + } + + QName(XSCRT::XML::Element<C> const& e) + : Name<C> (e) + { + } + + QName(XSCRT::XML::Attribute<C> const& a) + : Name<C> (a) + { + } + + QName(Base__ const& x) + : Name<C> (x) + { + } + + QName& + operator= (Base__ const& x) + { + static_cast<Base__&> (*this) = x; + return *this; + } + }; + + template <typename C> + struct IdentityProvider : XSCRT::IdentityProvider + { + IdentityProvider (NCName<C> const& id) + : id_ (id) + { + } + + virtual bool + before (XSCRT::IdentityProvider const& y) const + { + return id_ < dynamic_cast<IdentityProvider const&> (y).id_; + } + + private: + NCName<C> const& id_; + + private: + IdentityProvider (IdentityProvider const&); + + IdentityProvider& + operator= (IdentityProvider const&); + }; + + + template <typename C> + class ID : public NCName<C> + { + protected: + typedef typename NCName<C>::Base__ Base__; + + public: + ~ID() + { + unregister_id (); + } + + ID () + : id_provider_ (*this) + { + } + + ID (XSCRT::XML::Element<C> const& e) + : NCName<C> (e), id_provider_ (*this) + { + } + + ID (XSCRT::XML::Attribute<C> const& a) + : NCName<C> (a), id_provider_ (*this) + { + } + + ID (ID const& x) + : NCName<C> (x), id_provider_ (*this) + { + } + + ID (Base__ const& x) + : NCName<C> (x), id_provider_ (*this) + { + } + + ID& + operator= (Base__ const& x) + { + unregister_id (); + + static_cast<NCName<C>&>(*this) = x; + + register_id (); + + return *this; + } + + ID& + operator= (ID const& x) + { + unregister_id (); + + static_cast<NCName<C>&>(*this) = static_cast<NCName<C> const&>(x); + + register_id (); + + return *this; + } + + public: + using NCName<C>::container; + + virtual void + container (XSCRT::Type* c) + { + unregister_id (); + + NCName<C>::container (c); + + register_id (); + } + + private: + using NCName<C>::empty; + using NCName<C>::root; + + void + register_id () + { + if (container () != this && !empty ()) + { + //std::wcerr << "registering " << container () + // << " as '" << *this + // << "' on " << container () << std::endl; + container ()->register_id (id_provider_, container ()); + } + } + + void + unregister_id () + { + if (container () != this && !empty ()) + { + //std::wcerr << "un-registering " << container () + // << " as '" << *this + // << "' on " << container () << std::endl; + container ()->unregister_id (id_provider_); + } + } + + private: + IdentityProvider<C> id_provider_; + }; + + struct IDREF_Base : public XSCRT::Type + { + virtual XSCRT::Type* + get () const = 0; + }; + + template <typename C> + class IDREF : public IDREF_Base + { + public: + IDREF () + : id_provider_ (id_) + { + } + + IDREF (XSCRT::XML::Element<C> const& e) + : id_ (e), id_provider_ (id_) + { + } + + IDREF (XSCRT::XML::Attribute<C> const& a) + : id_ (a), id_provider_ (id_) + { + } + + IDREF (IDREF const& x) + : id_ (x.id_), id_provider_ (id_) + { + } + + IDREF (basic_string<C> const& id) + : id_ (id), id_provider_ (id_) + { + } + + IDREF& + operator= (IDREF const& x) + { + id_ = x.id_; + return *this; + } + + IDREF& + operator= (basic_string<C> const& x) + { + id_ = x; + return *this; + } + + public: + XSCRT::Type* + operator-> () const + { + return get (); + } + + XSCRT::Type& + operator* () const + { + return *(get ()); + } + + virtual XSCRT::Type* + get () const + { + if (!id_.empty () && container () != this) + { + return root ()->lookup_id (id_provider_); + } + else + { + return 0; + } + } + + // conversion to bool + // + typedef XSCRT::Type* (IDREF::*bool_convertable)() const; + + operator bool_convertable () const + { + return get () ? &IDREF::operator-> : 0; + } + + private: + NCName<C> id_; + IdentityProvider<C> id_provider_; + }; +} + +// Traversal +// +// + +#include "XSCRT/Traversal.hpp" + +namespace XMLSchema +{ + namespace Traversal + { + template <typename T> + struct Traverser : XSCRT::Traversal::Traverser<T, XSCRT::Type>, + XSCRT::Traversal::Traverser<IDREF_Base, XSCRT::Type> + { + typedef + T + Type; + + virtual void + traverse (XMLSchema::IDREF_Base& r) + { + if (r.get ()) dispatch (*(r.get ())); + } + }; + + typedef Traverser<byte> byte; + typedef Traverser<unsignedByte> unsignedByte; + + typedef Traverser<short_> short_; + typedef Traverser<unsignedShort> unsignedShort; + + typedef Traverser<int_> int_; + typedef Traverser<unsignedInt> unsignedInt; + + typedef Traverser<long_> long_; + typedef Traverser<unsignedLong> unsignedLong; + + typedef Traverser<boolean> boolean; + + typedef Traverser<float_> float_; + typedef Traverser<double_> double_; + + template <typename C> + struct string : Traverser<XMLSchema::string<C> > + { + }; + + template <typename C> + struct ID : Traverser<XMLSchema::ID<C> > + { + }; + } +} + + +// ExtendedTypeInfo for XML Schema types +// +// + +#include "XSCRT/ExtendedTypeInfo.hpp" + +namespace XMLSchema +{ + template <typename C> + struct TypeInfoInitializer + { + TypeInfoInitializer (XSCRT::ExtendedTypeInfoMap&); + }; +} + +#include "XSCRT/XMLSchema.ipp" +#include "XSCRT/XMLSchema.tpp" + +#endif // XSCRT_XMLSCHEMA_HPP diff --git a/modules/CIAO/tools/Config_Handlers/XSC_XML_Handlers_Export.h b/modules/CIAO/tools/Config_Handlers/XSC_XML_Handlers_Export.h new file mode 100644 index 00000000000..82272eb6c05 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/XSC_XML_Handlers_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl XSC_XML_Handlers +// ------------------------------ +#ifndef XSC_XML_HANDLERS_EXPORT_H +#define XSC_XML_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (XSC_XML_HANDLERS_HAS_DLL) +# define XSC_XML_HANDLERS_HAS_DLL 1 +#endif /* ! XSC_XML_HANDLERS_HAS_DLL */ + +#if defined (XSC_XML_HANDLERS_HAS_DLL) && (XSC_XML_HANDLERS_HAS_DLL == 1) +# if defined (XSC_XML_HANDLERS_BUILD_DLL) +# define XSC_XML_Handlers_Export ACE_Proper_Export_Flag +# define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* XSC_XML_HANDLERS_BUILD_DLL */ +# define XSC_XML_Handlers_Export ACE_Proper_Import_Flag +# define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* XSC_XML_HANDLERS_BUILD_DLL */ +#else /* XSC_XML_HANDLERS_HAS_DLL == 1 */ +# define XSC_XML_Handlers_Export +# define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T) +# define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* XSC_XML_HANDLERS_HAS_DLL == 1 */ + +// Set XSC_XML_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (XSC_XML_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define XSC_XML_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define XSC_XML_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !XSC_XML_HANDLERS_NTRACE */ + +#if (XSC_XML_HANDLERS_NTRACE == 1) +# define XSC_XML_HANDLERS_TRACE(X) +#else /* (XSC_XML_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define XSC_XML_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (XSC_XML_HANDLERS_NTRACE == 1) */ + +#endif /* XSC_XML_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/Config_Handlers/ccd.cpp b/modules/CIAO/tools/Config_Handlers/ccd.cpp new file mode 100644 index 00000000000..8ed4163970b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ccd.cpp @@ -0,0 +1,1502 @@ +/* $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 "ccd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // ComponentInterfaceDescription + // + + ComponentInterfaceDescription:: + ComponentInterfaceDescription () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ComponentInterfaceDescription:: + ComponentInterfaceDescription (ComponentInterfaceDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + specificType_ (s.specificType_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.specificType_) : 0), + supportedType_ (s.supportedType_), + idlFile_ (s.idlFile_), + configProperty_ (s.configProperty_), + port_ (s.port_), + property_ (s.property_), + infoProperty_ (s.infoProperty_), + contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.contentLocation_) : 0), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (specificType_.get ()) specificType_->container (this); + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ComponentInterfaceDescription& ComponentInterfaceDescription:: + operator= (ComponentInterfaceDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.specificType_.get ()) + specificType (*(s.specificType_)); + else + specificType_.reset (0); + + supportedType_ = s.supportedType_; + + idlFile_ = s.idlFile_; + + configProperty_ = s.configProperty_; + + port_ = s.port_; + + property_ = s.property_; + + infoProperty_ = s.infoProperty_; + + if (s.contentLocation_.get ()) + contentLocation (*(s.contentLocation_)); + else + contentLocation_.reset (0); + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ComponentInterfaceDescription + // + bool ComponentInterfaceDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentInterfaceDescription:: + label () const + { + return *label_; + } + + void ComponentInterfaceDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ComponentInterfaceDescription + // + bool ComponentInterfaceDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentInterfaceDescription:: + UUID () const + { + return *UUID_; + } + + void ComponentInterfaceDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ComponentInterfaceDescription + // + bool ComponentInterfaceDescription:: + specificType_p () const + { + return specificType_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentInterfaceDescription:: + specificType () const + { + return *specificType_; + } + + void ComponentInterfaceDescription:: + 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); + } + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::supportedType_iterator ComponentInterfaceDescription:: + begin_supportedType () + { + return supportedType_.begin (); + } + + ComponentInterfaceDescription::supportedType_iterator ComponentInterfaceDescription:: + end_supportedType () + { + return supportedType_.end (); + } + + ComponentInterfaceDescription::supportedType_const_iterator ComponentInterfaceDescription:: + begin_supportedType () const + { + return supportedType_.begin (); + } + + ComponentInterfaceDescription::supportedType_const_iterator ComponentInterfaceDescription:: + end_supportedType () const + { + return supportedType_.end (); + } + + void ComponentInterfaceDescription:: + add_supportedType (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + supportedType_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_supportedType(void) const + { + return supportedType_.size (); + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::idlFile_iterator ComponentInterfaceDescription:: + begin_idlFile () + { + return idlFile_.begin (); + } + + ComponentInterfaceDescription::idlFile_iterator ComponentInterfaceDescription:: + end_idlFile () + { + return idlFile_.end (); + } + + ComponentInterfaceDescription::idlFile_const_iterator ComponentInterfaceDescription:: + begin_idlFile () const + { + return idlFile_.begin (); + } + + ComponentInterfaceDescription::idlFile_const_iterator ComponentInterfaceDescription:: + end_idlFile () const + { + return idlFile_.end (); + } + + void ComponentInterfaceDescription:: + add_idlFile (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + idlFile_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_idlFile(void) const + { + return idlFile_.size (); + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::configProperty_iterator ComponentInterfaceDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + ComponentInterfaceDescription::configProperty_iterator ComponentInterfaceDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + ComponentInterfaceDescription::configProperty_const_iterator ComponentInterfaceDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + ComponentInterfaceDescription::configProperty_const_iterator ComponentInterfaceDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void ComponentInterfaceDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::port_iterator ComponentInterfaceDescription:: + begin_port () + { + return port_.begin (); + } + + ComponentInterfaceDescription::port_iterator ComponentInterfaceDescription:: + end_port () + { + return port_.end (); + } + + ComponentInterfaceDescription::port_const_iterator ComponentInterfaceDescription:: + begin_port () const + { + return port_.begin (); + } + + ComponentInterfaceDescription::port_const_iterator ComponentInterfaceDescription:: + end_port () const + { + return port_.end (); + } + + void ComponentInterfaceDescription:: + add_port (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > const& e) + { + port_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_port(void) const + { + return port_.size (); + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::property_iterator ComponentInterfaceDescription:: + begin_property () + { + return property_.begin (); + } + + ComponentInterfaceDescription::property_iterator ComponentInterfaceDescription:: + end_property () + { + return property_.end (); + } + + ComponentInterfaceDescription::property_const_iterator ComponentInterfaceDescription:: + begin_property () const + { + return property_.begin (); + } + + ComponentInterfaceDescription::property_const_iterator ComponentInterfaceDescription:: + end_property () const + { + return property_.end (); + } + + void ComponentInterfaceDescription:: + add_property (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > const& e) + { + property_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_property(void) const + { + return property_.size (); + } + + // ComponentInterfaceDescription + // + ComponentInterfaceDescription::infoProperty_iterator ComponentInterfaceDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ComponentInterfaceDescription::infoProperty_iterator ComponentInterfaceDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ComponentInterfaceDescription::infoProperty_const_iterator ComponentInterfaceDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ComponentInterfaceDescription::infoProperty_const_iterator ComponentInterfaceDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ComponentInterfaceDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ComponentInterfaceDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ComponentInterfaceDescription + // + bool ComponentInterfaceDescription:: + contentLocation_p () const + { + return contentLocation_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentInterfaceDescription:: + contentLocation () const + { + return *contentLocation_; + } + + void ComponentInterfaceDescription:: + contentLocation (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (contentLocation_.get ()) + { + *contentLocation_ = e; + } + + else + { + contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + contentLocation_->container (this); + } + } + + // ComponentInterfaceDescription + // + bool ComponentInterfaceDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentInterfaceDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ComponentInterfaceDescription:: + href () + { + return *href_; + } + + void ComponentInterfaceDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // ComponentInterfaceDescription + // + + ComponentInterfaceDescription:: + ComponentInterfaceDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("specificType")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + specificType (t); + } + + else if (n == ACE_TEXT("supportedType")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_supportedType (t); + } + + else if (n == ACE_TEXT("idlFile")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_idlFile (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("port")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ComponentPortDescription (e)); + add_port (t); + } + + else if (n == ACE_TEXT("property")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ComponentPropertyDescription (e)); + add_property (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (t); + } + + else if (n == ACE_TEXT("contentLocation")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + contentLocation (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (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 ComponentInterfaceDescriptionTypeInfoInitializer + { + ComponentInterfaceDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ComponentInterfaceDescription)); + ::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)); + } + }; + + ComponentInterfaceDescriptionTypeInfoInitializer ComponentInterfaceDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // ComponentInterfaceDescription + // + // + + void ComponentInterfaceDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + idlFile (o); + configProperty (o); + port (o); + property (o); + infoProperty (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentInterfaceDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + idlFile (o); + configProperty (o); + port (o); + property (o); + infoProperty (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentInterfaceDescription:: + pre (Type&) + { + } + + void ComponentInterfaceDescription:: + pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ComponentInterfaceDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ComponentInterfaceDescription:: + label_none (Type&) + { + } + + void ComponentInterfaceDescription:: + label_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ComponentInterfaceDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ComponentInterfaceDescription:: + UUID_none (Type&) + { + } + + void ComponentInterfaceDescription:: + UUID_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + specificType (Type& o) + { + dispatch (o.specificType ()); + } + + void ComponentInterfaceDescription:: + specificType (Type const& o) + { + dispatch (o.specificType ()); + } + + void ComponentInterfaceDescription:: + specificType_none (Type&) + { + } + + void ComponentInterfaceDescription:: + specificType_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + supportedType (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + supportedType (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + supportedType_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + supportedType_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + supportedType_next (Type&) + { + } + + void ComponentInterfaceDescription:: + supportedType_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + supportedType_post (Type&) + { + } + + void ComponentInterfaceDescription:: + supportedType_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + supportedType_none (Type&) + { + } + + void ComponentInterfaceDescription:: + supportedType_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + idlFile (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::idlFile_iterator b (o.begin_idlFile()), e (o.end_idlFile()); + + if (b != e) + { + idlFile_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) idlFile_next (o); + } + + idlFile_post (o); + } + + else idlFile_none (o); + } + + void ComponentInterfaceDescription:: + idlFile (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::idlFile_const_iterator b (o.begin_idlFile()), e (o.end_idlFile()); + + if (b != e) + { + idlFile_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) idlFile_next (o); + } + + idlFile_post (o); + } + + else idlFile_none (o); + } + + void ComponentInterfaceDescription:: + idlFile_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + idlFile_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + idlFile_next (Type&) + { + } + + void ComponentInterfaceDescription:: + idlFile_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + idlFile_post (Type&) + { + } + + void ComponentInterfaceDescription:: + idlFile_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + idlFile_none (Type&) + { + } + + void ComponentInterfaceDescription:: + idlFile_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + configProperty_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + configProperty_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + configProperty_next (Type&) + { + } + + void ComponentInterfaceDescription:: + configProperty_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + configProperty_post (Type&) + { + } + + void ComponentInterfaceDescription:: + configProperty_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + configProperty_none (Type&) + { + } + + void ComponentInterfaceDescription:: + configProperty_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + port (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::port_iterator b (o.begin_port()), e (o.end_port()); + + if (b != e) + { + port_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) port_next (o); + } + + port_post (o); + } + + else port_none (o); + } + + void ComponentInterfaceDescription:: + port (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::port_const_iterator b (o.begin_port()), e (o.end_port()); + + if (b != e) + { + port_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) port_next (o); + } + + port_post (o); + } + + else port_none (o); + } + + void ComponentInterfaceDescription:: + port_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + port_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + port_next (Type&) + { + } + + void ComponentInterfaceDescription:: + port_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + port_post (Type&) + { + } + + void ComponentInterfaceDescription:: + port_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + port_none (Type&) + { + } + + void ComponentInterfaceDescription:: + port_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::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 ComponentInterfaceDescription:: + property_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + property_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + property_next (Type&) + { + } + + void ComponentInterfaceDescription:: + property_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + property_post (Type&) + { + } + + void ComponentInterfaceDescription:: + property_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + property_none (Type&) + { + } + + void ComponentInterfaceDescription:: + property_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentInterfaceDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentInterfaceDescription:: + infoProperty_pre (Type&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_pre (Type const&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_next (Type&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_next (Type const&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_post (Type&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_post (Type const&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_none (Type&) + { + } + + void ComponentInterfaceDescription:: + infoProperty_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + contentLocation (Type& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentInterfaceDescription:: + contentLocation (Type const& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentInterfaceDescription:: + contentLocation_none (Type&) + { + } + + void ComponentInterfaceDescription:: + contentLocation_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ComponentInterfaceDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ComponentInterfaceDescription:: + href_none (Type&) + { + } + + void ComponentInterfaceDescription:: + href_none (Type const&) + { + } + + void ComponentInterfaceDescription:: + post (Type&) + { + } + + void ComponentInterfaceDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // ComponentInterfaceDescription + // + // + + ComponentInterfaceDescription:: + ComponentInterfaceDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentInterfaceDescription:: + ComponentInterfaceDescription () + { + } + + void ComponentInterfaceDescription:: + traverse (Type const& o) + { + Traversal::ComponentInterfaceDescription::traverse (o); + } + + void ComponentInterfaceDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ComponentInterfaceDescription::label (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ComponentInterfaceDescription::UUID (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + specificType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("specificType"), top_ ())); + Traversal::ComponentInterfaceDescription::specificType (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("supportedType"), top_ ())); + } + + void ComponentInterfaceDescription:: + supportedType_next (Type const& o) + { + supportedType_post (o); + supportedType_pre (o); + } + + void ComponentInterfaceDescription:: + supportedType_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + idlFile_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("idlFile"), top_ ())); + } + + void ComponentInterfaceDescription:: + idlFile_next (Type const& o) + { + idlFile_post (o); + idlFile_pre (o); + } + + void ComponentInterfaceDescription:: + idlFile_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void ComponentInterfaceDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void ComponentInterfaceDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + port_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("port"), top_ ())); + } + + void ComponentInterfaceDescription:: + port_next (Type const& o) + { + port_post (o); + port_pre (o); + } + + void ComponentInterfaceDescription:: + port_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("property"), top_ ())); + } + + void ComponentInterfaceDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ComponentInterfaceDescription:: + property_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ComponentInterfaceDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ComponentInterfaceDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ComponentInterfaceDescription:: + contentLocation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("contentLocation"), top_ ())); + Traversal::ComponentInterfaceDescription::contentLocation (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ComponentInterfaceDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/ccd.hpp b/modules/CIAO/tools/Config_Handlers/ccd.hpp new file mode 100644 index 00000000000..7bb0245ead6 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/ccd.hpp @@ -0,0 +1,741 @@ +/* $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 + +#ifndef CCD_HPP +#define CCD_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentInterfaceDescription; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export ComponentInterfaceDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentInterfaceDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // specificType + // + public: + bool specificType_p () const; + ::XMLSchema::string< ACE_TCHAR > const& specificType () const; + void specificType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > specificType_; + + // supportedType + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator supportedType_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator supportedType_const_iterator; + supportedType_iterator begin_supportedType (); + supportedType_iterator end_supportedType (); + supportedType_const_iterator begin_supportedType () const; + supportedType_const_iterator end_supportedType () const; + void add_supportedType ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* supportedType_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_supportedType (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > supportedType_; + + // idlFile + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator idlFile_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator idlFile_const_iterator; + idlFile_iterator begin_idlFile (); + idlFile_iterator end_idlFile (); + idlFile_const_iterator begin_idlFile () const; + idlFile_const_iterator end_idlFile () const; + void add_idlFile ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* idlFile_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_idlFile (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > idlFile_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // port + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > >::iterator port_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > >::const_iterator port_const_iterator; + port_iterator begin_port (); + port_iterator end_port (); + port_const_iterator begin_port () const; + port_const_iterator end_port () const; + void add_port ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* port_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_port (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPortDescription, ACE_Null_Mutex > > port_; + + // property + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > >::iterator property_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > >::const_iterator property_const_iterator; + property_iterator begin_property (); + property_iterator end_property (); + property_const_iterator begin_property () const; + property_const_iterator end_property () const; + void add_property ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* property_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_property (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ComponentPropertyDescription, ACE_Null_Mutex > > property_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // contentLocation + // + public: + bool contentLocation_p () const; + ::XMLSchema::string< ACE_TCHAR > const& contentLocation () const; + void contentLocation (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > contentLocation_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ComponentInterfaceDescription (); + + ComponentInterfaceDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentInterfaceDescription (ComponentInterfaceDescription const& s); + + ComponentInterfaceDescription& + operator= (ComponentInterfaceDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export ComponentInterfaceDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentInterfaceDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + specificType (Type&); + + virtual void + specificType (Type const&); + + virtual void + specificType_none (Type&); + + virtual void + specificType_none (Type const&); + + virtual void + supportedType (Type&); + + virtual void + supportedType (Type const&); + + virtual void + supportedType_pre (Type&); + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type&); + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type&); + + virtual void + supportedType_post (Type const&); + + virtual void + supportedType_none (Type&); + + virtual void + supportedType_none (Type const&); + + virtual void + idlFile (Type&); + + virtual void + idlFile (Type const&); + + virtual void + idlFile_pre (Type&); + + virtual void + idlFile_pre (Type const&); + + virtual void + idlFile_next (Type&); + + virtual void + idlFile_next (Type const&); + + virtual void + idlFile_post (Type&); + + virtual void + idlFile_post (Type const&); + + virtual void + idlFile_none (Type&); + + virtual void + idlFile_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + port (Type&); + + virtual void + port (Type const&); + + virtual void + port_pre (Type&); + + virtual void + port_pre (Type const&); + + virtual void + port_next (Type&); + + virtual void + port_next (Type const&); + + virtual void + port_post (Type&); + + virtual void + port_post (Type const&); + + virtual void + port_none (Type&); + + virtual void + port_none (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + property_pre (Type&); + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type&); + + virtual void + property_next (Type const&); + + virtual void + property_post (Type&); + + virtual void + property_post (Type const&); + + virtual void + property_none (Type&); + + virtual void + property_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + contentLocation (Type&); + + virtual void + contentLocation (Type const&); + + virtual void + contentLocation_none (Type&); + + virtual void + contentLocation_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct ComponentInterfaceDescription : Traversal::ComponentInterfaceDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentInterfaceDescription Type; + ComponentInterfaceDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + specificType (Type &o) + { + this->specificType (const_cast <Type const &> (o)); + } + + virtual void + specificType (Type const&); + + virtual void + supportedType_pre (Type &o) + { + this->supportedType_pre (const_cast <Type const &> (o)); + } + + virtual void + supportedType_pre (Type const&); + + virtual void + supportedType_next (Type &o) + { + this->supportedType_next (const_cast <Type const &> (o)); + } + + virtual void + supportedType_next (Type const&); + + virtual void + supportedType_post (Type &o) + { + this->supportedType_post (const_cast <Type const &> (o)); + } + + virtual void + supportedType_post (Type const&); + + virtual void + idlFile_pre (Type &o) + { + this->idlFile_pre (const_cast <Type const &> (o)); + } + + virtual void + idlFile_pre (Type const&); + + virtual void + idlFile_next (Type &o) + { + this->idlFile_next (const_cast <Type const &> (o)); + } + + virtual void + idlFile_next (Type const&); + + virtual void + idlFile_post (Type &o) + { + this->idlFile_post (const_cast <Type const &> (o)); + } + + virtual void + idlFile_post (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + port_pre (Type &o) + { + this->port_pre (const_cast <Type const &> (o)); + } + + virtual void + port_pre (Type const&); + + virtual void + port_next (Type &o) + { + this->port_next (const_cast <Type const &> (o)); + } + + virtual void + port_next (Type const&); + + virtual void + port_post (Type &o) + { + this->port_post (const_cast <Type const &> (o)); + } + + virtual void + port_post (Type const&); + + virtual void + property_pre (Type &o) + { + this->property_pre (const_cast <Type const &> (o)); + } + + virtual void + property_pre (Type const&); + + virtual void + property_next (Type &o) + { + this->property_next (const_cast <Type const &> (o)); + } + + virtual void + property_next (Type const&); + + virtual void + property_post (Type &o) + { + this->property_post (const_cast <Type const &> (o)); + } + + virtual void + property_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + contentLocation (Type &o) + { + this->contentLocation (const_cast <Type const &> (o)); + } + + virtual void + contentLocation (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ComponentInterfaceDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CCD_HPP diff --git a/modules/CIAO/tools/Config_Handlers/cdd.cpp b/modules/CIAO/tools/Config_Handlers/cdd.cpp new file mode 100644 index 00000000000..4dc1a9d9915 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cdd.cpp @@ -0,0 +1,3334 @@ +/* $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 "cdd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // Domain + // + + Domain:: + Domain (::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > const& node__) + : + ::XSCRT::Type (), + node_ (node__), + regulator__ () + { + } + + Domain:: + Domain (Domain const& s) + : + ::XSCRT::Type (), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + node_ (s.node_), + interconnect_ (s.interconnect_), + bridge_ (s.bridge_), + sharedResource_ (s.sharedResource_), + infoProperty_ (s.infoProperty_), + regulator__ () + { + if (UUID_.get ()) UUID_->container (this); + if (label_.get ()) label_->container (this); + } + + Domain& Domain:: + operator= (Domain const& s) + { + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + node_ = s.node_; + + interconnect_ = s.interconnect_; + + bridge_ = s.bridge_; + + sharedResource_ = s.sharedResource_; + + infoProperty_ = s.infoProperty_; + + return *this; + } + + + // Domain + // + bool Domain:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Domain:: + UUID () const + { + return *UUID_; + } + + void Domain:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // Domain + // + bool Domain:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Domain:: + label () const + { + return *label_; + } + + void Domain:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // Domain + // + Domain::node_iterator Domain:: + begin_node () + { + return node_.begin (); + } + + Domain::node_iterator Domain:: + end_node () + { + return node_.end (); + } + + Domain::node_const_iterator Domain:: + begin_node () const + { + return node_.begin (); + } + + Domain::node_const_iterator Domain:: + end_node () const + { + return node_.end (); + } + + void Domain:: + add_node (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > const& e) + { + node_.push_back (e); + } + + size_t Domain:: + count_node(void) const + { + return node_.size (); + } + + // Domain + // + Domain::interconnect_iterator Domain:: + begin_interconnect () + { + return interconnect_.begin (); + } + + Domain::interconnect_iterator Domain:: + end_interconnect () + { + return interconnect_.end (); + } + + Domain::interconnect_const_iterator Domain:: + begin_interconnect () const + { + return interconnect_.begin (); + } + + Domain::interconnect_const_iterator Domain:: + end_interconnect () const + { + return interconnect_.end (); + } + + void Domain:: + add_interconnect (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& e) + { + interconnect_.push_back (e); + } + + size_t Domain:: + count_interconnect(void) const + { + return interconnect_.size (); + } + + // Domain + // + Domain::bridge_iterator Domain:: + begin_bridge () + { + return bridge_.begin (); + } + + Domain::bridge_iterator Domain:: + end_bridge () + { + return bridge_.end (); + } + + Domain::bridge_const_iterator Domain:: + begin_bridge () const + { + return bridge_.begin (); + } + + Domain::bridge_const_iterator Domain:: + end_bridge () const + { + return bridge_.end (); + } + + void Domain:: + add_bridge (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > const& e) + { + bridge_.push_back (e); + } + + size_t Domain:: + count_bridge(void) const + { + return bridge_.size (); + } + + // Domain + // + Domain::sharedResource_iterator Domain:: + begin_sharedResource () + { + return sharedResource_.begin (); + } + + Domain::sharedResource_iterator Domain:: + end_sharedResource () + { + return sharedResource_.end (); + } + + Domain::sharedResource_const_iterator Domain:: + begin_sharedResource () const + { + return sharedResource_.begin (); + } + + Domain::sharedResource_const_iterator Domain:: + end_sharedResource () const + { + return sharedResource_.end (); + } + + void Domain:: + add_sharedResource (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > const& e) + { + sharedResource_.push_back (e); + } + + size_t Domain:: + count_sharedResource(void) const + { + return sharedResource_.size (); + } + + // Domain + // + Domain::infoProperty_iterator Domain:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + Domain::infoProperty_iterator Domain:: + end_infoProperty () + { + return infoProperty_.end (); + } + + Domain::infoProperty_const_iterator Domain:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + Domain::infoProperty_const_iterator Domain:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void Domain:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t Domain:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + + // Bridge + // + + Bridge:: + Bridge (::XMLSchema::string< ACE_TCHAR > const& name__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > > const& connect__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + connect_ (connect__), + regulator__ () + { + name_->container (this); + } + + Bridge:: + Bridge (Bridge const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + connect_ (s.connect_), + resource_ (s.resource_), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + } + + Bridge& Bridge:: + operator= (Bridge const& s) + { + name (*s.name_); + + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + connect_ = s.connect_; + + resource_ = s.resource_; + + return *this; + } + + + // Bridge + // + ::XMLSchema::string< ACE_TCHAR > const& Bridge:: + name () const + { + return *name_; + } + + void Bridge:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Bridge + // + bool Bridge:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Bridge:: + label () const + { + return *label_; + } + + void Bridge:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // Bridge + // + Bridge::connect_iterator Bridge:: + begin_connect () + { + return connect_.begin (); + } + + Bridge::connect_iterator Bridge:: + end_connect () + { + return connect_.end (); + } + + Bridge::connect_const_iterator Bridge:: + begin_connect () const + { + return connect_.begin (); + } + + Bridge::connect_const_iterator Bridge:: + end_connect () const + { + return connect_.end (); + } + + void Bridge:: + add_connect (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& e) + { + connect_.push_back (e); + } + + size_t Bridge:: + count_connect(void) const + { + return connect_.size (); + } + + // Bridge + // + Bridge::resource_iterator Bridge:: + begin_resource () + { + return resource_.begin (); + } + + Bridge::resource_iterator Bridge:: + end_resource () + { + return resource_.end (); + } + + Bridge::resource_const_iterator Bridge:: + begin_resource () const + { + return resource_.begin (); + } + + Bridge::resource_const_iterator Bridge:: + end_resource () const + { + return resource_.end (); + } + + void Bridge:: + add_resource (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& e) + { + resource_.push_back (e); + } + + size_t Bridge:: + count_resource(void) const + { + return resource_.size (); + } + + + // Interconnect + // + + Interconnect:: + Interconnect (::XMLSchema::string< ACE_TCHAR > const& name__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > const& connect__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + connect_ (connect__), + regulator__ () + { + name_->container (this); + } + + Interconnect:: + Interconnect (Interconnect const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + connection_ (s.connection_), + connect_ (s.connect_), + resource_ (s.resource_), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + } + + Interconnect& Interconnect:: + operator= (Interconnect const& s) + { + name (*s.name_); + + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + connection_ = s.connection_; + + connect_ = s.connect_; + + resource_ = s.resource_; + + return *this; + } + + + // Interconnect + // + ::XMLSchema::string< ACE_TCHAR > const& Interconnect:: + name () const + { + return *name_; + } + + void Interconnect:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Interconnect + // + bool Interconnect:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Interconnect:: + label () const + { + return *label_; + } + + void Interconnect:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // Interconnect + // + Interconnect::connection_iterator Interconnect:: + begin_connection () + { + return connection_.begin (); + } + + Interconnect::connection_iterator Interconnect:: + end_connection () + { + return connection_.end (); + } + + Interconnect::connection_const_iterator Interconnect:: + begin_connection () const + { + return connection_.begin (); + } + + Interconnect::connection_const_iterator Interconnect:: + end_connection () const + { + return connection_.end (); + } + + void Interconnect:: + add_connection (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > const& e) + { + connection_.push_back (e); + } + + size_t Interconnect:: + count_connection(void) const + { + return connection_.size (); + } + + // Interconnect + // + Interconnect::connect_iterator Interconnect:: + begin_connect () + { + return connect_.begin (); + } + + Interconnect::connect_iterator Interconnect:: + end_connect () + { + return connect_.end (); + } + + Interconnect::connect_const_iterator Interconnect:: + begin_connect () const + { + return connect_.begin (); + } + + Interconnect::connect_const_iterator Interconnect:: + end_connect () const + { + return connect_.end (); + } + + void Interconnect:: + add_connect (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > const& e) + { + connect_.push_back (e); + } + + size_t Interconnect:: + count_connect(void) const + { + return connect_.size (); + } + + // Interconnect + // + Interconnect::resource_iterator Interconnect:: + begin_resource () + { + return resource_.begin (); + } + + Interconnect::resource_iterator Interconnect:: + end_resource () + { + return resource_.end (); + } + + Interconnect::resource_const_iterator Interconnect:: + begin_resource () const + { + return resource_.begin (); + } + + Interconnect::resource_const_iterator Interconnect:: + end_resource () const + { + return resource_.end (); + } + + void Interconnect:: + add_resource (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& e) + { + resource_.push_back (e); + } + + size_t Interconnect:: + count_resource(void) const + { + return resource_.size (); + } + + + // Node + // + + Node:: + Node (::XMLSchema::string< ACE_TCHAR > const& name__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Node:: + Node (Node const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + connection_ (s.connection_), + sharedResource_ (s.sharedResource_), + resource_ (s.resource_), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + } + + Node& Node:: + operator= (Node const& s) + { + name (*s.name_); + + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + connection_ = s.connection_; + + sharedResource_ = s.sharedResource_; + + resource_ = s.resource_; + + return *this; + } + + + // Node + // + ::XMLSchema::string< ACE_TCHAR > const& Node:: + name () const + { + return *name_; + } + + void Node:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Node + // + bool Node:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& Node:: + label () const + { + return *label_; + } + + void Node:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // Node + // + Node::connection_iterator Node:: + begin_connection () + { + return connection_.begin (); + } + + Node::connection_iterator Node:: + end_connection () + { + return connection_.end (); + } + + Node::connection_const_iterator Node:: + begin_connection () const + { + return connection_.begin (); + } + + Node::connection_const_iterator Node:: + end_connection () const + { + return connection_.end (); + } + + void Node:: + add_connection (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& e) + { + connection_.push_back (e); + } + + size_t Node:: + count_connection(void) const + { + return connection_.size (); + } + + // Node + // + Node::sharedResource_iterator Node:: + begin_sharedResource () + { + return sharedResource_.begin (); + } + + Node::sharedResource_iterator Node:: + end_sharedResource () + { + return sharedResource_.end (); + } + + Node::sharedResource_const_iterator Node:: + begin_sharedResource () const + { + return sharedResource_.begin (); + } + + Node::sharedResource_const_iterator Node:: + end_sharedResource () const + { + return sharedResource_.end (); + } + + void Node:: + add_sharedResource (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > const& e) + { + sharedResource_.push_back (e); + } + + size_t Node:: + count_sharedResource(void) const + { + return sharedResource_.size (); + } + + // Node + // + Node::resource_iterator Node:: + begin_resource () + { + return resource_.begin (); + } + + Node::resource_iterator Node:: + end_resource () + { + return resource_.end (); + } + + Node::resource_const_iterator Node:: + begin_resource () const + { + return resource_.begin (); + } + + Node::resource_const_iterator Node:: + end_resource () const + { + return resource_.end (); + } + + void Node:: + add_resource (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& e) + { + resource_.push_back (e); + } + + size_t Node:: + count_resource(void) const + { + return resource_.size (); + } + + + // SharedResource + // + + SharedResource:: + SharedResource (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::CIAO::Config_Handlers::Node const& node__, + ::CIAO::Config_Handlers::SatisfierProperty const& property__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + node_ (new ::CIAO::Config_Handlers::Node (node__)), + property_ (new ::CIAO::Config_Handlers::SatisfierProperty (property__)), + regulator__ () + { + name_->container (this); + resourceType_->container (this); + node_->container (this); + property_->container (this); + } + + SharedResource:: + SharedResource (SharedResource const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + node_ (new ::CIAO::Config_Handlers::Node (*s.node_)), + property_ (new ::CIAO::Config_Handlers::SatisfierProperty (*s.property_)), + regulator__ () + { + name_->container (this); + resourceType_->container (this); + node_->container (this); + property_->container (this); + } + + SharedResource& SharedResource:: + operator= (SharedResource const& s) + { + name (*s.name_); + + resourceType (*s.resourceType_); + + node (*s.node_); + + property (*s.property_); + + return *this; + } + + + // SharedResource + // + ::XMLSchema::string< ACE_TCHAR > const& SharedResource:: + name () const + { + return *name_; + } + + void SharedResource:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // SharedResource + // + ::XMLSchema::string< ACE_TCHAR > const& SharedResource:: + resourceType () const + { + return *resourceType_; + } + + void SharedResource:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = e; + } + + // SharedResource + // + ::CIAO::Config_Handlers::Node const& SharedResource:: + node () const + { + return *node_; + } + + void SharedResource:: + node (::CIAO::Config_Handlers::Node const& e) + { + *node_ = e; + } + + // SharedResource + // + ::CIAO::Config_Handlers::SatisfierProperty const& SharedResource:: + property () const + { + return *property_; + } + + void SharedResource:: + property (::CIAO::Config_Handlers::SatisfierProperty const& e) + { + *property_ = e; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // Domain + // + + Domain:: + Domain (::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 == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("node")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Node (e)); + add_node (t); + } + + else if (n == ACE_TEXT("interconnect")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Interconnect (e)); + add_interconnect (t); + } + + else if (n == ACE_TEXT("bridge")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Bridge (e)); + add_bridge (t); + } + + else if (n == ACE_TEXT("sharedResource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SharedResource (e)); + add_sharedResource (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (t); + } + + else + { + } + } + } + + // Bridge + // + + Bridge:: + Bridge (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("connect")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Interconnect (e)); + add_connect (t); + } + + else if (n == ACE_TEXT("resource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Resource (e)); + add_resource (t); + } + + else + { + } + } + } + + // Interconnect + // + + Interconnect:: + Interconnect (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("connection")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Bridge (e)); + add_connection (t); + } + + else if (n == ACE_TEXT("connect")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Node (e)); + add_connect (t); + } + + else if (n == ACE_TEXT("resource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Resource (e)); + add_resource (t); + } + + else + { + } + } + } + + // Node + // + + Node:: + Node (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("connection")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Interconnect (e)); + add_connection (t); + } + + else if (n == ACE_TEXT("sharedResource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SharedResource (e)); + add_sharedResource (t); + } + + else if (n == ACE_TEXT("resource")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Resource (e)); + add_resource (t); + } + + else + { + } + } + } + + // SharedResource + // + + SharedResource:: + SharedResource (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("resourceType")) + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == ACE_TEXT("node")) + { + node_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Node > (new ::CIAO::Config_Handlers::Node (e)); + node_->container (this); + } + + else if (n == ACE_TEXT("property")) + { + property_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierProperty > (new ::CIAO::Config_Handlers::SatisfierProperty (e)); + property_->container (this); + } + + 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 DomainTypeInfoInitializer + { + DomainTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::Domain)); + ::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)); + } + }; + + DomainTypeInfoInitializer DomainTypeInfoInitializer_; + + struct BridgeTypeInfoInitializer + { + BridgeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::Bridge)); + ::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)); + } + }; + + BridgeTypeInfoInitializer BridgeTypeInfoInitializer_; + + struct InterconnectTypeInfoInitializer + { + InterconnectTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::Interconnect)); + ::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)); + } + }; + + InterconnectTypeInfoInitializer InterconnectTypeInfoInitializer_; + + struct NodeTypeInfoInitializer + { + NodeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::Node)); + ::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)); + } + }; + + NodeTypeInfoInitializer NodeTypeInfoInitializer_; + + struct SharedResourceTypeInfoInitializer + { + SharedResourceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::SharedResource)); + ::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)); + } + }; + + SharedResourceTypeInfoInitializer SharedResourceTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // Domain + // + // + + void Domain:: + traverse (Type& o) + { + pre (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.label_p ()) label (o); + else label_none (o); + node (o); + interconnect (o); + bridge (o); + sharedResource (o); + infoProperty (o); + post (o); + } + + void Domain:: + traverse (Type const& o) + { + pre (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.label_p ()) label (o); + else label_none (o); + node (o); + interconnect (o); + bridge (o); + sharedResource (o); + infoProperty (o); + post (o); + } + + void Domain:: + pre (Type&) + { + } + + void Domain:: + pre (Type const&) + { + } + + void Domain:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void Domain:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void Domain:: + UUID_none (Type&) + { + } + + void Domain:: + UUID_none (Type const&) + { + } + + void Domain:: + label (Type& o) + { + dispatch (o.label ()); + } + + void Domain:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void Domain:: + label_none (Type&) + { + } + + void Domain:: + label_none (Type const&) + { + } + + void Domain:: + node (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::node_iterator b (o.begin_node()), e (o.end_node()); + + if (b != e) + { + node_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) node_next (o); + } + + node_post (o); + } + } + + void Domain:: + node (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::node_const_iterator b (o.begin_node()), e (o.end_node()); + + if (b != e) + { + node_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) node_next (o); + } + + node_post (o); + } + } + + void Domain:: + node_pre (Type&) + { + } + + void Domain:: + node_pre (Type const&) + { + } + + void Domain:: + node_next (Type&) + { + } + + void Domain:: + node_next (Type const&) + { + } + + void Domain:: + node_post (Type&) + { + } + + void Domain:: + node_post (Type const&) + { + } + + void Domain:: + interconnect (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::interconnect_iterator b (o.begin_interconnect()), e (o.end_interconnect()); + + if (b != e) + { + interconnect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) interconnect_next (o); + } + + interconnect_post (o); + } + + else interconnect_none (o); + } + + void Domain:: + interconnect (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::interconnect_const_iterator b (o.begin_interconnect()), e (o.end_interconnect()); + + if (b != e) + { + interconnect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) interconnect_next (o); + } + + interconnect_post (o); + } + + else interconnect_none (o); + } + + void Domain:: + interconnect_pre (Type&) + { + } + + void Domain:: + interconnect_pre (Type const&) + { + } + + void Domain:: + interconnect_next (Type&) + { + } + + void Domain:: + interconnect_next (Type const&) + { + } + + void Domain:: + interconnect_post (Type&) + { + } + + void Domain:: + interconnect_post (Type const&) + { + } + + void Domain:: + interconnect_none (Type&) + { + } + + void Domain:: + interconnect_none (Type const&) + { + } + + void Domain:: + bridge (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::bridge_iterator b (o.begin_bridge()), e (o.end_bridge()); + + if (b != e) + { + bridge_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) bridge_next (o); + } + + bridge_post (o); + } + + else bridge_none (o); + } + + void Domain:: + bridge (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::bridge_const_iterator b (o.begin_bridge()), e (o.end_bridge()); + + if (b != e) + { + bridge_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) bridge_next (o); + } + + bridge_post (o); + } + + else bridge_none (o); + } + + void Domain:: + bridge_pre (Type&) + { + } + + void Domain:: + bridge_pre (Type const&) + { + } + + void Domain:: + bridge_next (Type&) + { + } + + void Domain:: + bridge_next (Type const&) + { + } + + void Domain:: + bridge_post (Type&) + { + } + + void Domain:: + bridge_post (Type const&) + { + } + + void Domain:: + bridge_none (Type&) + { + } + + void Domain:: + bridge_none (Type const&) + { + } + + void Domain:: + sharedResource (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::sharedResource_iterator b (o.begin_sharedResource()), e (o.end_sharedResource()); + + if (b != e) + { + sharedResource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) sharedResource_next (o); + } + + sharedResource_post (o); + } + + else sharedResource_none (o); + } + + void Domain:: + sharedResource (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::sharedResource_const_iterator b (o.begin_sharedResource()), e (o.end_sharedResource()); + + if (b != e) + { + sharedResource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) sharedResource_next (o); + } + + sharedResource_post (o); + } + + else sharedResource_none (o); + } + + void Domain:: + sharedResource_pre (Type&) + { + } + + void Domain:: + sharedResource_pre (Type const&) + { + } + + void Domain:: + sharedResource_next (Type&) + { + } + + void Domain:: + sharedResource_next (Type const&) + { + } + + void Domain:: + sharedResource_post (Type&) + { + } + + void Domain:: + sharedResource_post (Type const&) + { + } + + void Domain:: + sharedResource_none (Type&) + { + } + + void Domain:: + sharedResource_none (Type const&) + { + } + + void Domain:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void Domain:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Domain::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void Domain:: + infoProperty_pre (Type&) + { + } + + void Domain:: + infoProperty_pre (Type const&) + { + } + + void Domain:: + infoProperty_next (Type&) + { + } + + void Domain:: + infoProperty_next (Type const&) + { + } + + void Domain:: + infoProperty_post (Type&) + { + } + + void Domain:: + infoProperty_post (Type const&) + { + } + + void Domain:: + infoProperty_none (Type&) + { + } + + void Domain:: + infoProperty_none (Type const&) + { + } + + void Domain:: + post (Type&) + { + } + + void Domain:: + post (Type const&) + { + } + + // Bridge + // + // + + void Bridge:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connect (o); + resource (o); + post (o); + } + + void Bridge:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connect (o); + resource (o); + post (o); + } + + void Bridge:: + pre (Type&) + { + } + + void Bridge:: + pre (Type const&) + { + } + + void Bridge:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Bridge:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Bridge:: + label (Type& o) + { + dispatch (o.label ()); + } + + void Bridge:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void Bridge:: + label_none (Type&) + { + } + + void Bridge:: + label_none (Type const&) + { + } + + void Bridge:: + connect (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Bridge::connect_iterator b (o.begin_connect()), e (o.end_connect()); + + if (b != e) + { + connect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connect_next (o); + } + + connect_post (o); + } + } + + void Bridge:: + connect (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Bridge::connect_const_iterator b (o.begin_connect()), e (o.end_connect()); + + if (b != e) + { + connect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connect_next (o); + } + + connect_post (o); + } + } + + void Bridge:: + connect_pre (Type&) + { + } + + void Bridge:: + connect_pre (Type const&) + { + } + + void Bridge:: + connect_next (Type&) + { + } + + void Bridge:: + connect_next (Type const&) + { + } + + void Bridge:: + connect_post (Type&) + { + } + + void Bridge:: + connect_post (Type const&) + { + } + + void Bridge:: + resource (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Bridge::resource_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Bridge:: + resource (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Bridge::resource_const_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Bridge:: + resource_pre (Type&) + { + } + + void Bridge:: + resource_pre (Type const&) + { + } + + void Bridge:: + resource_next (Type&) + { + } + + void Bridge:: + resource_next (Type const&) + { + } + + void Bridge:: + resource_post (Type&) + { + } + + void Bridge:: + resource_post (Type const&) + { + } + + void Bridge:: + resource_none (Type&) + { + } + + void Bridge:: + resource_none (Type const&) + { + } + + void Bridge:: + post (Type&) + { + } + + void Bridge:: + post (Type const&) + { + } + + // Interconnect + // + // + + void Interconnect:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connection (o); + connect (o); + resource (o); + post (o); + } + + void Interconnect:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connection (o); + connect (o); + resource (o); + post (o); + } + + void Interconnect:: + pre (Type&) + { + } + + void Interconnect:: + pre (Type const&) + { + } + + void Interconnect:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Interconnect:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Interconnect:: + label (Type& o) + { + dispatch (o.label ()); + } + + void Interconnect:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void Interconnect:: + label_none (Type&) + { + } + + void Interconnect:: + label_none (Type const&) + { + } + + void Interconnect:: + connection (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::connection_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void Interconnect:: + connection (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::connection_const_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void Interconnect:: + connection_pre (Type&) + { + } + + void Interconnect:: + connection_pre (Type const&) + { + } + + void Interconnect:: + connection_next (Type&) + { + } + + void Interconnect:: + connection_next (Type const&) + { + } + + void Interconnect:: + connection_post (Type&) + { + } + + void Interconnect:: + connection_post (Type const&) + { + } + + void Interconnect:: + connection_none (Type&) + { + } + + void Interconnect:: + connection_none (Type const&) + { + } + + void Interconnect:: + connect (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::connect_iterator b (o.begin_connect()), e (o.end_connect()); + + if (b != e) + { + connect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connect_next (o); + } + + connect_post (o); + } + } + + void Interconnect:: + connect (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::connect_const_iterator b (o.begin_connect()), e (o.end_connect()); + + if (b != e) + { + connect_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connect_next (o); + } + + connect_post (o); + } + } + + void Interconnect:: + connect_pre (Type&) + { + } + + void Interconnect:: + connect_pre (Type const&) + { + } + + void Interconnect:: + connect_next (Type&) + { + } + + void Interconnect:: + connect_next (Type const&) + { + } + + void Interconnect:: + connect_post (Type&) + { + } + + void Interconnect:: + connect_post (Type const&) + { + } + + void Interconnect:: + resource (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::resource_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Interconnect:: + resource (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Interconnect::resource_const_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Interconnect:: + resource_pre (Type&) + { + } + + void Interconnect:: + resource_pre (Type const&) + { + } + + void Interconnect:: + resource_next (Type&) + { + } + + void Interconnect:: + resource_next (Type const&) + { + } + + void Interconnect:: + resource_post (Type&) + { + } + + void Interconnect:: + resource_post (Type const&) + { + } + + void Interconnect:: + resource_none (Type&) + { + } + + void Interconnect:: + resource_none (Type const&) + { + } + + void Interconnect:: + post (Type&) + { + } + + void Interconnect:: + post (Type const&) + { + } + + // Node + // + // + + void Node:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connection (o); + sharedResource (o); + resource (o); + post (o); + } + + void Node:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.label_p ()) label (o); + else label_none (o); + connection (o); + sharedResource (o); + resource (o); + post (o); + } + + void Node:: + pre (Type&) + { + } + + void Node:: + pre (Type const&) + { + } + + void Node:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Node:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Node:: + label (Type& o) + { + dispatch (o.label ()); + } + + void Node:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void Node:: + label_none (Type&) + { + } + + void Node:: + label_none (Type const&) + { + } + + void Node:: + connection (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::connection_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void Node:: + connection (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::connection_const_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void Node:: + connection_pre (Type&) + { + } + + void Node:: + connection_pre (Type const&) + { + } + + void Node:: + connection_next (Type&) + { + } + + void Node:: + connection_next (Type const&) + { + } + + void Node:: + connection_post (Type&) + { + } + + void Node:: + connection_post (Type const&) + { + } + + void Node:: + connection_none (Type&) + { + } + + void Node:: + connection_none (Type const&) + { + } + + void Node:: + sharedResource (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::sharedResource_iterator b (o.begin_sharedResource()), e (o.end_sharedResource()); + + if (b != e) + { + sharedResource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) sharedResource_next (o); + } + + sharedResource_post (o); + } + + else sharedResource_none (o); + } + + void Node:: + sharedResource (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::sharedResource_const_iterator b (o.begin_sharedResource()), e (o.end_sharedResource()); + + if (b != e) + { + sharedResource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) sharedResource_next (o); + } + + sharedResource_post (o); + } + + else sharedResource_none (o); + } + + void Node:: + sharedResource_pre (Type&) + { + } + + void Node:: + sharedResource_pre (Type const&) + { + } + + void Node:: + sharedResource_next (Type&) + { + } + + void Node:: + sharedResource_next (Type const&) + { + } + + void Node:: + sharedResource_post (Type&) + { + } + + void Node:: + sharedResource_post (Type const&) + { + } + + void Node:: + sharedResource_none (Type&) + { + } + + void Node:: + sharedResource_none (Type const&) + { + } + + void Node:: + resource (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::resource_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Node:: + resource (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::Node::resource_const_iterator b (o.begin_resource()), e (o.end_resource()); + + if (b != e) + { + resource_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) resource_next (o); + } + + resource_post (o); + } + + else resource_none (o); + } + + void Node:: + resource_pre (Type&) + { + } + + void Node:: + resource_pre (Type const&) + { + } + + void Node:: + resource_next (Type&) + { + } + + void Node:: + resource_next (Type const&) + { + } + + void Node:: + resource_post (Type&) + { + } + + void Node:: + resource_post (Type const&) + { + } + + void Node:: + resource_none (Type&) + { + } + + void Node:: + resource_none (Type const&) + { + } + + void Node:: + post (Type&) + { + } + + void Node:: + post (Type const&) + { + } + + // SharedResource + // + // + + void SharedResource:: + traverse (Type& o) + { + pre (o); + name (o); + resourceType (o); + node (o); + property (o); + post (o); + } + + void SharedResource:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + node (o); + property (o); + post (o); + } + + void SharedResource:: + pre (Type&) + { + } + + void SharedResource:: + pre (Type const&) + { + } + + void SharedResource:: + name (Type& o) + { + dispatch (o.name ()); + } + + void SharedResource:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void SharedResource:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void SharedResource:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void SharedResource:: + node (Type& o) + { + dispatch (o.node ()); + } + + void SharedResource:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void SharedResource:: + property (Type& o) + { + dispatch (o.property ()); + } + + void SharedResource:: + property (Type const& o) + { + dispatch (o.property ()); + } + + void SharedResource:: + post (Type&) + { + } + + void SharedResource:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // Domain + // + // + + Domain:: + Domain (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Domain:: + Domain () + { + } + + void Domain:: + traverse (Type const& o) + { + Traversal::Domain::traverse (o); + } + + void Domain:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::Domain::UUID (o); + pop_ (); + } + + void Domain:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::Domain::label (o); + pop_ (); + } + + void Domain:: + node_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("node"), top_ ())); + } + + void Domain:: + node_next (Type const& o) + { + node_post (o); + node_pre (o); + } + + void Domain:: + node_post (Type const&) + { + pop_ (); + } + + void Domain:: + interconnect_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("interconnect"), top_ ())); + } + + void Domain:: + interconnect_next (Type const& o) + { + interconnect_post (o); + interconnect_pre (o); + } + + void Domain:: + interconnect_post (Type const&) + { + pop_ (); + } + + void Domain:: + bridge_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("bridge"), top_ ())); + } + + void Domain:: + bridge_next (Type const& o) + { + bridge_post (o); + bridge_pre (o); + } + + void Domain:: + bridge_post (Type const&) + { + pop_ (); + } + + void Domain:: + sharedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("sharedResource"), top_ ())); + } + + void Domain:: + sharedResource_next (Type const& o) + { + sharedResource_post (o); + sharedResource_pre (o); + } + + void Domain:: + sharedResource_post (Type const&) + { + pop_ (); + } + + void Domain:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void Domain:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void Domain:: + infoProperty_post (Type const&) + { + pop_ (); + } + + // Bridge + // + // + + Bridge:: + Bridge (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Bridge:: + Bridge () + { + } + + void Bridge:: + traverse (Type const& o) + { + Traversal::Bridge::traverse (o); + } + + void Bridge:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::Bridge::name (o); + pop_ (); + } + + void Bridge:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::Bridge::label (o); + pop_ (); + } + + void Bridge:: + connect_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connect"), top_ ())); + } + + void Bridge:: + connect_next (Type const& o) + { + connect_post (o); + connect_pre (o); + } + + void Bridge:: + connect_post (Type const&) + { + pop_ (); + } + + void Bridge:: + resource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resource"), top_ ())); + } + + void Bridge:: + resource_next (Type const& o) + { + resource_post (o); + resource_pre (o); + } + + void Bridge:: + resource_post (Type const&) + { + pop_ (); + } + + // Interconnect + // + // + + Interconnect:: + Interconnect (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Interconnect:: + Interconnect () + { + } + + void Interconnect:: + traverse (Type const& o) + { + Traversal::Interconnect::traverse (o); + } + + void Interconnect:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::Interconnect::name (o); + pop_ (); + } + + void Interconnect:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::Interconnect::label (o); + pop_ (); + } + + void Interconnect:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connection"), top_ ())); + } + + void Interconnect:: + connection_next (Type const& o) + { + connection_post (o); + connection_pre (o); + } + + void Interconnect:: + connection_post (Type const&) + { + pop_ (); + } + + void Interconnect:: + connect_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connect"), top_ ())); + } + + void Interconnect:: + connect_next (Type const& o) + { + connect_post (o); + connect_pre (o); + } + + void Interconnect:: + connect_post (Type const&) + { + pop_ (); + } + + void Interconnect:: + resource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resource"), top_ ())); + } + + void Interconnect:: + resource_next (Type const& o) + { + resource_post (o); + resource_pre (o); + } + + void Interconnect:: + resource_post (Type const&) + { + pop_ (); + } + + // Node + // + // + + Node:: + Node (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Node:: + Node () + { + } + + void Node:: + traverse (Type const& o) + { + Traversal::Node::traverse (o); + } + + void Node:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::Node::name (o); + pop_ (); + } + + void Node:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::Node::label (o); + pop_ (); + } + + void Node:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connection"), top_ ())); + } + + void Node:: + connection_next (Type const& o) + { + connection_post (o); + connection_pre (o); + } + + void Node:: + connection_post (Type const&) + { + pop_ (); + } + + void Node:: + sharedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("sharedResource"), top_ ())); + } + + void Node:: + sharedResource_next (Type const& o) + { + sharedResource_post (o); + sharedResource_pre (o); + } + + void Node:: + sharedResource_post (Type const&) + { + pop_ (); + } + + void Node:: + resource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resource"), top_ ())); + } + + void Node:: + resource_next (Type const& o) + { + resource_post (o); + resource_pre (o); + } + + void Node:: + resource_post (Type const&) + { + pop_ (); + } + + // SharedResource + // + // + + SharedResource:: + SharedResource (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SharedResource:: + SharedResource () + { + } + + void SharedResource:: + traverse (Type const& o) + { + Traversal::SharedResource::traverse (o); + } + + void SharedResource:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::SharedResource::name (o); + pop_ (); + } + + void SharedResource:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("resourceType"), top_ ())); + Traversal::SharedResource::resourceType (o); + pop_ (); + } + + void SharedResource:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("node"), top_ ())); + Traversal::SharedResource::node (o); + pop_ (); + } + + void SharedResource:: + property (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("property"), top_ ())); + Traversal::SharedResource::property (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/cdd.hpp b/modules/CIAO/tools/Config_Handlers/cdd.hpp new file mode 100644 index 00000000000..37cf50be3db --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cdd.hpp @@ -0,0 +1,1654 @@ +/* $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 + +#ifndef CDD_HPP +#define CDD_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class Domain; + class Bridge; + class Interconnect; + class Node; + class SharedResource; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export Domain : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Domain, ACE_Null_Mutex > _ptr; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // node + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > >::iterator node_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > >::const_iterator node_const_iterator; + node_iterator begin_node (); + node_iterator end_node (); + node_const_iterator begin_node () const; + node_const_iterator end_node () const; + void add_node ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > const& ); + XSCRT::Type* node_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_node (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > node_; + + // interconnect + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::iterator interconnect_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::const_iterator interconnect_const_iterator; + interconnect_iterator begin_interconnect (); + interconnect_iterator end_interconnect (); + interconnect_const_iterator begin_interconnect () const; + interconnect_const_iterator end_interconnect () const; + void add_interconnect ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& ); + XSCRT::Type* interconnect_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_interconnect (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > > interconnect_; + + // bridge + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > >::iterator bridge_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > >::const_iterator bridge_const_iterator; + bridge_iterator begin_bridge (); + bridge_iterator end_bridge (); + bridge_const_iterator begin_bridge () const; + bridge_const_iterator end_bridge () const; + void add_bridge ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > const& ); + XSCRT::Type* bridge_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_bridge (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > > bridge_; + + // sharedResource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > >::iterator sharedResource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > >::const_iterator sharedResource_const_iterator; + sharedResource_iterator begin_sharedResource (); + sharedResource_iterator end_sharedResource (); + sharedResource_const_iterator begin_sharedResource () const; + sharedResource_const_iterator end_sharedResource () const; + void add_sharedResource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > const& ); + XSCRT::Type* sharedResource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_sharedResource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > > sharedResource_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + public: + Domain (::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > const& node__); + + Domain (::XSCRT::XML::Element< ACE_TCHAR > const&); + Domain (Domain const& s); + + Domain& + operator= (Domain const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Bridge : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Bridge, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // connect + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::iterator connect_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::const_iterator connect_const_iterator; + connect_iterator begin_connect (); + connect_iterator end_connect (); + connect_const_iterator begin_connect () const; + connect_const_iterator end_connect () const; + void add_connect ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& ); + XSCRT::Type* connect_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connect (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > > connect_; + + // resource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::iterator resource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::const_iterator resource_const_iterator; + resource_iterator begin_resource (); + resource_iterator end_resource (); + resource_const_iterator begin_resource () const; + resource_const_iterator end_resource () const; + void add_resource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& ); + XSCRT::Type* resource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_resource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > > resource_; + + public: + Bridge (::XMLSchema::string< ACE_TCHAR > const& name__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > > const& connect__); + + Bridge (::XSCRT::XML::Element< ACE_TCHAR > const&); + Bridge (Bridge const& s); + + Bridge& + operator= (Bridge const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Interconnect : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Interconnect, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // connection + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > >::iterator connection_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > >::const_iterator connection_const_iterator; + connection_iterator begin_connection (); + connection_iterator end_connection (); + connection_const_iterator begin_connection () const; + connection_const_iterator end_connection () const; + void add_connection ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > const& ); + XSCRT::Type* connection_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connection (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Bridge, ACE_Null_Mutex > > connection_; + + // connect + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > >::iterator connect_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > >::const_iterator connect_const_iterator; + connect_iterator begin_connect (); + connect_iterator end_connect (); + connect_const_iterator begin_connect () const; + connect_const_iterator end_connect () const; + void add_connect ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > const& ); + XSCRT::Type* connect_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connect (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > connect_; + + // resource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::iterator resource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::const_iterator resource_const_iterator; + resource_iterator begin_resource (); + resource_iterator end_resource (); + resource_const_iterator begin_resource () const; + resource_const_iterator end_resource () const; + void add_resource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& ); + XSCRT::Type* resource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_resource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > > resource_; + + public: + Interconnect (::XMLSchema::string< ACE_TCHAR > const& name__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Node, ACE_Null_Mutex > > const& connect__); + + Interconnect (::XSCRT::XML::Element< ACE_TCHAR > const&); + Interconnect (Interconnect const& s); + + Interconnect& + operator= (Interconnect const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export Node : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Node, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // connection + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::iterator connection_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > >::const_iterator connection_const_iterator; + connection_iterator begin_connection (); + connection_iterator end_connection (); + connection_const_iterator begin_connection () const; + connection_const_iterator end_connection () const; + void add_connection ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > const& ); + XSCRT::Type* connection_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connection (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Interconnect, ACE_Null_Mutex > > connection_; + + // sharedResource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > >::iterator sharedResource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > >::const_iterator sharedResource_const_iterator; + sharedResource_iterator begin_sharedResource (); + sharedResource_iterator end_sharedResource (); + sharedResource_const_iterator begin_sharedResource () const; + sharedResource_const_iterator end_sharedResource () const; + void add_sharedResource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > const& ); + XSCRT::Type* sharedResource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_sharedResource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SharedResource, ACE_Null_Mutex > > sharedResource_; + + // resource + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::iterator resource_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > >::const_iterator resource_const_iterator; + resource_iterator begin_resource (); + resource_iterator end_resource (); + resource_const_iterator begin_resource () const; + resource_const_iterator end_resource () const; + void add_resource ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > const& ); + XSCRT::Type* resource_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_resource (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Resource, ACE_Null_Mutex > > resource_; + + public: + Node (::XMLSchema::string< ACE_TCHAR > const& name__); + + Node (::XSCRT::XML::Element< ACE_TCHAR > const&); + Node (Node const& s); + + Node& + operator= (Node const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SharedResource : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SharedResource, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // resourceType + // + public: + ::XMLSchema::string< ACE_TCHAR > const& resourceType () const; + void resourceType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > resourceType_; + + // node + // + public: + ::CIAO::Config_Handlers::Node const& node () const; + void node (::CIAO::Config_Handlers::Node const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::Node > node_; + + // property + // + public: + ::CIAO::Config_Handlers::SatisfierProperty const& property () const; + void property (::CIAO::Config_Handlers::SatisfierProperty const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierProperty > property_; + + public: + SharedResource (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::CIAO::Config_Handlers::Node const& node__, + ::CIAO::Config_Handlers::SatisfierProperty const& property__); + + SharedResource (::XSCRT::XML::Element< ACE_TCHAR > const&); + SharedResource (SharedResource const& s); + + SharedResource& + operator= (SharedResource const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export Domain : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Domain > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + node (Type&); + + virtual void + node (Type const&); + + virtual void + node_pre (Type&); + + virtual void + node_pre (Type const&); + + virtual void + node_next (Type&); + + virtual void + node_next (Type const&); + + virtual void + node_post (Type&); + + virtual void + node_post (Type const&); + + virtual void + interconnect (Type&); + + virtual void + interconnect (Type const&); + + virtual void + interconnect_pre (Type&); + + virtual void + interconnect_pre (Type const&); + + virtual void + interconnect_next (Type&); + + virtual void + interconnect_next (Type const&); + + virtual void + interconnect_post (Type&); + + virtual void + interconnect_post (Type const&); + + virtual void + interconnect_none (Type&); + + virtual void + interconnect_none (Type const&); + + virtual void + bridge (Type&); + + virtual void + bridge (Type const&); + + virtual void + bridge_pre (Type&); + + virtual void + bridge_pre (Type const&); + + virtual void + bridge_next (Type&); + + virtual void + bridge_next (Type const&); + + virtual void + bridge_post (Type&); + + virtual void + bridge_post (Type const&); + + virtual void + bridge_none (Type&); + + virtual void + bridge_none (Type const&); + + virtual void + sharedResource (Type&); + + virtual void + sharedResource (Type const&); + + virtual void + sharedResource_pre (Type&); + + virtual void + sharedResource_pre (Type const&); + + virtual void + sharedResource_next (Type&); + + virtual void + sharedResource_next (Type const&); + + virtual void + sharedResource_post (Type&); + + virtual void + sharedResource_post (Type const&); + + virtual void + sharedResource_none (Type&); + + virtual void + sharedResource_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Bridge : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Bridge > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + connect (Type&); + + virtual void + connect (Type const&); + + virtual void + connect_pre (Type&); + + virtual void + connect_pre (Type const&); + + virtual void + connect_next (Type&); + + virtual void + connect_next (Type const&); + + virtual void + connect_post (Type&); + + virtual void + connect_post (Type const&); + + virtual void + resource (Type&); + + virtual void + resource (Type const&); + + virtual void + resource_pre (Type&); + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type&); + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type&); + + virtual void + resource_post (Type const&); + + virtual void + resource_none (Type&); + + virtual void + resource_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Interconnect : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Interconnect > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + connection (Type&); + + virtual void + connection (Type const&); + + virtual void + connection_pre (Type&); + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type&); + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type&); + + virtual void + connection_post (Type const&); + + virtual void + connection_none (Type&); + + virtual void + connection_none (Type const&); + + virtual void + connect (Type&); + + virtual void + connect (Type const&); + + virtual void + connect_pre (Type&); + + virtual void + connect_pre (Type const&); + + virtual void + connect_next (Type&); + + virtual void + connect_next (Type const&); + + virtual void + connect_post (Type&); + + virtual void + connect_post (Type const&); + + virtual void + resource (Type&); + + virtual void + resource (Type const&); + + virtual void + resource_pre (Type&); + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type&); + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type&); + + virtual void + resource_post (Type const&); + + virtual void + resource_none (Type&); + + virtual void + resource_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export Node : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Node > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + connection (Type&); + + virtual void + connection (Type const&); + + virtual void + connection_pre (Type&); + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type&); + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type&); + + virtual void + connection_post (Type const&); + + virtual void + connection_none (Type&); + + virtual void + connection_none (Type const&); + + virtual void + sharedResource (Type&); + + virtual void + sharedResource (Type const&); + + virtual void + sharedResource_pre (Type&); + + virtual void + sharedResource_pre (Type const&); + + virtual void + sharedResource_next (Type&); + + virtual void + sharedResource_next (Type const&); + + virtual void + sharedResource_post (Type&); + + virtual void + sharedResource_post (Type const&); + + virtual void + sharedResource_none (Type&); + + virtual void + sharedResource_none (Type const&); + + virtual void + resource (Type&); + + virtual void + resource (Type const&); + + virtual void + resource_pre (Type&); + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type&); + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type&); + + virtual void + resource_post (Type const&); + + virtual void + resource_none (Type&); + + virtual void + resource_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export SharedResource : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SharedResource > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + resourceType (Type&); + + virtual void + resourceType (Type const&); + + virtual void + node (Type&); + + virtual void + node (Type const&); + + virtual void + property (Type&); + + virtual void + property (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct Domain : Traversal::Domain, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Domain Type; + Domain (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + node_pre (Type &o) + { + this->node_pre (const_cast <Type const &> (o)); + } + + virtual void + node_pre (Type const&); + + virtual void + node_next (Type &o) + { + this->node_next (const_cast <Type const &> (o)); + } + + virtual void + node_next (Type const&); + + virtual void + node_post (Type &o) + { + this->node_post (const_cast <Type const &> (o)); + } + + virtual void + node_post (Type const&); + + virtual void + interconnect_pre (Type &o) + { + this->interconnect_pre (const_cast <Type const &> (o)); + } + + virtual void + interconnect_pre (Type const&); + + virtual void + interconnect_next (Type &o) + { + this->interconnect_next (const_cast <Type const &> (o)); + } + + virtual void + interconnect_next (Type const&); + + virtual void + interconnect_post (Type &o) + { + this->interconnect_post (const_cast <Type const &> (o)); + } + + virtual void + interconnect_post (Type const&); + + virtual void + bridge_pre (Type &o) + { + this->bridge_pre (const_cast <Type const &> (o)); + } + + virtual void + bridge_pre (Type const&); + + virtual void + bridge_next (Type &o) + { + this->bridge_next (const_cast <Type const &> (o)); + } + + virtual void + bridge_next (Type const&); + + virtual void + bridge_post (Type &o) + { + this->bridge_post (const_cast <Type const &> (o)); + } + + virtual void + bridge_post (Type const&); + + virtual void + sharedResource_pre (Type &o) + { + this->sharedResource_pre (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_pre (Type const&); + + virtual void + sharedResource_next (Type &o) + { + this->sharedResource_next (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_next (Type const&); + + virtual void + sharedResource_post (Type &o) + { + this->sharedResource_post (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + protected: + Domain (); + }; + + struct Bridge : Traversal::Bridge, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Bridge Type; + Bridge (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + connect_pre (Type &o) + { + this->connect_pre (const_cast <Type const &> (o)); + } + + virtual void + connect_pre (Type const&); + + virtual void + connect_next (Type &o) + { + this->connect_next (const_cast <Type const &> (o)); + } + + virtual void + connect_next (Type const&); + + virtual void + connect_post (Type &o) + { + this->connect_post (const_cast <Type const &> (o)); + } + + virtual void + connect_post (Type const&); + + virtual void + resource_pre (Type &o) + { + this->resource_pre (const_cast <Type const &> (o)); + } + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type &o) + { + this->resource_next (const_cast <Type const &> (o)); + } + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type &o) + { + this->resource_post (const_cast <Type const &> (o)); + } + + virtual void + resource_post (Type const&); + + protected: + Bridge (); + }; + + struct Interconnect : Traversal::Interconnect, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Interconnect Type; + Interconnect (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + connection_pre (Type &o) + { + this->connection_pre (const_cast <Type const &> (o)); + } + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type &o) + { + this->connection_next (const_cast <Type const &> (o)); + } + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type &o) + { + this->connection_post (const_cast <Type const &> (o)); + } + + virtual void + connection_post (Type const&); + + virtual void + connect_pre (Type &o) + { + this->connect_pre (const_cast <Type const &> (o)); + } + + virtual void + connect_pre (Type const&); + + virtual void + connect_next (Type &o) + { + this->connect_next (const_cast <Type const &> (o)); + } + + virtual void + connect_next (Type const&); + + virtual void + connect_post (Type &o) + { + this->connect_post (const_cast <Type const &> (o)); + } + + virtual void + connect_post (Type const&); + + virtual void + resource_pre (Type &o) + { + this->resource_pre (const_cast <Type const &> (o)); + } + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type &o) + { + this->resource_next (const_cast <Type const &> (o)); + } + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type &o) + { + this->resource_post (const_cast <Type const &> (o)); + } + + virtual void + resource_post (Type const&); + + protected: + Interconnect (); + }; + + struct Node : Traversal::Node, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Node Type; + Node (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + connection_pre (Type &o) + { + this->connection_pre (const_cast <Type const &> (o)); + } + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type &o) + { + this->connection_next (const_cast <Type const &> (o)); + } + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type &o) + { + this->connection_post (const_cast <Type const &> (o)); + } + + virtual void + connection_post (Type const&); + + virtual void + sharedResource_pre (Type &o) + { + this->sharedResource_pre (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_pre (Type const&); + + virtual void + sharedResource_next (Type &o) + { + this->sharedResource_next (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_next (Type const&); + + virtual void + sharedResource_post (Type &o) + { + this->sharedResource_post (const_cast <Type const &> (o)); + } + + virtual void + sharedResource_post (Type const&); + + virtual void + resource_pre (Type &o) + { + this->resource_pre (const_cast <Type const &> (o)); + } + + virtual void + resource_pre (Type const&); + + virtual void + resource_next (Type &o) + { + this->resource_next (const_cast <Type const &> (o)); + } + + virtual void + resource_next (Type const&); + + virtual void + resource_post (Type &o) + { + this->resource_post (const_cast <Type const &> (o)); + } + + virtual void + resource_post (Type const&); + + protected: + Node (); + }; + + struct SharedResource : Traversal::SharedResource, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SharedResource Type; + SharedResource (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + resourceType (Type &o) + { + this->resourceType (const_cast <Type const &> (o)); + } + + virtual void + resourceType (Type const&); + + virtual void + node (Type &o) + { + this->node (const_cast <Type const &> (o)); + } + + virtual void + node (Type const&); + + virtual void + property (Type &o) + { + this->property (const_cast <Type const &> (o)); + } + + virtual void + property (Type const&); + + protected: + SharedResource (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CDD_HPP diff --git a/modules/CIAO/tools/Config_Handlers/cdp.cpp b/modules/CIAO/tools/Config_Handlers/cdp.cpp new file mode 100644 index 00000000000..f1e8538a788 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cdp.cpp @@ -0,0 +1,2366 @@ +/* $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 "cdp.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // PlanSubcomponentPropertyReference + // + + PlanSubcomponentPropertyReference:: + PlanSubcomponentPropertyReference (::XMLSchema::string< ACE_TCHAR > const& propertyName__, + ::CIAO::Config_Handlers::InstanceDeploymentDescription const& instance__) + : + ::XSCRT::Type (), + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (propertyName__)), + instance_ (new ::CIAO::Config_Handlers::InstanceDeploymentDescription (instance__)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + PlanSubcomponentPropertyReference:: + PlanSubcomponentPropertyReference (PlanSubcomponentPropertyReference const& s) + : + ::XSCRT::Type (), + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.propertyName_)), + instance_ (new ::CIAO::Config_Handlers::InstanceDeploymentDescription (*s.instance_)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + PlanSubcomponentPropertyReference& PlanSubcomponentPropertyReference:: + operator= (PlanSubcomponentPropertyReference const& s) + { + propertyName (*s.propertyName_); + + instance (*s.instance_); + + return *this; + } + + + // PlanSubcomponentPropertyReference + // + ::XMLSchema::string< ACE_TCHAR > const& PlanSubcomponentPropertyReference:: + propertyName () const + { + return *propertyName_; + } + + void PlanSubcomponentPropertyReference:: + propertyName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *propertyName_ = e; + } + + // PlanSubcomponentPropertyReference + // + ::CIAO::Config_Handlers::InstanceDeploymentDescription const& PlanSubcomponentPropertyReference:: + instance () const + { + return *instance_; + } + + void PlanSubcomponentPropertyReference:: + instance (::CIAO::Config_Handlers::InstanceDeploymentDescription const& e) + { + *instance_ = e; + } + + + // PlanPropertyMapping + // + + PlanPropertyMapping:: + PlanPropertyMapping (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& externalName__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > > const& delegatesTo__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (externalName__)), + delegatesTo_ (delegatesTo__), + regulator__ () + { + name_->container (this); + externalName_->container (this); + } + + PlanPropertyMapping:: + PlanPropertyMapping (PlanPropertyMapping const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + source_ (s.source_), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.externalName_)), + delegatesTo_ (s.delegatesTo_), + regulator__ () + { + name_->container (this); + externalName_->container (this); + } + + PlanPropertyMapping& PlanPropertyMapping:: + operator= (PlanPropertyMapping const& s) + { + name (*s.name_); + + source_ = s.source_; + + externalName (*s.externalName_); + + delegatesTo_ = s.delegatesTo_; + + return *this; + } + + + // PlanPropertyMapping + // + ::XMLSchema::string< ACE_TCHAR > const& PlanPropertyMapping:: + name () const + { + return *name_; + } + + void PlanPropertyMapping:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // PlanPropertyMapping + // + PlanPropertyMapping::source_iterator PlanPropertyMapping:: + begin_source () + { + return source_.begin (); + } + + PlanPropertyMapping::source_iterator PlanPropertyMapping:: + end_source () + { + return source_.end (); + } + + PlanPropertyMapping::source_const_iterator PlanPropertyMapping:: + begin_source () const + { + return source_.begin (); + } + + PlanPropertyMapping::source_const_iterator PlanPropertyMapping:: + end_source () const + { + return source_.end (); + } + + void PlanPropertyMapping:: + add_source (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + source_.push_back (e); + } + + size_t PlanPropertyMapping:: + count_source(void) const + { + return source_.size (); + } + + // PlanPropertyMapping + // + ::XMLSchema::string< ACE_TCHAR > const& PlanPropertyMapping:: + externalName () const + { + return *externalName_; + } + + void PlanPropertyMapping:: + externalName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *externalName_ = e; + } + + // PlanPropertyMapping + // + PlanPropertyMapping::delegatesTo_iterator PlanPropertyMapping:: + begin_delegatesTo () + { + return delegatesTo_.begin (); + } + + PlanPropertyMapping::delegatesTo_iterator PlanPropertyMapping:: + end_delegatesTo () + { + return delegatesTo_.end (); + } + + PlanPropertyMapping::delegatesTo_const_iterator PlanPropertyMapping:: + begin_delegatesTo () const + { + return delegatesTo_.begin (); + } + + PlanPropertyMapping::delegatesTo_const_iterator PlanPropertyMapping:: + end_delegatesTo () const + { + return delegatesTo_.end (); + } + + void PlanPropertyMapping:: + add_delegatesTo (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > const& e) + { + delegatesTo_.push_back (e); + } + + size_t PlanPropertyMapping:: + count_delegatesTo(void) const + { + return delegatesTo_.size (); + } + + + // deploymentPlan + // + + deploymentPlan:: + deploymentPlan () + : + regulator__ () + { + } + + deploymentPlan:: + deploymentPlan (deploymentPlan const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + realizes_ (s.realizes_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.realizes_) : 0), + implementation_ (s.implementation_), + instance_ (s.instance_), + connection_ (s.connection_), + externalProperty_ (s.externalProperty_), + dependsOn_ (s.dependsOn_), + artifact_ (s.artifact_), + infoProperty_ (s.infoProperty_), + localityConstraint_ (s.localityConstraint_), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (realizes_.get ()) realizes_->container (this); + } + + deploymentPlan& deploymentPlan:: + operator= (deploymentPlan const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.realizes_.get ()) + realizes (*(s.realizes_)); + else + realizes_.reset (0); + + implementation_ = s.implementation_; + + instance_ = s.instance_; + + connection_ = s.connection_; + + externalProperty_ = s.externalProperty_; + + dependsOn_ = s.dependsOn_; + + artifact_ = s.artifact_; + + infoProperty_ = s.infoProperty_; + + localityConstraint_ = s.localityConstraint_; + + return *this; + } + + + // deploymentPlan + // + bool deploymentPlan:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& deploymentPlan:: + label () const + { + return *label_; + } + + void deploymentPlan:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // deploymentPlan + // + bool deploymentPlan:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& deploymentPlan:: + UUID () const + { + return *UUID_; + } + + void deploymentPlan:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // deploymentPlan + // + bool deploymentPlan:: + realizes_p () const + { + return realizes_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& deploymentPlan:: + realizes () const + { + return *realizes_; + } + + void deploymentPlan:: + realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + if (realizes_.get ()) + { + *realizes_ = e; + } + + else + { + realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + realizes_->container (this); + } + } + + // deploymentPlan + // + deploymentPlan::implementation_iterator deploymentPlan:: + begin_implementation () + { + return implementation_.begin (); + } + + deploymentPlan::implementation_iterator deploymentPlan:: + end_implementation () + { + return implementation_.end (); + } + + deploymentPlan::implementation_const_iterator deploymentPlan:: + begin_implementation () const + { + return implementation_.begin (); + } + + deploymentPlan::implementation_const_iterator deploymentPlan:: + end_implementation () const + { + return implementation_.end (); + } + + void deploymentPlan:: + add_implementation (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > const& e) + { + implementation_.push_back (e); + } + + size_t deploymentPlan:: + count_implementation(void) const + { + return implementation_.size (); + } + + // deploymentPlan + // + deploymentPlan::instance_iterator deploymentPlan:: + begin_instance () + { + return instance_.begin (); + } + + deploymentPlan::instance_iterator deploymentPlan:: + end_instance () + { + return instance_.end (); + } + + deploymentPlan::instance_const_iterator deploymentPlan:: + begin_instance () const + { + return instance_.begin (); + } + + deploymentPlan::instance_const_iterator deploymentPlan:: + end_instance () const + { + return instance_.end (); + } + + void deploymentPlan:: + add_instance (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > const& e) + { + instance_.push_back (e); + } + + size_t deploymentPlan:: + count_instance(void) const + { + return instance_.size (); + } + + // deploymentPlan + // + deploymentPlan::connection_iterator deploymentPlan:: + begin_connection () + { + return connection_.begin (); + } + + deploymentPlan::connection_iterator deploymentPlan:: + end_connection () + { + return connection_.end (); + } + + deploymentPlan::connection_const_iterator deploymentPlan:: + begin_connection () const + { + return connection_.begin (); + } + + deploymentPlan::connection_const_iterator deploymentPlan:: + end_connection () const + { + return connection_.end (); + } + + void deploymentPlan:: + add_connection (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > const& e) + { + connection_.push_back (e); + } + + size_t deploymentPlan:: + count_connection(void) const + { + return connection_.size (); + } + + // deploymentPlan + // + deploymentPlan::externalProperty_iterator deploymentPlan:: + begin_externalProperty () + { + return externalProperty_.begin (); + } + + deploymentPlan::externalProperty_iterator deploymentPlan:: + end_externalProperty () + { + return externalProperty_.end (); + } + + deploymentPlan::externalProperty_const_iterator deploymentPlan:: + begin_externalProperty () const + { + return externalProperty_.begin (); + } + + deploymentPlan::externalProperty_const_iterator deploymentPlan:: + end_externalProperty () const + { + return externalProperty_.end (); + } + + void deploymentPlan:: + add_externalProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > const& e) + { + externalProperty_.push_back (e); + } + + size_t deploymentPlan:: + count_externalProperty(void) const + { + return externalProperty_.size (); + } + + // deploymentPlan + // + deploymentPlan::dependsOn_iterator deploymentPlan:: + begin_dependsOn () + { + return dependsOn_.begin (); + } + + deploymentPlan::dependsOn_iterator deploymentPlan:: + end_dependsOn () + { + return dependsOn_.end (); + } + + deploymentPlan::dependsOn_const_iterator deploymentPlan:: + begin_dependsOn () const + { + return dependsOn_.begin (); + } + + deploymentPlan::dependsOn_const_iterator deploymentPlan:: + end_dependsOn () const + { + return dependsOn_.end (); + } + + void deploymentPlan:: + add_dependsOn (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& e) + { + dependsOn_.push_back (e); + } + + size_t deploymentPlan:: + count_dependsOn(void) const + { + return dependsOn_.size (); + } + + // deploymentPlan + // + deploymentPlan::artifact_iterator deploymentPlan:: + begin_artifact () + { + return artifact_.begin (); + } + + deploymentPlan::artifact_iterator deploymentPlan:: + end_artifact () + { + return artifact_.end (); + } + + deploymentPlan::artifact_const_iterator deploymentPlan:: + begin_artifact () const + { + return artifact_.begin (); + } + + deploymentPlan::artifact_const_iterator deploymentPlan:: + end_artifact () const + { + return artifact_.end (); + } + + void deploymentPlan:: + add_artifact (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > const& e) + { + artifact_.push_back (e); + } + + size_t deploymentPlan:: + count_artifact(void) const + { + return artifact_.size (); + } + + // deploymentPlan + // + deploymentPlan::infoProperty_iterator deploymentPlan:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + deploymentPlan::infoProperty_iterator deploymentPlan:: + end_infoProperty () + { + return infoProperty_.end (); + } + + deploymentPlan::infoProperty_const_iterator deploymentPlan:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + deploymentPlan::infoProperty_const_iterator deploymentPlan:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void deploymentPlan:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t deploymentPlan:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // deploymentPlan + // + deploymentPlan::localityConstraint_iterator deploymentPlan:: + begin_localityConstraint () + { + return localityConstraint_.begin (); + } + + deploymentPlan::localityConstraint_iterator deploymentPlan:: + end_localityConstraint () + { + return localityConstraint_.end (); + } + + deploymentPlan::localityConstraint_const_iterator deploymentPlan:: + begin_localityConstraint () const + { + return localityConstraint_.begin (); + } + + deploymentPlan::localityConstraint_const_iterator deploymentPlan:: + end_localityConstraint () const + { + return localityConstraint_.end (); + } + + void deploymentPlan:: + add_localityConstraint (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > const& e) + { + localityConstraint_.push_back (e); + } + + size_t deploymentPlan:: + count_localityConstraint(void) const + { + return localityConstraint_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // PlanSubcomponentPropertyReference + // + + PlanSubcomponentPropertyReference:: + PlanSubcomponentPropertyReference (::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 == ACE_TEXT("propertyName")) + { + propertyName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + propertyName_->container (this); + } + + else if (n == ACE_TEXT("instance")) + { + instance_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceDeploymentDescription > (new ::CIAO::Config_Handlers::InstanceDeploymentDescription (e)); + instance_->container (this); + } + + else + { + } + } + } + + // PlanPropertyMapping + // + + PlanPropertyMapping:: + PlanPropertyMapping (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("source")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_source (t); + } + + else if (n == ACE_TEXT("externalName")) + { + externalName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + externalName_->container (this); + } + + else if (n == ACE_TEXT("delegatesTo")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference (e)); + add_delegatesTo (t); + } + + else + { + } + } + } + + // deploymentPlan + // + + deploymentPlan:: + deploymentPlan (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("realizes")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + realizes (t); + } + + else if (n == ACE_TEXT("implementation")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::MonolithicDeploymentDescription (e)); + add_implementation (t); + } + + else if (n == ACE_TEXT("instance")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::InstanceDeploymentDescription (e)); + add_instance (t); + } + + else if (n == ACE_TEXT("connection")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PlanConnectionDescription (e)); + add_connection (t); + } + + else if (n == ACE_TEXT("externalProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PlanPropertyMapping (e)); + add_externalProperty (t); + } + + else if (n == ACE_TEXT("dependsOn")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ImplementationDependency (e)); + add_dependsOn (t); + } + + else if (n == ACE_TEXT("artifact")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ArtifactDeploymentDescription (e)); + add_artifact (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (t); + } + + else if (n == ACE_TEXT("localityConstraint")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PlanLocality (e)); + add_localityConstraint (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 PlanSubcomponentPropertyReferenceTypeInfoInitializer + { + PlanSubcomponentPropertyReferenceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::PlanSubcomponentPropertyReference)); + ::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)); + } + }; + + PlanSubcomponentPropertyReferenceTypeInfoInitializer PlanSubcomponentPropertyReferenceTypeInfoInitializer_; + + struct PlanPropertyMappingTypeInfoInitializer + { + PlanPropertyMappingTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::PlanPropertyMapping)); + ::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)); + } + }; + + PlanPropertyMappingTypeInfoInitializer PlanPropertyMappingTypeInfoInitializer_; + + struct deploymentPlanTypeInfoInitializer + { + deploymentPlanTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::deploymentPlan)); + ::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)); + } + }; + + deploymentPlanTypeInfoInitializer deploymentPlanTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // PlanSubcomponentPropertyReference + // + // + + void PlanSubcomponentPropertyReference:: + traverse (Type& o) + { + pre (o); + propertyName (o); + instance (o); + post (o); + } + + void PlanSubcomponentPropertyReference:: + traverse (Type const& o) + { + pre (o); + propertyName (o); + instance (o); + post (o); + } + + void PlanSubcomponentPropertyReference:: + pre (Type&) + { + } + + void PlanSubcomponentPropertyReference:: + pre (Type const&) + { + } + + void PlanSubcomponentPropertyReference:: + propertyName (Type& o) + { + dispatch (o.propertyName ()); + } + + void PlanSubcomponentPropertyReference:: + propertyName (Type const& o) + { + dispatch (o.propertyName ()); + } + + void PlanSubcomponentPropertyReference:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPropertyReference:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPropertyReference:: + post (Type&) + { + } + + void PlanSubcomponentPropertyReference:: + post (Type const&) + { + } + + // PlanPropertyMapping + // + // + + void PlanPropertyMapping:: + traverse (Type& o) + { + pre (o); + name (o); + source (o); + externalName (o); + delegatesTo (o); + post (o); + } + + void PlanPropertyMapping:: + traverse (Type const& o) + { + pre (o); + name (o); + source (o); + externalName (o); + delegatesTo (o); + post (o); + } + + void PlanPropertyMapping:: + pre (Type&) + { + } + + void PlanPropertyMapping:: + pre (Type const&) + { + } + + void PlanPropertyMapping:: + name (Type& o) + { + dispatch (o.name ()); + } + + void PlanPropertyMapping:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void PlanPropertyMapping:: + source (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanPropertyMapping::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); + } + + else source_none (o); + } + + void PlanPropertyMapping:: + source (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanPropertyMapping::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); + } + + else source_none (o); + } + + void PlanPropertyMapping:: + source_pre (Type&) + { + } + + void PlanPropertyMapping:: + source_pre (Type const&) + { + } + + void PlanPropertyMapping:: + source_next (Type&) + { + } + + void PlanPropertyMapping:: + source_next (Type const&) + { + } + + void PlanPropertyMapping:: + source_post (Type&) + { + } + + void PlanPropertyMapping:: + source_post (Type const&) + { + } + + void PlanPropertyMapping:: + source_none (Type&) + { + } + + void PlanPropertyMapping:: + source_none (Type const&) + { + } + + void PlanPropertyMapping:: + externalName (Type& o) + { + dispatch (o.externalName ()); + } + + void PlanPropertyMapping:: + externalName (Type const& o) + { + dispatch (o.externalName ()); + } + + void PlanPropertyMapping:: + delegatesTo (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanPropertyMapping::delegatesTo_iterator b (o.begin_delegatesTo()), e (o.end_delegatesTo()); + + if (b != e) + { + delegatesTo_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) delegatesTo_next (o); + } + + delegatesTo_post (o); + } + } + + void PlanPropertyMapping:: + delegatesTo (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PlanPropertyMapping::delegatesTo_const_iterator b (o.begin_delegatesTo()), e (o.end_delegatesTo()); + + if (b != e) + { + delegatesTo_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) delegatesTo_next (o); + } + + delegatesTo_post (o); + } + } + + void PlanPropertyMapping:: + delegatesTo_pre (Type&) + { + } + + void PlanPropertyMapping:: + delegatesTo_pre (Type const&) + { + } + + void PlanPropertyMapping:: + delegatesTo_next (Type&) + { + } + + void PlanPropertyMapping:: + delegatesTo_next (Type const&) + { + } + + void PlanPropertyMapping:: + delegatesTo_post (Type&) + { + } + + void PlanPropertyMapping:: + delegatesTo_post (Type const&) + { + } + + void PlanPropertyMapping:: + post (Type&) + { + } + + void PlanPropertyMapping:: + post (Type const&) + { + } + + // deploymentPlan + // + // + + void deploymentPlan:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + implementation (o); + instance (o); + connection (o); + externalProperty (o); + dependsOn (o); + artifact (o); + infoProperty (o); + localityConstraint (o); + post (o); + } + + void deploymentPlan:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + implementation (o); + instance (o); + connection (o); + externalProperty (o); + dependsOn (o); + artifact (o); + infoProperty (o); + localityConstraint (o); + post (o); + } + + void deploymentPlan:: + pre (Type&) + { + } + + void deploymentPlan:: + pre (Type const&) + { + } + + void deploymentPlan:: + label (Type& o) + { + dispatch (o.label ()); + } + + void deploymentPlan:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void deploymentPlan:: + label_none (Type&) + { + } + + void deploymentPlan:: + label_none (Type const&) + { + } + + void deploymentPlan:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void deploymentPlan:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void deploymentPlan:: + UUID_none (Type&) + { + } + + void deploymentPlan:: + UUID_none (Type const&) + { + } + + void deploymentPlan:: + realizes (Type& o) + { + dispatch (o.realizes ()); + } + + void deploymentPlan:: + realizes (Type const& o) + { + dispatch (o.realizes ()); + } + + void deploymentPlan:: + realizes_none (Type&) + { + } + + void deploymentPlan:: + realizes_none (Type const&) + { + } + + void deploymentPlan:: + implementation (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::implementation_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void deploymentPlan:: + implementation (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::implementation_const_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void deploymentPlan:: + implementation_pre (Type&) + { + } + + void deploymentPlan:: + implementation_pre (Type const&) + { + } + + void deploymentPlan:: + implementation_next (Type&) + { + } + + void deploymentPlan:: + implementation_next (Type const&) + { + } + + void deploymentPlan:: + implementation_post (Type&) + { + } + + void deploymentPlan:: + implementation_post (Type const&) + { + } + + void deploymentPlan:: + implementation_none (Type&) + { + } + + void deploymentPlan:: + implementation_none (Type const&) + { + } + + void deploymentPlan:: + instance (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::instance_iterator b (o.begin_instance()), e (o.end_instance()); + + if (b != e) + { + instance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) instance_next (o); + } + + instance_post (o); + } + + else instance_none (o); + } + + void deploymentPlan:: + instance (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::instance_const_iterator b (o.begin_instance()), e (o.end_instance()); + + if (b != e) + { + instance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) instance_next (o); + } + + instance_post (o); + } + + else instance_none (o); + } + + void deploymentPlan:: + instance_pre (Type&) + { + } + + void deploymentPlan:: + instance_pre (Type const&) + { + } + + void deploymentPlan:: + instance_next (Type&) + { + } + + void deploymentPlan:: + instance_next (Type const&) + { + } + + void deploymentPlan:: + instance_post (Type&) + { + } + + void deploymentPlan:: + instance_post (Type const&) + { + } + + void deploymentPlan:: + instance_none (Type&) + { + } + + void deploymentPlan:: + instance_none (Type const&) + { + } + + void deploymentPlan:: + connection (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::connection_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void deploymentPlan:: + connection (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::connection_const_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void deploymentPlan:: + connection_pre (Type&) + { + } + + void deploymentPlan:: + connection_pre (Type const&) + { + } + + void deploymentPlan:: + connection_next (Type&) + { + } + + void deploymentPlan:: + connection_next (Type const&) + { + } + + void deploymentPlan:: + connection_post (Type&) + { + } + + void deploymentPlan:: + connection_post (Type const&) + { + } + + void deploymentPlan:: + connection_none (Type&) + { + } + + void deploymentPlan:: + connection_none (Type const&) + { + } + + void deploymentPlan:: + externalProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::externalProperty_iterator b (o.begin_externalProperty()), e (o.end_externalProperty()); + + if (b != e) + { + externalProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) externalProperty_next (o); + } + + externalProperty_post (o); + } + + else externalProperty_none (o); + } + + void deploymentPlan:: + externalProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::externalProperty_const_iterator b (o.begin_externalProperty()), e (o.end_externalProperty()); + + if (b != e) + { + externalProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) externalProperty_next (o); + } + + externalProperty_post (o); + } + + else externalProperty_none (o); + } + + void deploymentPlan:: + externalProperty_pre (Type&) + { + } + + void deploymentPlan:: + externalProperty_pre (Type const&) + { + } + + void deploymentPlan:: + externalProperty_next (Type&) + { + } + + void deploymentPlan:: + externalProperty_next (Type const&) + { + } + + void deploymentPlan:: + externalProperty_post (Type&) + { + } + + void deploymentPlan:: + externalProperty_post (Type const&) + { + } + + void deploymentPlan:: + externalProperty_none (Type&) + { + } + + void deploymentPlan:: + externalProperty_none (Type const&) + { + } + + void deploymentPlan:: + dependsOn (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::dependsOn_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void deploymentPlan:: + dependsOn (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::dependsOn_const_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void deploymentPlan:: + dependsOn_pre (Type&) + { + } + + void deploymentPlan:: + dependsOn_pre (Type const&) + { + } + + void deploymentPlan:: + dependsOn_next (Type&) + { + } + + void deploymentPlan:: + dependsOn_next (Type const&) + { + } + + void deploymentPlan:: + dependsOn_post (Type&) + { + } + + void deploymentPlan:: + dependsOn_post (Type const&) + { + } + + void deploymentPlan:: + dependsOn_none (Type&) + { + } + + void deploymentPlan:: + dependsOn_none (Type const&) + { + } + + void deploymentPlan:: + artifact (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::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); + } + + else artifact_none (o); + } + + void deploymentPlan:: + artifact (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::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); + } + + else artifact_none (o); + } + + void deploymentPlan:: + artifact_pre (Type&) + { + } + + void deploymentPlan:: + artifact_pre (Type const&) + { + } + + void deploymentPlan:: + artifact_next (Type&) + { + } + + void deploymentPlan:: + artifact_next (Type const&) + { + } + + void deploymentPlan:: + artifact_post (Type&) + { + } + + void deploymentPlan:: + artifact_post (Type const&) + { + } + + void deploymentPlan:: + artifact_none (Type&) + { + } + + void deploymentPlan:: + artifact_none (Type const&) + { + } + + void deploymentPlan:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void deploymentPlan:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void deploymentPlan:: + infoProperty_pre (Type&) + { + } + + void deploymentPlan:: + infoProperty_pre (Type const&) + { + } + + void deploymentPlan:: + infoProperty_next (Type&) + { + } + + void deploymentPlan:: + infoProperty_next (Type const&) + { + } + + void deploymentPlan:: + infoProperty_post (Type&) + { + } + + void deploymentPlan:: + infoProperty_post (Type const&) + { + } + + void deploymentPlan:: + infoProperty_none (Type&) + { + } + + void deploymentPlan:: + infoProperty_none (Type const&) + { + } + + void deploymentPlan:: + localityConstraint (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::localityConstraint_iterator b (o.begin_localityConstraint()), e (o.end_localityConstraint()); + + if (b != e) + { + localityConstraint_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) localityConstraint_next (o); + } + + localityConstraint_post (o); + } + + else localityConstraint_none (o); + } + + void deploymentPlan:: + localityConstraint (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::deploymentPlan::localityConstraint_const_iterator b (o.begin_localityConstraint()), e (o.end_localityConstraint()); + + if (b != e) + { + localityConstraint_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) localityConstraint_next (o); + } + + localityConstraint_post (o); + } + + else localityConstraint_none (o); + } + + void deploymentPlan:: + localityConstraint_pre (Type&) + { + } + + void deploymentPlan:: + localityConstraint_pre (Type const&) + { + } + + void deploymentPlan:: + localityConstraint_next (Type&) + { + } + + void deploymentPlan:: + localityConstraint_next (Type const&) + { + } + + void deploymentPlan:: + localityConstraint_post (Type&) + { + } + + void deploymentPlan:: + localityConstraint_post (Type const&) + { + } + + void deploymentPlan:: + localityConstraint_none (Type&) + { + } + + void deploymentPlan:: + localityConstraint_none (Type const&) + { + } + + void deploymentPlan:: + post (Type&) + { + } + + void deploymentPlan:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // PlanSubcomponentPropertyReference + // + // + + PlanSubcomponentPropertyReference:: + PlanSubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanSubcomponentPropertyReference:: + PlanSubcomponentPropertyReference () + { + } + + void PlanSubcomponentPropertyReference:: + traverse (Type const& o) + { + Traversal::PlanSubcomponentPropertyReference::traverse (o); + } + + void PlanSubcomponentPropertyReference:: + propertyName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("propertyName"), top_ ())); + Traversal::PlanSubcomponentPropertyReference::propertyName (o); + pop_ (); + } + + void PlanSubcomponentPropertyReference:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("instance"), top_ ())); + Traversal::PlanSubcomponentPropertyReference::instance (o); + pop_ (); + } + + // PlanPropertyMapping + // + // + + PlanPropertyMapping:: + PlanPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanPropertyMapping:: + PlanPropertyMapping () + { + } + + void PlanPropertyMapping:: + traverse (Type const& o) + { + Traversal::PlanPropertyMapping::traverse (o); + } + + void PlanPropertyMapping:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::PlanPropertyMapping::name (o); + pop_ (); + } + + void PlanPropertyMapping:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("source"), top_ ())); + } + + void PlanPropertyMapping:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void PlanPropertyMapping:: + source_post (Type const&) + { + pop_ (); + } + + void PlanPropertyMapping:: + externalName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("externalName"), top_ ())); + Traversal::PlanPropertyMapping::externalName (o); + pop_ (); + } + + void PlanPropertyMapping:: + delegatesTo_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("delegatesTo"), top_ ())); + } + + void PlanPropertyMapping:: + delegatesTo_next (Type const& o) + { + delegatesTo_post (o); + delegatesTo_pre (o); + } + + void PlanPropertyMapping:: + delegatesTo_post (Type const&) + { + pop_ (); + } + + // deploymentPlan + // + // + + deploymentPlan:: + deploymentPlan (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + deploymentPlan:: + deploymentPlan () + { + } + + void deploymentPlan:: + traverse (Type const& o) + { + Traversal::deploymentPlan::traverse (o); + } + + void deploymentPlan:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::deploymentPlan::label (o); + pop_ (); + } + + void deploymentPlan:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::deploymentPlan::UUID (o); + pop_ (); + } + + void deploymentPlan:: + realizes (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("realizes"), top_ ())); + Traversal::deploymentPlan::realizes (o); + pop_ (); + } + + void deploymentPlan:: + implementation_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implementation"), top_ ())); + } + + void deploymentPlan:: + implementation_next (Type const& o) + { + implementation_post (o); + implementation_pre (o); + } + + void deploymentPlan:: + implementation_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + instance_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("instance"), top_ ())); + } + + void deploymentPlan:: + instance_next (Type const& o) + { + instance_post (o); + instance_pre (o); + } + + void deploymentPlan:: + instance_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connection"), top_ ())); + } + + void deploymentPlan:: + connection_next (Type const& o) + { + connection_post (o); + connection_pre (o); + } + + void deploymentPlan:: + connection_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + externalProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("externalProperty"), top_ ())); + } + + void deploymentPlan:: + externalProperty_next (Type const& o) + { + externalProperty_post (o); + externalProperty_pre (o); + } + + void deploymentPlan:: + externalProperty_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + dependsOn_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("dependsOn"), top_ ())); + } + + void deploymentPlan:: + dependsOn_next (Type const& o) + { + dependsOn_post (o); + dependsOn_pre (o); + } + + void deploymentPlan:: + dependsOn_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + artifact_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("artifact"), top_ ())); + } + + void deploymentPlan:: + artifact_next (Type const& o) + { + artifact_post (o); + artifact_pre (o); + } + + void deploymentPlan:: + artifact_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void deploymentPlan:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void deploymentPlan:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void deploymentPlan:: + localityConstraint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("localityConstraint"), top_ ())); + } + + void deploymentPlan:: + localityConstraint_next (Type const& o) + { + localityConstraint_post (o); + localityConstraint_pre (o); + } + + void deploymentPlan:: + localityConstraint_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/cdp.hpp b/modules/CIAO/tools/Config_Handlers/cdp.hpp new file mode 100644 index 00000000000..9b1e5f0bc9e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cdp.hpp @@ -0,0 +1,1187 @@ +/* $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 + +#ifndef CDP_HPP +#define CDP_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class PlanSubcomponentPropertyReference; + class PlanPropertyMapping; + class deploymentPlan; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "ccd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export PlanSubcomponentPropertyReference : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PlanSubcomponentPropertyReference, ACE_Null_Mutex > _ptr; + + // propertyName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& propertyName () const; + void propertyName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > propertyName_; + + // instance + // + public: + ::CIAO::Config_Handlers::InstanceDeploymentDescription const& instance () const; + void instance (::CIAO::Config_Handlers::InstanceDeploymentDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceDeploymentDescription > instance_; + + public: + PlanSubcomponentPropertyReference (::XMLSchema::string< ACE_TCHAR > const& propertyName__, + ::CIAO::Config_Handlers::InstanceDeploymentDescription const& instance__); + + PlanSubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanSubcomponentPropertyReference (PlanSubcomponentPropertyReference const& s); + + PlanSubcomponentPropertyReference& + operator= (PlanSubcomponentPropertyReference const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export PlanPropertyMapping : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PlanPropertyMapping, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // source + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator source_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* source_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_source (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > source_; + + // externalName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& externalName () const; + void externalName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > externalName_; + + // delegatesTo + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > >::iterator delegatesTo_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > >::const_iterator delegatesTo_const_iterator; + delegatesTo_iterator begin_delegatesTo (); + delegatesTo_iterator end_delegatesTo (); + delegatesTo_const_iterator begin_delegatesTo () const; + delegatesTo_const_iterator end_delegatesTo () const; + void add_delegatesTo ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > const& ); + XSCRT::Type* delegatesTo_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_delegatesTo (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > > delegatesTo_; + + public: + PlanPropertyMapping (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& externalName__, + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference, ACE_Null_Mutex > > const& delegatesTo__); + + PlanPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR > const&); + PlanPropertyMapping (PlanPropertyMapping const& s); + + PlanPropertyMapping& + operator= (PlanPropertyMapping const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export deploymentPlan : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < deploymentPlan, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // realizes + // + public: + bool realizes_p () const; + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& realizes () const; + void realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > realizes_; + + // implementation + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > >::iterator implementation_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > >::const_iterator implementation_const_iterator; + implementation_iterator begin_implementation (); + implementation_iterator end_implementation (); + implementation_const_iterator begin_implementation () const; + implementation_const_iterator end_implementation () const; + void add_implementation ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* implementation_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_implementation (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::MonolithicDeploymentDescription, ACE_Null_Mutex > > implementation_; + + // instance + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > >::iterator instance_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > >::const_iterator instance_const_iterator; + instance_iterator begin_instance (); + instance_iterator end_instance (); + instance_const_iterator begin_instance () const; + instance_const_iterator end_instance () const; + void add_instance ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* instance_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_instance (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::InstanceDeploymentDescription, ACE_Null_Mutex > > instance_; + + // connection + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > >::iterator connection_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > >::const_iterator connection_const_iterator; + connection_iterator begin_connection (); + connection_iterator end_connection (); + connection_const_iterator begin_connection () const; + connection_const_iterator end_connection () const; + void add_connection ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* connection_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connection (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanConnectionDescription, ACE_Null_Mutex > > connection_; + + // externalProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > >::iterator externalProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > >::const_iterator externalProperty_const_iterator; + externalProperty_iterator begin_externalProperty (); + externalProperty_iterator end_externalProperty (); + externalProperty_const_iterator begin_externalProperty () const; + externalProperty_const_iterator end_externalProperty () const; + void add_externalProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > const& ); + XSCRT::Type* externalProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanPropertyMapping, ACE_Null_Mutex > > externalProperty_; + + // dependsOn + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::iterator dependsOn_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::const_iterator dependsOn_const_iterator; + dependsOn_iterator begin_dependsOn (); + dependsOn_iterator end_dependsOn (); + dependsOn_const_iterator begin_dependsOn () const; + dependsOn_const_iterator end_dependsOn () const; + void add_dependsOn ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& ); + XSCRT::Type* dependsOn_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > > dependsOn_; + + // artifact + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > >::iterator artifact_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > >::const_iterator artifact_const_iterator; + artifact_iterator begin_artifact (); + artifact_iterator end_artifact (); + artifact_const_iterator begin_artifact () const; + artifact_const_iterator end_artifact () const; + void add_artifact ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* artifact_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_artifact (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ArtifactDeploymentDescription, ACE_Null_Mutex > > artifact_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // localityConstraint + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > >::iterator localityConstraint_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > >::const_iterator localityConstraint_const_iterator; + localityConstraint_iterator begin_localityConstraint (); + localityConstraint_iterator end_localityConstraint (); + localityConstraint_const_iterator begin_localityConstraint () const; + localityConstraint_const_iterator end_localityConstraint () const; + void add_localityConstraint ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > const& ); + XSCRT::Type* localityConstraint_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_localityConstraint (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PlanLocality, ACE_Null_Mutex > > localityConstraint_; + + public: + deploymentPlan (); + + deploymentPlan (::XSCRT::XML::Element< ACE_TCHAR > const&); + deploymentPlan (deploymentPlan const& s); + + deploymentPlan& + operator= (deploymentPlan const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export PlanSubcomponentPropertyReference : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + propertyName (Type&); + + virtual void + propertyName (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export PlanPropertyMapping : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PlanPropertyMapping > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + source (Type&); + + virtual void + source (Type const&); + + virtual void + source_pre (Type&); + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type&); + + virtual void + source_next (Type const&); + + virtual void + source_post (Type&); + + virtual void + source_post (Type const&); + + virtual void + source_none (Type&); + + virtual void + source_none (Type const&); + + virtual void + externalName (Type&); + + virtual void + externalName (Type const&); + + virtual void + delegatesTo (Type&); + + virtual void + delegatesTo (Type const&); + + virtual void + delegatesTo_pre (Type&); + + virtual void + delegatesTo_pre (Type const&); + + virtual void + delegatesTo_next (Type&); + + virtual void + delegatesTo_next (Type const&); + + virtual void + delegatesTo_post (Type&); + + virtual void + delegatesTo_post (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export deploymentPlan : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::deploymentPlan > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + realizes (Type&); + + virtual void + realizes (Type const&); + + virtual void + realizes_none (Type&); + + virtual void + realizes_none (Type const&); + + virtual void + implementation (Type&); + + virtual void + implementation (Type const&); + + virtual void + implementation_pre (Type&); + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type&); + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type&); + + virtual void + implementation_post (Type const&); + + virtual void + implementation_none (Type&); + + virtual void + implementation_none (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + instance_pre (Type&); + + virtual void + instance_pre (Type const&); + + virtual void + instance_next (Type&); + + virtual void + instance_next (Type const&); + + virtual void + instance_post (Type&); + + virtual void + instance_post (Type const&); + + virtual void + instance_none (Type&); + + virtual void + instance_none (Type const&); + + virtual void + connection (Type&); + + virtual void + connection (Type const&); + + virtual void + connection_pre (Type&); + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type&); + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type&); + + virtual void + connection_post (Type const&); + + virtual void + connection_none (Type&); + + virtual void + connection_none (Type const&); + + virtual void + externalProperty (Type&); + + virtual void + externalProperty (Type const&); + + virtual void + externalProperty_pre (Type&); + + virtual void + externalProperty_pre (Type const&); + + virtual void + externalProperty_next (Type&); + + virtual void + externalProperty_next (Type const&); + + virtual void + externalProperty_post (Type&); + + virtual void + externalProperty_post (Type const&); + + virtual void + externalProperty_none (Type&); + + virtual void + externalProperty_none (Type const&); + + virtual void + dependsOn (Type&); + + virtual void + dependsOn (Type const&); + + virtual void + dependsOn_pre (Type&); + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type&); + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type&); + + virtual void + dependsOn_post (Type const&); + + virtual void + dependsOn_none (Type&); + + virtual void + dependsOn_none (Type const&); + + virtual void + artifact (Type&); + + virtual void + artifact (Type const&); + + virtual void + artifact_pre (Type&); + + virtual void + artifact_pre (Type const&); + + virtual void + artifact_next (Type&); + + virtual void + artifact_next (Type const&); + + virtual void + artifact_post (Type&); + + virtual void + artifact_post (Type const&); + + virtual void + artifact_none (Type&); + + virtual void + artifact_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + localityConstraint (Type&); + + virtual void + localityConstraint (Type const&); + + virtual void + localityConstraint_pre (Type&); + + virtual void + localityConstraint_pre (Type const&); + + virtual void + localityConstraint_next (Type&); + + virtual void + localityConstraint_next (Type const&); + + virtual void + localityConstraint_post (Type&); + + virtual void + localityConstraint_post (Type const&); + + virtual void + localityConstraint_none (Type&); + + virtual void + localityConstraint_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct PlanSubcomponentPropertyReference : Traversal::PlanSubcomponentPropertyReference, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PlanSubcomponentPropertyReference Type; + PlanSubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + propertyName (Type &o) + { + this->propertyName (const_cast <Type const &> (o)); + } + + virtual void + propertyName (Type const&); + + virtual void + instance (Type &o) + { + this->instance (const_cast <Type const &> (o)); + } + + virtual void + instance (Type const&); + + protected: + PlanSubcomponentPropertyReference (); + }; + + struct PlanPropertyMapping : Traversal::PlanPropertyMapping, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PlanPropertyMapping Type; + PlanPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + source_pre (Type &o) + { + this->source_pre (const_cast <Type const &> (o)); + } + + virtual void + source_pre (Type const&); + + virtual void + source_next (Type &o) + { + this->source_next (const_cast <Type const &> (o)); + } + + virtual void + source_next (Type const&); + + virtual void + source_post (Type &o) + { + this->source_post (const_cast <Type const &> (o)); + } + + virtual void + source_post (Type const&); + + virtual void + externalName (Type &o) + { + this->externalName (const_cast <Type const &> (o)); + } + + virtual void + externalName (Type const&); + + virtual void + delegatesTo_pre (Type &o) + { + this->delegatesTo_pre (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_pre (Type const&); + + virtual void + delegatesTo_next (Type &o) + { + this->delegatesTo_next (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_next (Type const&); + + virtual void + delegatesTo_post (Type &o) + { + this->delegatesTo_post (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_post (Type const&); + + protected: + PlanPropertyMapping (); + }; + + struct deploymentPlan : Traversal::deploymentPlan, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::deploymentPlan Type; + deploymentPlan (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + realizes (Type &o) + { + this->realizes (const_cast <Type const &> (o)); + } + + virtual void + realizes (Type const&); + + virtual void + implementation_pre (Type &o) + { + this->implementation_pre (const_cast <Type const &> (o)); + } + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type &o) + { + this->implementation_next (const_cast <Type const &> (o)); + } + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type &o) + { + this->implementation_post (const_cast <Type const &> (o)); + } + + virtual void + implementation_post (Type const&); + + virtual void + instance_pre (Type &o) + { + this->instance_pre (const_cast <Type const &> (o)); + } + + virtual void + instance_pre (Type const&); + + virtual void + instance_next (Type &o) + { + this->instance_next (const_cast <Type const &> (o)); + } + + virtual void + instance_next (Type const&); + + virtual void + instance_post (Type &o) + { + this->instance_post (const_cast <Type const &> (o)); + } + + virtual void + instance_post (Type const&); + + virtual void + connection_pre (Type &o) + { + this->connection_pre (const_cast <Type const &> (o)); + } + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type &o) + { + this->connection_next (const_cast <Type const &> (o)); + } + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type &o) + { + this->connection_post (const_cast <Type const &> (o)); + } + + virtual void + connection_post (Type const&); + + virtual void + externalProperty_pre (Type &o) + { + this->externalProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_pre (Type const&); + + virtual void + externalProperty_next (Type &o) + { + this->externalProperty_next (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_next (Type const&); + + virtual void + externalProperty_post (Type &o) + { + this->externalProperty_post (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_post (Type const&); + + virtual void + dependsOn_pre (Type &o) + { + this->dependsOn_pre (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type &o) + { + this->dependsOn_next (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type &o) + { + this->dependsOn_post (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_post (Type const&); + + virtual void + artifact_pre (Type &o) + { + this->artifact_pre (const_cast <Type const &> (o)); + } + + virtual void + artifact_pre (Type const&); + + virtual void + artifact_next (Type &o) + { + this->artifact_next (const_cast <Type const &> (o)); + } + + virtual void + artifact_next (Type const&); + + virtual void + artifact_post (Type &o) + { + this->artifact_post (const_cast <Type const &> (o)); + } + + virtual void + artifact_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + localityConstraint_pre (Type &o) + { + this->localityConstraint_pre (const_cast <Type const &> (o)); + } + + virtual void + localityConstraint_pre (Type const&); + + virtual void + localityConstraint_next (Type &o) + { + this->localityConstraint_next (const_cast <Type const &> (o)); + } + + virtual void + localityConstraint_next (Type const&); + + virtual void + localityConstraint_post (Type &o) + { + this->localityConstraint_post (const_cast <Type const &> (o)); + } + + virtual void + localityConstraint_post (Type const&); + + protected: + deploymentPlan (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CDP_HPP diff --git a/modules/CIAO/tools/Config_Handlers/cid.cpp b/modules/CIAO/tools/Config_Handlers/cid.cpp new file mode 100644 index 00000000000..32e9bb6b924 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cid.cpp @@ -0,0 +1,6047 @@ +/* $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 "cid.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // ComponentPackageReference + // + + ComponentPackageReference:: + ComponentPackageReference (::CIAO::Config_Handlers::ComponentInterfaceDescription const& requiredType__) + : + ::XSCRT::Type (), + requiredType_ (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ComponentPackageReference:: + ComponentPackageReference (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 ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.requiredType_)), + regulator__ () + { + if (requiredUUID_.get ()) requiredUUID_->container (this); + if (requiredName_.get ()) requiredName_->container (this); + requiredType_->container (this); + } + + ComponentPackageReference& ComponentPackageReference:: + operator= (ComponentPackageReference const& s) + { + if (s.requiredUUID_.get ()) + requiredUUID (*(s.requiredUUID_)); + else + requiredUUID_.reset (0); + + if (s.requiredName_.get ()) + requiredName (*(s.requiredName_)); + else + requiredName_.reset (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 + // + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ComponentPackageReference:: + requiredType () const + { + return *requiredType_; + } + + void ComponentPackageReference:: + requiredType (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + *requiredType_ = e; + } + + + // SubcomponentInstantiationDescription + // + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (SubcomponentInstantiationDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + basePackage_ (s.basePackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageDescription (*s.basePackage_) : 0), + specializedConfig_ (s.specializedConfig_.get () ? new ::CIAO::Config_Handlers::PackageConfiguration (*s.specializedConfig_) : 0), + selectRequirement_ (s.selectRequirement_), + configProperty_ (s.configProperty_), + referencedPackage_ (s.referencedPackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageReference (*s.referencedPackage_) : 0), + importedPackage_ (s.importedPackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageImport (*s.importedPackage_) : 0), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + if (basePackage_.get ()) basePackage_->container (this); + if (specializedConfig_.get ()) specializedConfig_->container (this); + if (referencedPackage_.get ()) referencedPackage_->container (this); + if (importedPackage_.get ()) importedPackage_->container (this); + if (id_.get ()) id_->container (this); + } + + SubcomponentInstantiationDescription& SubcomponentInstantiationDescription:: + operator= (SubcomponentInstantiationDescription const& s) + { + name (*s.name_); + + if (s.basePackage_.get ()) + basePackage (*(s.basePackage_)); + else + basePackage_.reset (0); + + if (s.specializedConfig_.get ()) + specializedConfig (*(s.specializedConfig_)); + else + specializedConfig_.reset (0); + + selectRequirement_ = s.selectRequirement_; + + configProperty_ = s.configProperty_; + + if (s.referencedPackage_.get ()) + referencedPackage (*(s.referencedPackage_)); + else + referencedPackage_.reset (0); + + if (s.importedPackage_.get ()) + importedPackage (*(s.importedPackage_)); + else + importedPackage_.reset (0); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // SubcomponentInstantiationDescription + // + ::XMLSchema::string< ACE_TCHAR > const& SubcomponentInstantiationDescription:: + name () const + { + return *name_; + } + + void SubcomponentInstantiationDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // SubcomponentInstantiationDescription + // + bool SubcomponentInstantiationDescription:: + basePackage_p () const + { + return basePackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageDescription const& SubcomponentInstantiationDescription:: + basePackage () const + { + return *basePackage_; + } + + void SubcomponentInstantiationDescription:: + basePackage (::CIAO::Config_Handlers::ComponentPackageDescription const& e) + { + if (basePackage_.get ()) + { + *basePackage_ = e; + } + + else + { + basePackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > (new ::CIAO::Config_Handlers::ComponentPackageDescription (e)); + basePackage_->container (this); + } + } + + // SubcomponentInstantiationDescription + // + bool SubcomponentInstantiationDescription:: + specializedConfig_p () const + { + return specializedConfig_.get () != 0; + } + + ::CIAO::Config_Handlers::PackageConfiguration const& SubcomponentInstantiationDescription:: + specializedConfig () const + { + return *specializedConfig_; + } + + void SubcomponentInstantiationDescription:: + specializedConfig (::CIAO::Config_Handlers::PackageConfiguration const& e) + { + if (specializedConfig_.get ()) + { + *specializedConfig_ = e; + } + + else + { + specializedConfig_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > (new ::CIAO::Config_Handlers::PackageConfiguration (e)); + specializedConfig_->container (this); + } + } + + // SubcomponentInstantiationDescription + // + SubcomponentInstantiationDescription::selectRequirement_iterator SubcomponentInstantiationDescription:: + begin_selectRequirement () + { + return selectRequirement_.begin (); + } + + SubcomponentInstantiationDescription::selectRequirement_iterator SubcomponentInstantiationDescription:: + end_selectRequirement () + { + return selectRequirement_.end (); + } + + SubcomponentInstantiationDescription::selectRequirement_const_iterator SubcomponentInstantiationDescription:: + begin_selectRequirement () const + { + return selectRequirement_.begin (); + } + + SubcomponentInstantiationDescription::selectRequirement_const_iterator SubcomponentInstantiationDescription:: + end_selectRequirement () const + { + return selectRequirement_.end (); + } + + void SubcomponentInstantiationDescription:: + add_selectRequirement (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& e) + { + selectRequirement_.push_back (e); + } + + size_t SubcomponentInstantiationDescription:: + count_selectRequirement(void) const + { + return selectRequirement_.size (); + } + + // SubcomponentInstantiationDescription + // + SubcomponentInstantiationDescription::configProperty_iterator SubcomponentInstantiationDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + SubcomponentInstantiationDescription::configProperty_iterator SubcomponentInstantiationDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + SubcomponentInstantiationDescription::configProperty_const_iterator SubcomponentInstantiationDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + SubcomponentInstantiationDescription::configProperty_const_iterator SubcomponentInstantiationDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void SubcomponentInstantiationDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t SubcomponentInstantiationDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // SubcomponentInstantiationDescription + // + bool SubcomponentInstantiationDescription:: + referencedPackage_p () const + { + return referencedPackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageReference const& SubcomponentInstantiationDescription:: + referencedPackage () const + { + return *referencedPackage_; + } + + void SubcomponentInstantiationDescription:: + referencedPackage (::CIAO::Config_Handlers::ComponentPackageReference const& e) + { + if (referencedPackage_.get ()) + { + *referencedPackage_ = e; + } + + else + { + referencedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (new ::CIAO::Config_Handlers::ComponentPackageReference (e)); + referencedPackage_->container (this); + } + } + + // SubcomponentInstantiationDescription + // + bool SubcomponentInstantiationDescription:: + importedPackage_p () const + { + return importedPackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageImport const& SubcomponentInstantiationDescription:: + importedPackage () const + { + return *importedPackage_; + } + + void SubcomponentInstantiationDescription:: + importedPackage (::CIAO::Config_Handlers::ComponentPackageImport const& e) + { + if (importedPackage_.get ()) + { + *importedPackage_ = e; + } + + else + { + importedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > (new ::CIAO::Config_Handlers::ComponentPackageImport (e)); + importedPackage_->container (this); + } + } + + // SubcomponentInstantiationDescription + // + bool SubcomponentInstantiationDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& SubcomponentInstantiationDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& SubcomponentInstantiationDescription:: + id () + { + return *id_; + } + + void SubcomponentInstantiationDescription:: + 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); + } + } + + + // SubcomponentPropertyReference + // + + SubcomponentPropertyReference:: + SubcomponentPropertyReference (::XMLSchema::string< ACE_TCHAR > const& propertyName__, + ::CIAO::Config_Handlers::IdRef const& instance__) + : + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (propertyName__)), + instance_ (new ::CIAO::Config_Handlers::IdRef (instance__)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + SubcomponentPropertyReference:: + SubcomponentPropertyReference (SubcomponentPropertyReference const& s) + : + ::XSCRT::Type (), + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.propertyName_)), + instance_ (new ::CIAO::Config_Handlers::IdRef (*s.instance_)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + SubcomponentPropertyReference& SubcomponentPropertyReference:: + operator= (SubcomponentPropertyReference const& s) + { + propertyName (*s.propertyName_); + + instance (*s.instance_); + + return *this; + } + + + // SubcomponentPropertyReference + // + ::XMLSchema::string< ACE_TCHAR > const& SubcomponentPropertyReference:: + propertyName () const + { + return *propertyName_; + } + + void SubcomponentPropertyReference:: + propertyName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *propertyName_ = e; + } + + // SubcomponentPropertyReference + // + ::CIAO::Config_Handlers::IdRef const& SubcomponentPropertyReference:: + instance () const + { + return *instance_; + } + + void SubcomponentPropertyReference:: + instance (::CIAO::Config_Handlers::IdRef const& e) + { + *instance_ = e; + } + + + // AssemblyPropertyMapping + // + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& externalName__) + : + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (externalName__)), + regulator__ () + { + name_->container (this); + externalName_->container (this); + } + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (AssemblyPropertyMapping const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.externalName_)), + delegatesTo_ (s.delegatesTo_), + regulator__ () + { + name_->container (this); + externalName_->container (this); + } + + AssemblyPropertyMapping& AssemblyPropertyMapping:: + operator= (AssemblyPropertyMapping const& s) + { + name (*s.name_); + + externalName (*s.externalName_); + + delegatesTo_ = s.delegatesTo_; + + return *this; + } + + + // AssemblyPropertyMapping + // + ::XMLSchema::string< ACE_TCHAR > const& AssemblyPropertyMapping:: + name () const + { + return *name_; + } + + void AssemblyPropertyMapping:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AssemblyPropertyMapping + // + ::XMLSchema::string< ACE_TCHAR > const& AssemblyPropertyMapping:: + externalName () const + { + return *externalName_; + } + + void AssemblyPropertyMapping:: + externalName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *externalName_ = e; + } + + // AssemblyPropertyMapping + // + AssemblyPropertyMapping::delegatesTo_iterator AssemblyPropertyMapping:: + begin_delegatesTo () + { + return delegatesTo_.begin (); + } + + AssemblyPropertyMapping::delegatesTo_iterator AssemblyPropertyMapping:: + end_delegatesTo () + { + return delegatesTo_.end (); + } + + AssemblyPropertyMapping::delegatesTo_const_iterator AssemblyPropertyMapping:: + begin_delegatesTo () const + { + return delegatesTo_.begin (); + } + + AssemblyPropertyMapping::delegatesTo_const_iterator AssemblyPropertyMapping:: + end_delegatesTo () const + { + return delegatesTo_.end (); + } + + void AssemblyPropertyMapping:: + add_delegatesTo (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > const& e) + { + delegatesTo_.push_back (e); + } + + size_t AssemblyPropertyMapping:: + count_delegatesTo(void) const + { + return delegatesTo_.size (); + } + + + // LocalityKind + // + + LocalityKind::Value LocalityKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::LocalityKind const& a, ::CIAO::Config_Handlers::LocalityKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::LocalityKind const& a, ::CIAO::Config_Handlers::LocalityKind const& b) + { + return a.v_ != b.v_; + } + + LocalityKind:: + LocalityKind (LocalityKind::Value v) + : v_ (v) + { + } + + // Locality + // + + Locality:: + Locality (::CIAO::Config_Handlers::LocalityKind const& constraint__, + ::CIAO::Config_Handlers::IdRef const& constrainedInstance__) + : + constraint_ (new ::CIAO::Config_Handlers::LocalityKind (constraint__)), + constrainedInstance_ (new ::CIAO::Config_Handlers::IdRef (constrainedInstance__)), + regulator__ () + { + constraint_->container (this); + constrainedInstance_->container (this); + } + + Locality:: + Locality (Locality const& s) + : + ::XSCRT::Type (), + constraint_ (new ::CIAO::Config_Handlers::LocalityKind (*s.constraint_)), + constrainedInstance_ (new ::CIAO::Config_Handlers::IdRef (*s.constrainedInstance_)), + regulator__ () + { + constraint_->container (this); + constrainedInstance_->container (this); + } + + Locality& Locality:: + operator= (Locality const& s) + { + constraint (*s.constraint_); + + constrainedInstance (*s.constrainedInstance_); + + return *this; + } + + + // Locality + // + ::CIAO::Config_Handlers::LocalityKind const& Locality:: + constraint () const + { + return *constraint_; + } + + void Locality:: + constraint (::CIAO::Config_Handlers::LocalityKind const& e) + { + *constraint_ = e; + } + + // Locality + // + ::CIAO::Config_Handlers::IdRef const& Locality:: + constrainedInstance () const + { + return *constrainedInstance_; + } + + void Locality:: + constrainedInstance (::CIAO::Config_Handlers::IdRef const& e) + { + *constrainedInstance_ = e; + } + + + // ComponentAssemblyDescription + // + + ComponentAssemblyDescription:: + ComponentAssemblyDescription () + : + regulator__ () + { + } + + ComponentAssemblyDescription:: + ComponentAssemblyDescription (ComponentAssemblyDescription const& s) + : + ::XSCRT::Type (), + instance_ (s.instance_), + connection_ (s.connection_), + externalProperty_ (s.externalProperty_), + locality_ (s.locality_), + regulator__ () + { + } + + ComponentAssemblyDescription& ComponentAssemblyDescription:: + operator= (ComponentAssemblyDescription const& s) + { + instance_ = s.instance_; + + connection_ = s.connection_; + + externalProperty_ = s.externalProperty_; + + locality_ = s.locality_; + + return *this; + } + + + // ComponentAssemblyDescription + // + ComponentAssemblyDescription::instance_iterator ComponentAssemblyDescription:: + begin_instance () + { + return instance_.begin (); + } + + ComponentAssemblyDescription::instance_iterator ComponentAssemblyDescription:: + end_instance () + { + return instance_.end (); + } + + ComponentAssemblyDescription::instance_const_iterator ComponentAssemblyDescription:: + begin_instance () const + { + return instance_.begin (); + } + + ComponentAssemblyDescription::instance_const_iterator ComponentAssemblyDescription:: + end_instance () const + { + return instance_.end (); + } + + void ComponentAssemblyDescription:: + add_instance (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > const& e) + { + instance_.push_back (e); + } + + size_t ComponentAssemblyDescription:: + count_instance(void) const + { + return instance_.size (); + } + + // ComponentAssemblyDescription + // + ComponentAssemblyDescription::connection_iterator ComponentAssemblyDescription:: + begin_connection () + { + return connection_.begin (); + } + + ComponentAssemblyDescription::connection_iterator ComponentAssemblyDescription:: + end_connection () + { + return connection_.end (); + } + + ComponentAssemblyDescription::connection_const_iterator ComponentAssemblyDescription:: + begin_connection () const + { + return connection_.begin (); + } + + ComponentAssemblyDescription::connection_const_iterator ComponentAssemblyDescription:: + end_connection () const + { + return connection_.end (); + } + + void ComponentAssemblyDescription:: + add_connection (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > const& e) + { + connection_.push_back (e); + } + + size_t ComponentAssemblyDescription:: + count_connection(void) const + { + return connection_.size (); + } + + // ComponentAssemblyDescription + // + ComponentAssemblyDescription::externalProperty_iterator ComponentAssemblyDescription:: + begin_externalProperty () + { + return externalProperty_.begin (); + } + + ComponentAssemblyDescription::externalProperty_iterator ComponentAssemblyDescription:: + end_externalProperty () + { + return externalProperty_.end (); + } + + ComponentAssemblyDescription::externalProperty_const_iterator ComponentAssemblyDescription:: + begin_externalProperty () const + { + return externalProperty_.begin (); + } + + ComponentAssemblyDescription::externalProperty_const_iterator ComponentAssemblyDescription:: + end_externalProperty () const + { + return externalProperty_.end (); + } + + void ComponentAssemblyDescription:: + add_externalProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > const& e) + { + externalProperty_.push_back (e); + } + + size_t ComponentAssemblyDescription:: + count_externalProperty(void) const + { + return externalProperty_.size (); + } + + // ComponentAssemblyDescription + // + ComponentAssemblyDescription::locality_iterator ComponentAssemblyDescription:: + begin_locality () + { + return locality_.begin (); + } + + ComponentAssemblyDescription::locality_iterator ComponentAssemblyDescription:: + end_locality () + { + return locality_.end (); + } + + ComponentAssemblyDescription::locality_const_iterator ComponentAssemblyDescription:: + begin_locality () const + { + return locality_.begin (); + } + + ComponentAssemblyDescription::locality_const_iterator ComponentAssemblyDescription:: + end_locality () const + { + return locality_.end (); + } + + void ComponentAssemblyDescription:: + add_locality (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > const& e) + { + locality_.push_back (e); + } + + size_t ComponentAssemblyDescription:: + count_locality(void) const + { + return locality_.size (); + } + + + // MonolithicImplementationDescription + // + + MonolithicImplementationDescription:: + MonolithicImplementationDescription () + : + regulator__ () + { + } + + MonolithicImplementationDescription:: + MonolithicImplementationDescription (MonolithicImplementationDescription const& s) + : + ::XSCRT::Type (), + nodeExecParameter_ (s.nodeExecParameter_), + componentExecParameter_ (s.componentExecParameter_), + deployRequirement_ (s.deployRequirement_), + primaryArtifact_ (s.primaryArtifact_), + regulator__ () + { + } + + MonolithicImplementationDescription& MonolithicImplementationDescription:: + operator= (MonolithicImplementationDescription const& s) + { + nodeExecParameter_ = s.nodeExecParameter_; + + componentExecParameter_ = s.componentExecParameter_; + + deployRequirement_ = s.deployRequirement_; + + primaryArtifact_ = s.primaryArtifact_; + + return *this; + } + + + // MonolithicImplementationDescription + // + MonolithicImplementationDescription::nodeExecParameter_iterator MonolithicImplementationDescription:: + begin_nodeExecParameter () + { + return nodeExecParameter_.begin (); + } + + MonolithicImplementationDescription::nodeExecParameter_iterator MonolithicImplementationDescription:: + end_nodeExecParameter () + { + return nodeExecParameter_.end (); + } + + MonolithicImplementationDescription::nodeExecParameter_const_iterator MonolithicImplementationDescription:: + begin_nodeExecParameter () const + { + return nodeExecParameter_.begin (); + } + + MonolithicImplementationDescription::nodeExecParameter_const_iterator MonolithicImplementationDescription:: + end_nodeExecParameter () const + { + return nodeExecParameter_.end (); + } + + void MonolithicImplementationDescription:: + add_nodeExecParameter (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + nodeExecParameter_.push_back (e); + } + + size_t MonolithicImplementationDescription:: + count_nodeExecParameter(void) const + { + return nodeExecParameter_.size (); + } + + // MonolithicImplementationDescription + // + MonolithicImplementationDescription::componentExecParameter_iterator MonolithicImplementationDescription:: + begin_componentExecParameter () + { + return componentExecParameter_.begin (); + } + + MonolithicImplementationDescription::componentExecParameter_iterator MonolithicImplementationDescription:: + end_componentExecParameter () + { + return componentExecParameter_.end (); + } + + MonolithicImplementationDescription::componentExecParameter_const_iterator MonolithicImplementationDescription:: + begin_componentExecParameter () const + { + return componentExecParameter_.begin (); + } + + MonolithicImplementationDescription::componentExecParameter_const_iterator MonolithicImplementationDescription:: + end_componentExecParameter () const + { + return componentExecParameter_.end (); + } + + void MonolithicImplementationDescription:: + add_componentExecParameter (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + componentExecParameter_.push_back (e); + } + + size_t MonolithicImplementationDescription:: + count_componentExecParameter(void) const + { + return componentExecParameter_.size (); + } + + // MonolithicImplementationDescription + // + MonolithicImplementationDescription::deployRequirement_iterator MonolithicImplementationDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + MonolithicImplementationDescription::deployRequirement_iterator MonolithicImplementationDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + MonolithicImplementationDescription::deployRequirement_const_iterator MonolithicImplementationDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + MonolithicImplementationDescription::deployRequirement_const_iterator MonolithicImplementationDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void MonolithicImplementationDescription:: + add_deployRequirement (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > const& e) + { + deployRequirement_.push_back (e); + } + + size_t MonolithicImplementationDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // MonolithicImplementationDescription + // + MonolithicImplementationDescription::primaryArtifact_iterator MonolithicImplementationDescription:: + begin_primaryArtifact () + { + return primaryArtifact_.begin (); + } + + MonolithicImplementationDescription::primaryArtifact_iterator MonolithicImplementationDescription:: + end_primaryArtifact () + { + return primaryArtifact_.end (); + } + + MonolithicImplementationDescription::primaryArtifact_const_iterator MonolithicImplementationDescription:: + begin_primaryArtifact () const + { + return primaryArtifact_.begin (); + } + + MonolithicImplementationDescription::primaryArtifact_const_iterator MonolithicImplementationDescription:: + end_primaryArtifact () const + { + return primaryArtifact_.end (); + } + + void MonolithicImplementationDescription:: + add_primaryArtifact (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > const& e) + { + primaryArtifact_.push_back (e); + } + + size_t MonolithicImplementationDescription:: + count_primaryArtifact(void) const + { + return primaryArtifact_.size (); + } + + + // ComponentImplementationDescription + // + + ComponentImplementationDescription:: + ComponentImplementationDescription () + : + regulator__ () + { + } + + ComponentImplementationDescription:: + ComponentImplementationDescription (ComponentImplementationDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + implements_ (s.implements_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.implements_) : 0), + assemblyImpl_ (s.assemblyImpl_.get () ? new ::CIAO::Config_Handlers::ComponentAssemblyDescription (*s.assemblyImpl_) : 0), + monolithicImpl_ (s.monolithicImpl_.get () ? new ::CIAO::Config_Handlers::MonolithicImplementationDescription (*s.monolithicImpl_) : 0), + configProperty_ (s.configProperty_), + capability_ (s.capability_), + dependsOn_ (s.dependsOn_), + infoProperty_ (s.infoProperty_), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (implements_.get ()) implements_->container (this); + if (assemblyImpl_.get ()) assemblyImpl_->container (this); + if (monolithicImpl_.get ()) monolithicImpl_->container (this); + if (href_.get ()) href_->container (this); + } + + ComponentImplementationDescription& ComponentImplementationDescription:: + operator= (ComponentImplementationDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.implements_.get ()) + implements (*(s.implements_)); + else + implements_.reset (0); + + if (s.assemblyImpl_.get ()) + assemblyImpl (*(s.assemblyImpl_)); + else + assemblyImpl_.reset (0); + + if (s.monolithicImpl_.get ()) + monolithicImpl (*(s.monolithicImpl_)); + else + monolithicImpl_.reset (0); + + configProperty_ = s.configProperty_; + + capability_ = s.capability_; + + dependsOn_ = s.dependsOn_; + + infoProperty_ = s.infoProperty_; + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentImplementationDescription:: + label () const + { + return *label_; + } + + void ComponentImplementationDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentImplementationDescription:: + UUID () const + { + return *UUID_; + } + + void ComponentImplementationDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + implements_p () const + { + return implements_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ComponentImplementationDescription:: + implements () const + { + return *implements_; + } + + void ComponentImplementationDescription:: + implements (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + if (implements_.get ()) + { + *implements_ = e; + } + + else + { + implements_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + implements_->container (this); + } + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + assemblyImpl_p () const + { + return assemblyImpl_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentAssemblyDescription const& ComponentImplementationDescription:: + assemblyImpl () const + { + return *assemblyImpl_; + } + + void ComponentImplementationDescription:: + assemblyImpl (::CIAO::Config_Handlers::ComponentAssemblyDescription const& e) + { + if (assemblyImpl_.get ()) + { + *assemblyImpl_ = e; + } + + else + { + assemblyImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentAssemblyDescription > (new ::CIAO::Config_Handlers::ComponentAssemblyDescription (e)); + assemblyImpl_->container (this); + } + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + monolithicImpl_p () const + { + return monolithicImpl_.get () != 0; + } + + ::CIAO::Config_Handlers::MonolithicImplementationDescription const& ComponentImplementationDescription:: + monolithicImpl () const + { + return *monolithicImpl_; + } + + void ComponentImplementationDescription:: + monolithicImpl (::CIAO::Config_Handlers::MonolithicImplementationDescription const& e) + { + if (monolithicImpl_.get ()) + { + *monolithicImpl_ = e; + } + + else + { + monolithicImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > (new ::CIAO::Config_Handlers::MonolithicImplementationDescription (e)); + monolithicImpl_->container (this); + } + } + + // ComponentImplementationDescription + // + ComponentImplementationDescription::configProperty_iterator ComponentImplementationDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + ComponentImplementationDescription::configProperty_iterator ComponentImplementationDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + ComponentImplementationDescription::configProperty_const_iterator ComponentImplementationDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + ComponentImplementationDescription::configProperty_const_iterator ComponentImplementationDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void ComponentImplementationDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t ComponentImplementationDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // ComponentImplementationDescription + // + ComponentImplementationDescription::capability_iterator ComponentImplementationDescription:: + begin_capability () + { + return capability_.begin (); + } + + ComponentImplementationDescription::capability_iterator ComponentImplementationDescription:: + end_capability () + { + return capability_.end (); + } + + ComponentImplementationDescription::capability_const_iterator ComponentImplementationDescription:: + begin_capability () const + { + return capability_.begin (); + } + + ComponentImplementationDescription::capability_const_iterator ComponentImplementationDescription:: + end_capability () const + { + return capability_.end (); + } + + void ComponentImplementationDescription:: + add_capability (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > const& e) + { + capability_.push_back (e); + } + + size_t ComponentImplementationDescription:: + count_capability(void) const + { + return capability_.size (); + } + + // ComponentImplementationDescription + // + ComponentImplementationDescription::dependsOn_iterator ComponentImplementationDescription:: + begin_dependsOn () + { + return dependsOn_.begin (); + } + + ComponentImplementationDescription::dependsOn_iterator ComponentImplementationDescription:: + end_dependsOn () + { + return dependsOn_.end (); + } + + ComponentImplementationDescription::dependsOn_const_iterator ComponentImplementationDescription:: + begin_dependsOn () const + { + return dependsOn_.begin (); + } + + ComponentImplementationDescription::dependsOn_const_iterator ComponentImplementationDescription:: + end_dependsOn () const + { + return dependsOn_.end (); + } + + void ComponentImplementationDescription:: + add_dependsOn (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& e) + { + dependsOn_.push_back (e); + } + + size_t ComponentImplementationDescription:: + count_dependsOn(void) const + { + return dependsOn_.size (); + } + + // ComponentImplementationDescription + // + ComponentImplementationDescription::infoProperty_iterator ComponentImplementationDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ComponentImplementationDescription::infoProperty_iterator ComponentImplementationDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ComponentImplementationDescription::infoProperty_const_iterator ComponentImplementationDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ComponentImplementationDescription::infoProperty_const_iterator ComponentImplementationDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ComponentImplementationDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ComponentImplementationDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentImplementationDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ComponentImplementationDescription:: + href () + { + return *href_; + } + + void ComponentImplementationDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + + + // ConnectorImplementationDescription + // + + ConnectorImplementationDescription:: + ConnectorImplementationDescription () + : + regulator__ () + { + } + + ConnectorImplementationDescription:: + ConnectorImplementationDescription (ConnectorImplementationDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + implements_ (s.implements_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.implements_) : 0), + assemblyImpl_ (s.assemblyImpl_.get () ? new ::CIAO::Config_Handlers::ComponentAssemblyDescription (*s.assemblyImpl_) : 0), + monolithicImpl_ (s.monolithicImpl_.get () ? new ::CIAO::Config_Handlers::MonolithicImplementationDescription (*s.monolithicImpl_) : 0), + configProperty_ (s.configProperty_), + capability_ (s.capability_), + dependsOn_ (s.dependsOn_), + infoProperty_ (s.infoProperty_), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (implements_.get ()) implements_->container (this); + if (assemblyImpl_.get ()) assemblyImpl_->container (this); + if (monolithicImpl_.get ()) monolithicImpl_->container (this); + if (href_.get ()) href_->container (this); + } + + ConnectorImplementationDescription& ConnectorImplementationDescription:: + operator= (ConnectorImplementationDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.implements_.get ()) + implements (*(s.implements_)); + else + implements_.reset (0); + + if (s.assemblyImpl_.get ()) + assemblyImpl (*(s.assemblyImpl_)); + else + assemblyImpl_.reset (0); + + if (s.monolithicImpl_.get ()) + monolithicImpl (*(s.monolithicImpl_)); + else + monolithicImpl_.reset (0); + + configProperty_ = s.configProperty_; + + capability_ = s.capability_; + + dependsOn_ = s.dependsOn_; + + infoProperty_ = s.infoProperty_; + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorImplementationDescription:: + label () const + { + return *label_; + } + + void ConnectorImplementationDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorImplementationDescription:: + UUID () const + { + return *UUID_; + } + + void ConnectorImplementationDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + implements_p () const + { + return implements_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ConnectorImplementationDescription:: + implements () const + { + return *implements_; + } + + void ConnectorImplementationDescription:: + implements (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + if (implements_.get ()) + { + *implements_ = e; + } + + else + { + implements_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + implements_->container (this); + } + } + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + assemblyImpl_p () const + { + return assemblyImpl_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentAssemblyDescription const& ConnectorImplementationDescription:: + assemblyImpl () const + { + return *assemblyImpl_; + } + + void ConnectorImplementationDescription:: + assemblyImpl (::CIAO::Config_Handlers::ComponentAssemblyDescription const& e) + { + if (assemblyImpl_.get ()) + { + *assemblyImpl_ = e; + } + + else + { + assemblyImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentAssemblyDescription > (new ::CIAO::Config_Handlers::ComponentAssemblyDescription (e)); + assemblyImpl_->container (this); + } + } + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + monolithicImpl_p () const + { + return monolithicImpl_.get () != 0; + } + + ::CIAO::Config_Handlers::MonolithicImplementationDescription const& ConnectorImplementationDescription:: + monolithicImpl () const + { + return *monolithicImpl_; + } + + void ConnectorImplementationDescription:: + monolithicImpl (::CIAO::Config_Handlers::MonolithicImplementationDescription const& e) + { + if (monolithicImpl_.get ()) + { + *monolithicImpl_ = e; + } + + else + { + monolithicImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > (new ::CIAO::Config_Handlers::MonolithicImplementationDescription (e)); + monolithicImpl_->container (this); + } + } + + // ConnectorImplementationDescription + // + ConnectorImplementationDescription::configProperty_iterator ConnectorImplementationDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + ConnectorImplementationDescription::configProperty_iterator ConnectorImplementationDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + ConnectorImplementationDescription::configProperty_const_iterator ConnectorImplementationDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + ConnectorImplementationDescription::configProperty_const_iterator ConnectorImplementationDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void ConnectorImplementationDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t ConnectorImplementationDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // ConnectorImplementationDescription + // + ConnectorImplementationDescription::capability_iterator ConnectorImplementationDescription:: + begin_capability () + { + return capability_.begin (); + } + + ConnectorImplementationDescription::capability_iterator ConnectorImplementationDescription:: + end_capability () + { + return capability_.end (); + } + + ConnectorImplementationDescription::capability_const_iterator ConnectorImplementationDescription:: + begin_capability () const + { + return capability_.begin (); + } + + ConnectorImplementationDescription::capability_const_iterator ConnectorImplementationDescription:: + end_capability () const + { + return capability_.end (); + } + + void ConnectorImplementationDescription:: + add_capability (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > const& e) + { + capability_.push_back (e); + } + + size_t ConnectorImplementationDescription:: + count_capability(void) const + { + return capability_.size (); + } + + // ConnectorImplementationDescription + // + ConnectorImplementationDescription::dependsOn_iterator ConnectorImplementationDescription:: + begin_dependsOn () + { + return dependsOn_.begin (); + } + + ConnectorImplementationDescription::dependsOn_iterator ConnectorImplementationDescription:: + end_dependsOn () + { + return dependsOn_.end (); + } + + ConnectorImplementationDescription::dependsOn_const_iterator ConnectorImplementationDescription:: + begin_dependsOn () const + { + return dependsOn_.begin (); + } + + ConnectorImplementationDescription::dependsOn_const_iterator ConnectorImplementationDescription:: + end_dependsOn () const + { + return dependsOn_.end (); + } + + void ConnectorImplementationDescription:: + add_dependsOn (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& e) + { + dependsOn_.push_back (e); + } + + size_t ConnectorImplementationDescription:: + count_dependsOn(void) const + { + return dependsOn_.size (); + } + + // ConnectorImplementationDescription + // + ConnectorImplementationDescription::infoProperty_iterator ConnectorImplementationDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ConnectorImplementationDescription::infoProperty_iterator ConnectorImplementationDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ConnectorImplementationDescription::infoProperty_const_iterator ConnectorImplementationDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ConnectorImplementationDescription::infoProperty_const_iterator ConnectorImplementationDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ConnectorImplementationDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ConnectorImplementationDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ConnectorImplementationDescription + // + bool ConnectorImplementationDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorImplementationDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ConnectorImplementationDescription:: + href () + { + return *href_; + } + + void ConnectorImplementationDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // 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 == ACE_TEXT("requiredUUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredUUID (t); + } + + else if (n == ACE_TEXT("requiredName")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredName (t); + } + + else if (n == ACE_TEXT("requiredType")) + { + requiredType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + requiredType_->container (this); + } + + else + { + } + } + } + + // SubcomponentInstantiationDescription + // + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("basePackage")) + { + ::CIAO::Config_Handlers::ComponentPackageDescription t (e); + basePackage (t); + } + + else if (n == ACE_TEXT("specializedConfig")) + { + ::CIAO::Config_Handlers::PackageConfiguration t (e); + specializedConfig (t); + } + + else if (n == ACE_TEXT("selectRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_selectRequirement (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("referencedPackage")) + { + ::CIAO::Config_Handlers::ComponentPackageReference t (e); + referencedPackage (t); + } + + else if (n == ACE_TEXT("importedPackage")) + { + ::CIAO::Config_Handlers::ComponentPackageImport t (e); + importedPackage (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 == ACE_TEXT ("id")) + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + std::basic_string<ACE_TCHAR> temp ((*id_).c_str()); + (*ACE_Singleton<ID_Map::TSS_ID_Map, ACE_Null_Mutex>::instance())-> + add_id(temp, dynamic_cast<XSCRT::Type*> (this)); + } + + else + { + } + } + } + + // SubcomponentPropertyReference + // + + SubcomponentPropertyReference:: + SubcomponentPropertyReference (::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 == ACE_TEXT("propertyName")) + { + propertyName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + propertyName_->container (this); + } + + else if (n == ACE_TEXT("instance")) + { + instance_ = ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > (new ::CIAO::Config_Handlers::IdRef (e)); + instance_->container (this); + } + + else + { + } + } + } + + // AssemblyPropertyMapping + // + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("externalName")) + { + externalName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + externalName_->container (this); + } + + else if (n == ACE_TEXT("delegatesTo")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SubcomponentPropertyReference (e)); + add_delegatesTo (t); + } + + else + { + } + } + } + + // LocalityKind + // + + LocalityKind:: + LocalityKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == ACE_TEXT ("SameNodeAnyProcess")) v_ = SameNodeAnyProcess_l; + else if (v == ACE_TEXT ("SameNodeSameProcess")) v_ = SameNodeSameProcess_l; + else if (v == ACE_TEXT ("SameNodeDifferentProcess")) v_ = SameNodeDifferentProcess_l; + else if (v == ACE_TEXT ("DifferentNode")) v_ = DifferentNode_l; + else if (v == ACE_TEXT ("DifferentProcess")) v_ = DifferentProcess_l; + else if (v == ACE_TEXT ("NoConstraint")) v_ = NoConstraint_l; + else + { + } + } + + LocalityKind:: + LocalityKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == ACE_TEXT ("SameNodeAnyProcess")) v_ = SameNodeAnyProcess_l; + else if (v == ACE_TEXT ("SameNodeSameProcess")) v_ = SameNodeSameProcess_l; + else if (v == ACE_TEXT ("SameNodeDifferentProcess")) v_ = SameNodeDifferentProcess_l; + else if (v == ACE_TEXT ("DifferentNode")) v_ = DifferentNode_l; + else if (v == ACE_TEXT ("DifferentProcess")) v_ = DifferentProcess_l; + else if (v == ACE_TEXT ("NoConstraint")) v_ = NoConstraint_l; + else + { + } + } + + LocalityKind const LocalityKind::SameNodeAnyProcess (LocalityKind::SameNodeAnyProcess_l); + LocalityKind const LocalityKind::SameNodeSameProcess (LocalityKind::SameNodeSameProcess_l); + LocalityKind const LocalityKind::SameNodeDifferentProcess (LocalityKind::SameNodeDifferentProcess_l); + LocalityKind const LocalityKind::DifferentNode (LocalityKind::DifferentNode_l); + LocalityKind const LocalityKind::DifferentProcess (LocalityKind::DifferentProcess_l); + LocalityKind const LocalityKind::NoConstraint (LocalityKind::NoConstraint_l); + + // Locality + // + + Locality:: + Locality (::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 == ACE_TEXT("constraint")) + { + constraint_ = ::std::auto_ptr< ::CIAO::Config_Handlers::LocalityKind > (new ::CIAO::Config_Handlers::LocalityKind (e)); + constraint_->container (this); + } + + else if (n == ACE_TEXT("constrainedInstance")) + { + constrainedInstance_ = ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > (new ::CIAO::Config_Handlers::IdRef (e)); + constrainedInstance_->container (this); + } + + else + { + } + } + } + + // ComponentAssemblyDescription + // + + ComponentAssemblyDescription:: + ComponentAssemblyDescription (::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 == ACE_TEXT("instance")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::SubcomponentInstantiationDescription (e)); + add_instance (t); + } + + else if (n == ACE_TEXT("connection")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::AssemblyConnectionDescription (e)); + add_connection (t); + } + + else if (n == ACE_TEXT("externalProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::AssemblyPropertyMapping (e)); + add_externalProperty (t); + } + + else if (n == ACE_TEXT("locality")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Locality (e)); + add_locality (t); + } + + else + { + } + } + } + + // MonolithicImplementationDescription + // + + MonolithicImplementationDescription:: + MonolithicImplementationDescription (::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 == ACE_TEXT("nodeExecParameter")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_nodeExecParameter (t); + } + + else if (n == ACE_TEXT("componentExecParameter")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_componentExecParameter (t); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ImplementationRequirement (e)); + add_deployRequirement (t); + } + + else if (n == ACE_TEXT("primaryArtifact")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::NamedImplementationArtifact (e)); + add_primaryArtifact (t); + } + + else + { + } + } + } + + // ComponentImplementationDescription + // + + ComponentImplementationDescription:: + ComponentImplementationDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("implements")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + implements (t); + } + + else if (n == ACE_TEXT("assemblyImpl")) + { + ::CIAO::Config_Handlers::ComponentAssemblyDescription t (e); + assemblyImpl (t); + } + + else if (n == ACE_TEXT("monolithicImpl")) + { + ::CIAO::Config_Handlers::MonolithicImplementationDescription t (e); + monolithicImpl (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("capability")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Capability (e)); + add_capability (t); + } + + else if (n == ACE_TEXT("dependsOn")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ImplementationDependency (e)); + add_dependsOn (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (t); + } + + else + { + } + } + } + + // ConnectorImplementationDescription + // + + ConnectorImplementationDescription:: + ConnectorImplementationDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("implements")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + implements (t); + } + + else if (n == ACE_TEXT("assemblyImpl")) + { + ::CIAO::Config_Handlers::ComponentAssemblyDescription t (e); + assemblyImpl (t); + } + + else if (n == ACE_TEXT("monolithicImpl")) + { + ::CIAO::Config_Handlers::MonolithicImplementationDescription t (e); + monolithicImpl (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("capability")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Capability (e)); + add_capability (t); + } + + else if (n == ACE_TEXT("dependsOn")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ImplementationDependency (e)); + add_dependsOn (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (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 ComponentPackageReferenceTypeInfoInitializer + { + ComponentPackageReferenceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::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 SubcomponentInstantiationDescriptionTypeInfoInitializer + { + SubcomponentInstantiationDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::SubcomponentInstantiationDescription)); + ::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)); + } + }; + + SubcomponentInstantiationDescriptionTypeInfoInitializer SubcomponentInstantiationDescriptionTypeInfoInitializer_; + + struct SubcomponentPropertyReferenceTypeInfoInitializer + { + SubcomponentPropertyReferenceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::SubcomponentPropertyReference)); + ::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)); + } + }; + + SubcomponentPropertyReferenceTypeInfoInitializer SubcomponentPropertyReferenceTypeInfoInitializer_; + + struct AssemblyPropertyMappingTypeInfoInitializer + { + AssemblyPropertyMappingTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::AssemblyPropertyMapping)); + ::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)); + } + }; + + AssemblyPropertyMappingTypeInfoInitializer AssemblyPropertyMappingTypeInfoInitializer_; + + struct LocalityKindTypeInfoInitializer + { + LocalityKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (LocalityKind)); + ::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)); + } + }; + + LocalityKindTypeInfoInitializer LocalityKindTypeInfoInitializer_; + + struct LocalityTypeInfoInitializer + { + LocalityTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::Locality)); + ::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)); + } + }; + + LocalityTypeInfoInitializer LocalityTypeInfoInitializer_; + + struct ComponentAssemblyDescriptionTypeInfoInitializer + { + ComponentAssemblyDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ComponentAssemblyDescription)); + ::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)); + } + }; + + ComponentAssemblyDescriptionTypeInfoInitializer ComponentAssemblyDescriptionTypeInfoInitializer_; + + struct MonolithicImplementationDescriptionTypeInfoInitializer + { + MonolithicImplementationDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::MonolithicImplementationDescription)); + ::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)); + } + }; + + MonolithicImplementationDescriptionTypeInfoInitializer MonolithicImplementationDescriptionTypeInfoInitializer_; + + struct ComponentImplementationDescriptionTypeInfoInitializer + { + ComponentImplementationDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ComponentImplementationDescription)); + ::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)); + } + }; + + ComponentImplementationDescriptionTypeInfoInitializer ComponentImplementationDescriptionTypeInfoInitializer_; + + struct ConnectorImplementationDescriptionTypeInfoInitializer + { + ConnectorImplementationDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ConnectorImplementationDescription)); + ::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)); + } + }; + + ConnectorImplementationDescriptionTypeInfoInitializer ConnectorImplementationDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // 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&) + { + } + + // SubcomponentInstantiationDescription + // + // + + void SubcomponentInstantiationDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.basePackage_p ()) basePackage (o); + else basePackage_none (o); + if (o.specializedConfig_p ()) specializedConfig (o); + else specializedConfig_none (o); + selectRequirement (o); + configProperty (o); + if (o.referencedPackage_p ()) referencedPackage (o); + else referencedPackage_none (o); + if (o.importedPackage_p ()) importedPackage (o); + else importedPackage_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void SubcomponentInstantiationDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.basePackage_p ()) basePackage (o); + else basePackage_none (o); + if (o.specializedConfig_p ()) specializedConfig (o); + else specializedConfig_none (o); + selectRequirement (o); + configProperty (o); + if (o.referencedPackage_p ()) referencedPackage (o); + else referencedPackage_none (o); + if (o.importedPackage_p ()) importedPackage (o); + else importedPackage_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void SubcomponentInstantiationDescription:: + pre (Type&) + { + } + + void SubcomponentInstantiationDescription:: + pre (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void SubcomponentInstantiationDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void SubcomponentInstantiationDescription:: + basePackage (Type& o) + { + dispatch (o.basePackage ()); + } + + void SubcomponentInstantiationDescription:: + basePackage (Type const& o) + { + dispatch (o.basePackage ()); + } + + void SubcomponentInstantiationDescription:: + basePackage_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + basePackage_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + specializedConfig (Type& o) + { + dispatch (o.specializedConfig ()); + } + + void SubcomponentInstantiationDescription:: + specializedConfig (Type const& o) + { + dispatch (o.specializedConfig ()); + } + + void SubcomponentInstantiationDescription:: + specializedConfig_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + specializedConfig_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription::selectRequirement_iterator b (o.begin_selectRequirement()), e (o.end_selectRequirement()); + + if (b != e) + { + selectRequirement_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) selectRequirement_next (o); + } + + selectRequirement_post (o); + } + + else selectRequirement_none (o); + } + + void SubcomponentInstantiationDescription:: + selectRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription::selectRequirement_const_iterator b (o.begin_selectRequirement()), e (o.end_selectRequirement()); + + if (b != e) + { + selectRequirement_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) selectRequirement_next (o); + } + + selectRequirement_post (o); + } + + else selectRequirement_none (o); + } + + void SubcomponentInstantiationDescription:: + selectRequirement_pre (Type&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_pre (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_next (Type&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_next (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_post (Type&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_post (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + selectRequirement_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription::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 SubcomponentInstantiationDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription::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 SubcomponentInstantiationDescription:: + configProperty_pre (Type&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_pre (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_next (Type&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_next (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_post (Type&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_post (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + configProperty_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + referencedPackage (Type& o) + { + dispatch (o.referencedPackage ()); + } + + void SubcomponentInstantiationDescription:: + referencedPackage (Type const& o) + { + dispatch (o.referencedPackage ()); + } + + void SubcomponentInstantiationDescription:: + referencedPackage_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + referencedPackage_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + importedPackage (Type& o) + { + dispatch (o.importedPackage ()); + } + + void SubcomponentInstantiationDescription:: + importedPackage (Type const& o) + { + dispatch (o.importedPackage ()); + } + + void SubcomponentInstantiationDescription:: + importedPackage_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + importedPackage_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void SubcomponentInstantiationDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void SubcomponentInstantiationDescription:: + id_none (Type&) + { + } + + void SubcomponentInstantiationDescription:: + id_none (Type const&) + { + } + + void SubcomponentInstantiationDescription:: + post (Type&) + { + } + + void SubcomponentInstantiationDescription:: + post (Type const&) + { + } + + // SubcomponentPropertyReference + // + // + + void SubcomponentPropertyReference:: + traverse (Type& o) + { + pre (o); + propertyName (o); + instance (o); + post (o); + } + + void SubcomponentPropertyReference:: + traverse (Type const& o) + { + pre (o); + propertyName (o); + instance (o); + post (o); + } + + void SubcomponentPropertyReference:: + pre (Type&) + { + } + + void SubcomponentPropertyReference:: + pre (Type const&) + { + } + + void SubcomponentPropertyReference:: + propertyName (Type& o) + { + dispatch (o.propertyName ()); + } + + void SubcomponentPropertyReference:: + propertyName (Type const& o) + { + dispatch (o.propertyName ()); + } + + void SubcomponentPropertyReference:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPropertyReference:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPropertyReference:: + post (Type&) + { + } + + void SubcomponentPropertyReference:: + post (Type const&) + { + } + + // AssemblyPropertyMapping + // + // + + void AssemblyPropertyMapping:: + traverse (Type& o) + { + pre (o); + name (o); + externalName (o); + delegatesTo (o); + post (o); + } + + void AssemblyPropertyMapping:: + traverse (Type const& o) + { + pre (o); + name (o); + externalName (o); + delegatesTo (o); + post (o); + } + + void AssemblyPropertyMapping:: + pre (Type&) + { + } + + void AssemblyPropertyMapping:: + pre (Type const&) + { + } + + void AssemblyPropertyMapping:: + name (Type& o) + { + dispatch (o.name ()); + } + + void AssemblyPropertyMapping:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void AssemblyPropertyMapping:: + externalName (Type& o) + { + dispatch (o.externalName ()); + } + + void AssemblyPropertyMapping:: + externalName (Type const& o) + { + dispatch (o.externalName ()); + } + + void AssemblyPropertyMapping:: + delegatesTo (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::AssemblyPropertyMapping::delegatesTo_iterator b (o.begin_delegatesTo()), e (o.end_delegatesTo()); + + if (b != e) + { + delegatesTo_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) delegatesTo_next (o); + } + + delegatesTo_post (o); + } + + else delegatesTo_none (o); + } + + void AssemblyPropertyMapping:: + delegatesTo (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::AssemblyPropertyMapping::delegatesTo_const_iterator b (o.begin_delegatesTo()), e (o.end_delegatesTo()); + + if (b != e) + { + delegatesTo_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) delegatesTo_next (o); + } + + delegatesTo_post (o); + } + + else delegatesTo_none (o); + } + + void AssemblyPropertyMapping:: + delegatesTo_pre (Type&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_pre (Type const&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_next (Type&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_next (Type const&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_post (Type&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_post (Type const&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_none (Type&) + { + } + + void AssemblyPropertyMapping:: + delegatesTo_none (Type const&) + { + } + + void AssemblyPropertyMapping:: + post (Type&) + { + } + + void AssemblyPropertyMapping:: + post (Type const&) + { + } + + // Locality + // + // + + void Locality:: + traverse (Type& o) + { + pre (o); + constraint (o); + constrainedInstance (o); + post (o); + } + + void Locality:: + traverse (Type const& o) + { + pre (o); + constraint (o); + constrainedInstance (o); + post (o); + } + + void Locality:: + pre (Type&) + { + } + + void Locality:: + pre (Type const&) + { + } + + void Locality:: + constraint (Type& o) + { + dispatch (o.constraint ()); + } + + void Locality:: + constraint (Type const& o) + { + dispatch (o.constraint ()); + } + + void Locality:: + constrainedInstance (Type& o) + { + dispatch (o.constrainedInstance ()); + } + + void Locality:: + constrainedInstance (Type const& o) + { + dispatch (o.constrainedInstance ()); + } + + void Locality:: + post (Type&) + { + } + + void Locality:: + post (Type const&) + { + } + + // ComponentAssemblyDescription + // + // + + void ComponentAssemblyDescription:: + traverse (Type& o) + { + pre (o); + instance (o); + connection (o); + externalProperty (o); + locality (o); + post (o); + } + + void ComponentAssemblyDescription:: + traverse (Type const& o) + { + pre (o); + instance (o); + connection (o); + externalProperty (o); + locality (o); + post (o); + } + + void ComponentAssemblyDescription:: + pre (Type&) + { + } + + void ComponentAssemblyDescription:: + pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + instance (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::instance_iterator b (o.begin_instance()), e (o.end_instance()); + + if (b != e) + { + instance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) instance_next (o); + } + + instance_post (o); + } + + else instance_none (o); + } + + void ComponentAssemblyDescription:: + instance (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::instance_const_iterator b (o.begin_instance()), e (o.end_instance()); + + if (b != e) + { + instance_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) instance_next (o); + } + + instance_post (o); + } + + else instance_none (o); + } + + void ComponentAssemblyDescription:: + instance_pre (Type&) + { + } + + void ComponentAssemblyDescription:: + instance_pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + instance_next (Type&) + { + } + + void ComponentAssemblyDescription:: + instance_next (Type const&) + { + } + + void ComponentAssemblyDescription:: + instance_post (Type&) + { + } + + void ComponentAssemblyDescription:: + instance_post (Type const&) + { + } + + void ComponentAssemblyDescription:: + instance_none (Type&) + { + } + + void ComponentAssemblyDescription:: + instance_none (Type const&) + { + } + + void ComponentAssemblyDescription:: + connection (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::connection_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void ComponentAssemblyDescription:: + connection (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::connection_const_iterator b (o.begin_connection()), e (o.end_connection()); + + if (b != e) + { + connection_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) connection_next (o); + } + + connection_post (o); + } + + else connection_none (o); + } + + void ComponentAssemblyDescription:: + connection_pre (Type&) + { + } + + void ComponentAssemblyDescription:: + connection_pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + connection_next (Type&) + { + } + + void ComponentAssemblyDescription:: + connection_next (Type const&) + { + } + + void ComponentAssemblyDescription:: + connection_post (Type&) + { + } + + void ComponentAssemblyDescription:: + connection_post (Type const&) + { + } + + void ComponentAssemblyDescription:: + connection_none (Type&) + { + } + + void ComponentAssemblyDescription:: + connection_none (Type const&) + { + } + + void ComponentAssemblyDescription:: + externalProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::externalProperty_iterator b (o.begin_externalProperty()), e (o.end_externalProperty()); + + if (b != e) + { + externalProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) externalProperty_next (o); + } + + externalProperty_post (o); + } + + else externalProperty_none (o); + } + + void ComponentAssemblyDescription:: + externalProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::externalProperty_const_iterator b (o.begin_externalProperty()), e (o.end_externalProperty()); + + if (b != e) + { + externalProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) externalProperty_next (o); + } + + externalProperty_post (o); + } + + else externalProperty_none (o); + } + + void ComponentAssemblyDescription:: + externalProperty_pre (Type&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_next (Type&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_next (Type const&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_post (Type&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_post (Type const&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_none (Type&) + { + } + + void ComponentAssemblyDescription:: + externalProperty_none (Type const&) + { + } + + void ComponentAssemblyDescription:: + locality (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::locality_iterator b (o.begin_locality()), e (o.end_locality()); + + if (b != e) + { + locality_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) locality_next (o); + } + + locality_post (o); + } + + else locality_none (o); + } + + void ComponentAssemblyDescription:: + locality (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentAssemblyDescription::locality_const_iterator b (o.begin_locality()), e (o.end_locality()); + + if (b != e) + { + locality_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) locality_next (o); + } + + locality_post (o); + } + + else locality_none (o); + } + + void ComponentAssemblyDescription:: + locality_pre (Type&) + { + } + + void ComponentAssemblyDescription:: + locality_pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + locality_next (Type&) + { + } + + void ComponentAssemblyDescription:: + locality_next (Type const&) + { + } + + void ComponentAssemblyDescription:: + locality_post (Type&) + { + } + + void ComponentAssemblyDescription:: + locality_post (Type const&) + { + } + + void ComponentAssemblyDescription:: + locality_none (Type&) + { + } + + void ComponentAssemblyDescription:: + locality_none (Type const&) + { + } + + void ComponentAssemblyDescription:: + post (Type&) + { + } + + void ComponentAssemblyDescription:: + post (Type const&) + { + } + + // MonolithicImplementationDescription + // + // + + void MonolithicImplementationDescription:: + traverse (Type& o) + { + pre (o); + nodeExecParameter (o); + componentExecParameter (o); + deployRequirement (o); + primaryArtifact (o); + post (o); + } + + void MonolithicImplementationDescription:: + traverse (Type const& o) + { + pre (o); + nodeExecParameter (o); + componentExecParameter (o); + deployRequirement (o); + primaryArtifact (o); + post (o); + } + + void MonolithicImplementationDescription:: + pre (Type&) + { + } + + void MonolithicImplementationDescription:: + pre (Type const&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::nodeExecParameter_iterator b (o.begin_nodeExecParameter()), e (o.end_nodeExecParameter()); + + if (b != e) + { + nodeExecParameter_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) nodeExecParameter_next (o); + } + + nodeExecParameter_post (o); + } + + else nodeExecParameter_none (o); + } + + void MonolithicImplementationDescription:: + nodeExecParameter (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::nodeExecParameter_const_iterator b (o.begin_nodeExecParameter()), e (o.end_nodeExecParameter()); + + if (b != e) + { + nodeExecParameter_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) nodeExecParameter_next (o); + } + + nodeExecParameter_post (o); + } + + else nodeExecParameter_none (o); + } + + void MonolithicImplementationDescription:: + nodeExecParameter_pre (Type&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_pre (Type const&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_next (Type&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_next (Type const&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_post (Type&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_post (Type const&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_none (Type&) + { + } + + void MonolithicImplementationDescription:: + nodeExecParameter_none (Type const&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::componentExecParameter_iterator b (o.begin_componentExecParameter()), e (o.end_componentExecParameter()); + + if (b != e) + { + componentExecParameter_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) componentExecParameter_next (o); + } + + componentExecParameter_post (o); + } + + else componentExecParameter_none (o); + } + + void MonolithicImplementationDescription:: + componentExecParameter (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::componentExecParameter_const_iterator b (o.begin_componentExecParameter()), e (o.end_componentExecParameter()); + + if (b != e) + { + componentExecParameter_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) componentExecParameter_next (o); + } + + componentExecParameter_post (o); + } + + else componentExecParameter_none (o); + } + + void MonolithicImplementationDescription:: + componentExecParameter_pre (Type&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_pre (Type const&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_next (Type&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_next (Type const&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_post (Type&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_post (Type const&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_none (Type&) + { + } + + void MonolithicImplementationDescription:: + componentExecParameter_none (Type const&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::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 MonolithicImplementationDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::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 MonolithicImplementationDescription:: + deployRequirement_pre (Type&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_pre (Type const&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_next (Type&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_next (Type const&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_post (Type&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_post (Type const&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_none (Type&) + { + } + + void MonolithicImplementationDescription:: + deployRequirement_none (Type const&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::primaryArtifact_iterator b (o.begin_primaryArtifact()), e (o.end_primaryArtifact()); + + if (b != e) + { + primaryArtifact_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) primaryArtifact_next (o); + } + + primaryArtifact_post (o); + } + + else primaryArtifact_none (o); + } + + void MonolithicImplementationDescription:: + primaryArtifact (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::MonolithicImplementationDescription::primaryArtifact_const_iterator b (o.begin_primaryArtifact()), e (o.end_primaryArtifact()); + + if (b != e) + { + primaryArtifact_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) primaryArtifact_next (o); + } + + primaryArtifact_post (o); + } + + else primaryArtifact_none (o); + } + + void MonolithicImplementationDescription:: + primaryArtifact_pre (Type&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_pre (Type const&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_next (Type&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_next (Type const&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_post (Type&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_post (Type const&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_none (Type&) + { + } + + void MonolithicImplementationDescription:: + primaryArtifact_none (Type const&) + { + } + + void MonolithicImplementationDescription:: + post (Type&) + { + } + + void MonolithicImplementationDescription:: + post (Type const&) + { + } + + // ComponentImplementationDescription + // + // + + void ComponentImplementationDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.implements_p ()) implements (o); + else implements_none (o); + if (o.assemblyImpl_p ()) assemblyImpl (o); + else assemblyImpl_none (o); + if (o.monolithicImpl_p ()) monolithicImpl (o); + else monolithicImpl_none (o); + configProperty (o); + capability (o); + dependsOn (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentImplementationDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.implements_p ()) implements (o); + else implements_none (o); + if (o.assemblyImpl_p ()) assemblyImpl (o); + else assemblyImpl_none (o); + if (o.monolithicImpl_p ()) monolithicImpl (o); + else monolithicImpl_none (o); + configProperty (o); + capability (o); + dependsOn (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentImplementationDescription:: + pre (Type&) + { + } + + void ComponentImplementationDescription:: + pre (Type const&) + { + } + + void ComponentImplementationDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ComponentImplementationDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ComponentImplementationDescription:: + label_none (Type&) + { + } + + void ComponentImplementationDescription:: + label_none (Type const&) + { + } + + void ComponentImplementationDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ComponentImplementationDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ComponentImplementationDescription:: + UUID_none (Type&) + { + } + + void ComponentImplementationDescription:: + UUID_none (Type const&) + { + } + + void ComponentImplementationDescription:: + implements (Type& o) + { + dispatch (o.implements ()); + } + + void ComponentImplementationDescription:: + implements (Type const& o) + { + dispatch (o.implements ()); + } + + void ComponentImplementationDescription:: + implements_none (Type&) + { + } + + void ComponentImplementationDescription:: + implements_none (Type const&) + { + } + + void ComponentImplementationDescription:: + assemblyImpl (Type& o) + { + dispatch (o.assemblyImpl ()); + } + + void ComponentImplementationDescription:: + assemblyImpl (Type const& o) + { + dispatch (o.assemblyImpl ()); + } + + void ComponentImplementationDescription:: + assemblyImpl_none (Type&) + { + } + + void ComponentImplementationDescription:: + assemblyImpl_none (Type const&) + { + } + + void ComponentImplementationDescription:: + monolithicImpl (Type& o) + { + dispatch (o.monolithicImpl ()); + } + + void ComponentImplementationDescription:: + monolithicImpl (Type const& o) + { + dispatch (o.monolithicImpl ()); + } + + void ComponentImplementationDescription:: + monolithicImpl_none (Type&) + { + } + + void ComponentImplementationDescription:: + monolithicImpl_none (Type const&) + { + } + + void ComponentImplementationDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::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 ComponentImplementationDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::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 ComponentImplementationDescription:: + configProperty_pre (Type&) + { + } + + void ComponentImplementationDescription:: + configProperty_pre (Type const&) + { + } + + void ComponentImplementationDescription:: + configProperty_next (Type&) + { + } + + void ComponentImplementationDescription:: + configProperty_next (Type const&) + { + } + + void ComponentImplementationDescription:: + configProperty_post (Type&) + { + } + + void ComponentImplementationDescription:: + configProperty_post (Type const&) + { + } + + void ComponentImplementationDescription:: + configProperty_none (Type&) + { + } + + void ComponentImplementationDescription:: + configProperty_none (Type const&) + { + } + + void ComponentImplementationDescription:: + capability (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::capability_iterator b (o.begin_capability()), e (o.end_capability()); + + if (b != e) + { + capability_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) capability_next (o); + } + + capability_post (o); + } + + else capability_none (o); + } + + void ComponentImplementationDescription:: + capability (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::capability_const_iterator b (o.begin_capability()), e (o.end_capability()); + + if (b != e) + { + capability_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) capability_next (o); + } + + capability_post (o); + } + + else capability_none (o); + } + + void ComponentImplementationDescription:: + capability_pre (Type&) + { + } + + void ComponentImplementationDescription:: + capability_pre (Type const&) + { + } + + void ComponentImplementationDescription:: + capability_next (Type&) + { + } + + void ComponentImplementationDescription:: + capability_next (Type const&) + { + } + + void ComponentImplementationDescription:: + capability_post (Type&) + { + } + + void ComponentImplementationDescription:: + capability_post (Type const&) + { + } + + void ComponentImplementationDescription:: + capability_none (Type&) + { + } + + void ComponentImplementationDescription:: + capability_none (Type const&) + { + } + + void ComponentImplementationDescription:: + dependsOn (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::dependsOn_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ComponentImplementationDescription:: + dependsOn (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::dependsOn_const_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ComponentImplementationDescription:: + dependsOn_pre (Type&) + { + } + + void ComponentImplementationDescription:: + dependsOn_pre (Type const&) + { + } + + void ComponentImplementationDescription:: + dependsOn_next (Type&) + { + } + + void ComponentImplementationDescription:: + dependsOn_next (Type const&) + { + } + + void ComponentImplementationDescription:: + dependsOn_post (Type&) + { + } + + void ComponentImplementationDescription:: + dependsOn_post (Type const&) + { + } + + void ComponentImplementationDescription:: + dependsOn_none (Type&) + { + } + + void ComponentImplementationDescription:: + dependsOn_none (Type const&) + { + } + + void ComponentImplementationDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentImplementationDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentImplementationDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentImplementationDescription:: + infoProperty_pre (Type&) + { + } + + void ComponentImplementationDescription:: + infoProperty_pre (Type const&) + { + } + + void ComponentImplementationDescription:: + infoProperty_next (Type&) + { + } + + void ComponentImplementationDescription:: + infoProperty_next (Type const&) + { + } + + void ComponentImplementationDescription:: + infoProperty_post (Type&) + { + } + + void ComponentImplementationDescription:: + infoProperty_post (Type const&) + { + } + + void ComponentImplementationDescription:: + infoProperty_none (Type&) + { + } + + void ComponentImplementationDescription:: + infoProperty_none (Type const&) + { + } + + void ComponentImplementationDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ComponentImplementationDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ComponentImplementationDescription:: + href_none (Type&) + { + } + + void ComponentImplementationDescription:: + href_none (Type const&) + { + } + + void ComponentImplementationDescription:: + post (Type&) + { + } + + void ComponentImplementationDescription:: + post (Type const&) + { + } + + // ConnectorImplementationDescription + // + // + + void ConnectorImplementationDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.implements_p ()) implements (o); + else implements_none (o); + if (o.assemblyImpl_p ()) assemblyImpl (o); + else assemblyImpl_none (o); + if (o.monolithicImpl_p ()) monolithicImpl (o); + else monolithicImpl_none (o); + configProperty (o); + capability (o); + dependsOn (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ConnectorImplementationDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.implements_p ()) implements (o); + else implements_none (o); + if (o.assemblyImpl_p ()) assemblyImpl (o); + else assemblyImpl_none (o); + if (o.monolithicImpl_p ()) monolithicImpl (o); + else monolithicImpl_none (o); + configProperty (o); + capability (o); + dependsOn (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ConnectorImplementationDescription:: + pre (Type&) + { + } + + void ConnectorImplementationDescription:: + pre (Type const&) + { + } + + void ConnectorImplementationDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ConnectorImplementationDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ConnectorImplementationDescription:: + label_none (Type&) + { + } + + void ConnectorImplementationDescription:: + label_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ConnectorImplementationDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ConnectorImplementationDescription:: + UUID_none (Type&) + { + } + + void ConnectorImplementationDescription:: + UUID_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + implements (Type& o) + { + dispatch (o.implements ()); + } + + void ConnectorImplementationDescription:: + implements (Type const& o) + { + dispatch (o.implements ()); + } + + void ConnectorImplementationDescription:: + implements_none (Type&) + { + } + + void ConnectorImplementationDescription:: + implements_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + assemblyImpl (Type& o) + { + dispatch (o.assemblyImpl ()); + } + + void ConnectorImplementationDescription:: + assemblyImpl (Type const& o) + { + dispatch (o.assemblyImpl ()); + } + + void ConnectorImplementationDescription:: + assemblyImpl_none (Type&) + { + } + + void ConnectorImplementationDescription:: + assemblyImpl_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + monolithicImpl (Type& o) + { + dispatch (o.monolithicImpl ()); + } + + void ConnectorImplementationDescription:: + monolithicImpl (Type const& o) + { + dispatch (o.monolithicImpl ()); + } + + void ConnectorImplementationDescription:: + monolithicImpl_none (Type&) + { + } + + void ConnectorImplementationDescription:: + monolithicImpl_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::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 ConnectorImplementationDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::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 ConnectorImplementationDescription:: + configProperty_pre (Type&) + { + } + + void ConnectorImplementationDescription:: + configProperty_pre (Type const&) + { + } + + void ConnectorImplementationDescription:: + configProperty_next (Type&) + { + } + + void ConnectorImplementationDescription:: + configProperty_next (Type const&) + { + } + + void ConnectorImplementationDescription:: + configProperty_post (Type&) + { + } + + void ConnectorImplementationDescription:: + configProperty_post (Type const&) + { + } + + void ConnectorImplementationDescription:: + configProperty_none (Type&) + { + } + + void ConnectorImplementationDescription:: + configProperty_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + capability (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::capability_iterator b (o.begin_capability()), e (o.end_capability()); + + if (b != e) + { + capability_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) capability_next (o); + } + + capability_post (o); + } + + else capability_none (o); + } + + void ConnectorImplementationDescription:: + capability (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::capability_const_iterator b (o.begin_capability()), e (o.end_capability()); + + if (b != e) + { + capability_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) capability_next (o); + } + + capability_post (o); + } + + else capability_none (o); + } + + void ConnectorImplementationDescription:: + capability_pre (Type&) + { + } + + void ConnectorImplementationDescription:: + capability_pre (Type const&) + { + } + + void ConnectorImplementationDescription:: + capability_next (Type&) + { + } + + void ConnectorImplementationDescription:: + capability_next (Type const&) + { + } + + void ConnectorImplementationDescription:: + capability_post (Type&) + { + } + + void ConnectorImplementationDescription:: + capability_post (Type const&) + { + } + + void ConnectorImplementationDescription:: + capability_none (Type&) + { + } + + void ConnectorImplementationDescription:: + capability_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + dependsOn (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::dependsOn_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ConnectorImplementationDescription:: + dependsOn (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::dependsOn_const_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ConnectorImplementationDescription:: + dependsOn_pre (Type&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_pre (Type const&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_next (Type&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_next (Type const&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_post (Type&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_post (Type const&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_none (Type&) + { + } + + void ConnectorImplementationDescription:: + dependsOn_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ConnectorImplementationDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorImplementationDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ConnectorImplementationDescription:: + infoProperty_pre (Type&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_pre (Type const&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_next (Type&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_next (Type const&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_post (Type&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_post (Type const&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_none (Type&) + { + } + + void ConnectorImplementationDescription:: + infoProperty_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ConnectorImplementationDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ConnectorImplementationDescription:: + href_none (Type&) + { + } + + void ConnectorImplementationDescription:: + href_none (Type const&) + { + } + + void ConnectorImplementationDescription:: + post (Type&) + { + } + + void ConnectorImplementationDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // 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 > (ACE_TEXT ("requiredUUID"), top_ ())); + Traversal::ComponentPackageReference::requiredUUID (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("requiredName"), top_ ())); + Traversal::ComponentPackageReference::requiredName (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("requiredType"), top_ ())); + Traversal::ComponentPackageReference::requiredType (o); + pop_ (); + } + + // SubcomponentInstantiationDescription + // + // + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription () + { + } + + void SubcomponentInstantiationDescription:: + traverse (Type const& o) + { + Traversal::SubcomponentInstantiationDescription::traverse (o); + } + + void SubcomponentInstantiationDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::SubcomponentInstantiationDescription::name (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + basePackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("basePackage"), top_ ())); + Traversal::SubcomponentInstantiationDescription::basePackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + specializedConfig (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("specializedConfig"), top_ ())); + Traversal::SubcomponentInstantiationDescription::specializedConfig (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + selectRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("selectRequirement"), top_ ())); + } + + void SubcomponentInstantiationDescription:: + selectRequirement_next (Type const& o) + { + selectRequirement_post (o); + selectRequirement_pre (o); + } + + void SubcomponentInstantiationDescription:: + selectRequirement_post (Type const&) + { + pop_ (); + } + + void SubcomponentInstantiationDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void SubcomponentInstantiationDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void SubcomponentInstantiationDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void SubcomponentInstantiationDescription:: + referencedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("referencedPackage"), top_ ())); + Traversal::SubcomponentInstantiationDescription::referencedPackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + importedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("importedPackage"), top_ ())); + Traversal::SubcomponentInstantiationDescription::importedPackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("id"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::SubcomponentInstantiationDescription::id (o); + attr_ (0); + } + + // SubcomponentPropertyReference + // + // + + SubcomponentPropertyReference:: + SubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SubcomponentPropertyReference:: + SubcomponentPropertyReference () + { + } + + void SubcomponentPropertyReference:: + traverse (Type const& o) + { + Traversal::SubcomponentPropertyReference::traverse (o); + } + + void SubcomponentPropertyReference:: + propertyName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("propertyName"), top_ ())); + Traversal::SubcomponentPropertyReference::propertyName (o); + pop_ (); + } + + void SubcomponentPropertyReference:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("instance"), top_ ())); + Traversal::SubcomponentPropertyReference::instance (o); + pop_ (); + } + + // AssemblyPropertyMapping + // + // + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + AssemblyPropertyMapping:: + AssemblyPropertyMapping () + { + } + + void AssemblyPropertyMapping:: + traverse (Type const& o) + { + Traversal::AssemblyPropertyMapping::traverse (o); + } + + void AssemblyPropertyMapping:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::AssemblyPropertyMapping::name (o); + pop_ (); + } + + void AssemblyPropertyMapping:: + externalName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("externalName"), top_ ())); + Traversal::AssemblyPropertyMapping::externalName (o); + pop_ (); + } + + void AssemblyPropertyMapping:: + delegatesTo_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("delegatesTo"), top_ ())); + } + + void AssemblyPropertyMapping:: + delegatesTo_next (Type const& o) + { + delegatesTo_post (o); + delegatesTo_pre (o); + } + + void AssemblyPropertyMapping:: + delegatesTo_post (Type const&) + { + pop_ (); + } + + // LocalityKind + // + // + + LocalityKind:: + LocalityKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + LocalityKind:: + LocalityKind () + { + } + + void LocalityKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::LocalityKind::SameNodeAnyProcess) s = ACE_TEXT ("SameNodeAnyProcess"); + else if (o == ::CIAO::Config_Handlers::LocalityKind::SameNodeSameProcess) s = ACE_TEXT ("SameNodeSameProcess"); + else if (o == ::CIAO::Config_Handlers::LocalityKind::SameNodeDifferentProcess) s = ACE_TEXT ("SameNodeDifferentProcess"); + else if (o == ::CIAO::Config_Handlers::LocalityKind::DifferentNode) s = ACE_TEXT ("DifferentNode"); + else if (o == ::CIAO::Config_Handlers::LocalityKind::DifferentProcess) s = ACE_TEXT ("DifferentProcess"); + else if (o == ::CIAO::Config_Handlers::LocalityKind::NoConstraint) s = ACE_TEXT ("NoConstraint"); + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // Locality + // + // + + Locality:: + Locality (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Locality:: + Locality () + { + } + + void Locality:: + traverse (Type const& o) + { + Traversal::Locality::traverse (o); + } + + void Locality:: + constraint (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("constraint"), top_ ())); + Traversal::Locality::constraint (o); + pop_ (); + } + + void Locality:: + constrainedInstance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("constrainedInstance"), top_ ())); + Traversal::Locality::constrainedInstance (o); + pop_ (); + } + + // ComponentAssemblyDescription + // + // + + ComponentAssemblyDescription:: + ComponentAssemblyDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentAssemblyDescription:: + ComponentAssemblyDescription () + { + } + + void ComponentAssemblyDescription:: + traverse (Type const& o) + { + Traversal::ComponentAssemblyDescription::traverse (o); + } + + void ComponentAssemblyDescription:: + instance_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("instance"), top_ ())); + } + + void ComponentAssemblyDescription:: + instance_next (Type const& o) + { + instance_post (o); + instance_pre (o); + } + + void ComponentAssemblyDescription:: + instance_post (Type const&) + { + pop_ (); + } + + void ComponentAssemblyDescription:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("connection"), top_ ())); + } + + void ComponentAssemblyDescription:: + connection_next (Type const& o) + { + connection_post (o); + connection_pre (o); + } + + void ComponentAssemblyDescription:: + connection_post (Type const&) + { + pop_ (); + } + + void ComponentAssemblyDescription:: + externalProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("externalProperty"), top_ ())); + } + + void ComponentAssemblyDescription:: + externalProperty_next (Type const& o) + { + externalProperty_post (o); + externalProperty_pre (o); + } + + void ComponentAssemblyDescription:: + externalProperty_post (Type const&) + { + pop_ (); + } + + void ComponentAssemblyDescription:: + locality_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("locality"), top_ ())); + } + + void ComponentAssemblyDescription:: + locality_next (Type const& o) + { + locality_post (o); + locality_pre (o); + } + + void ComponentAssemblyDescription:: + locality_post (Type const&) + { + pop_ (); + } + + // MonolithicImplementationDescription + // + // + + MonolithicImplementationDescription:: + MonolithicImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + MonolithicImplementationDescription:: + MonolithicImplementationDescription () + { + } + + void MonolithicImplementationDescription:: + traverse (Type const& o) + { + Traversal::MonolithicImplementationDescription::traverse (o); + } + + void MonolithicImplementationDescription:: + nodeExecParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("nodeExecParameter"), top_ ())); + } + + void MonolithicImplementationDescription:: + nodeExecParameter_next (Type const& o) + { + nodeExecParameter_post (o); + nodeExecParameter_pre (o); + } + + void MonolithicImplementationDescription:: + nodeExecParameter_post (Type const&) + { + pop_ (); + } + + void MonolithicImplementationDescription:: + componentExecParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("componentExecParameter"), top_ ())); + } + + void MonolithicImplementationDescription:: + componentExecParameter_next (Type const& o) + { + componentExecParameter_post (o); + componentExecParameter_pre (o); + } + + void MonolithicImplementationDescription:: + componentExecParameter_post (Type const&) + { + pop_ (); + } + + void MonolithicImplementationDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("deployRequirement"), top_ ())); + } + + void MonolithicImplementationDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void MonolithicImplementationDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void MonolithicImplementationDescription:: + primaryArtifact_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("primaryArtifact"), top_ ())); + } + + void MonolithicImplementationDescription:: + primaryArtifact_next (Type const& o) + { + primaryArtifact_post (o); + primaryArtifact_pre (o); + } + + void MonolithicImplementationDescription:: + primaryArtifact_post (Type const&) + { + pop_ (); + } + + // ComponentImplementationDescription + // + // + + ComponentImplementationDescription:: + ComponentImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentImplementationDescription:: + ComponentImplementationDescription () + { + } + + void ComponentImplementationDescription:: + traverse (Type const& o) + { + Traversal::ComponentImplementationDescription::traverse (o); + } + + void ComponentImplementationDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ComponentImplementationDescription::label (o); + pop_ (); + } + + void ComponentImplementationDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ComponentImplementationDescription::UUID (o); + pop_ (); + } + + void ComponentImplementationDescription:: + implements (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implements"), top_ ())); + Traversal::ComponentImplementationDescription::implements (o); + pop_ (); + } + + void ComponentImplementationDescription:: + assemblyImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("assemblyImpl"), top_ ())); + Traversal::ComponentImplementationDescription::assemblyImpl (o); + pop_ (); + } + + void ComponentImplementationDescription:: + monolithicImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("monolithicImpl"), top_ ())); + Traversal::ComponentImplementationDescription::monolithicImpl (o); + pop_ (); + } + + void ComponentImplementationDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void ComponentImplementationDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void ComponentImplementationDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void ComponentImplementationDescription:: + capability_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("capability"), top_ ())); + } + + void ComponentImplementationDescription:: + capability_next (Type const& o) + { + capability_post (o); + capability_pre (o); + } + + void ComponentImplementationDescription:: + capability_post (Type const&) + { + pop_ (); + } + + void ComponentImplementationDescription:: + dependsOn_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("dependsOn"), top_ ())); + } + + void ComponentImplementationDescription:: + dependsOn_next (Type const& o) + { + dependsOn_post (o); + dependsOn_pre (o); + } + + void ComponentImplementationDescription:: + dependsOn_post (Type const&) + { + pop_ (); + } + + void ComponentImplementationDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ComponentImplementationDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ComponentImplementationDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ComponentImplementationDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ComponentImplementationDescription::href (o); + attr_ (0); + } + + // ConnectorImplementationDescription + // + // + + ConnectorImplementationDescription:: + ConnectorImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ConnectorImplementationDescription:: + ConnectorImplementationDescription () + { + } + + void ConnectorImplementationDescription:: + traverse (Type const& o) + { + Traversal::ConnectorImplementationDescription::traverse (o); + } + + void ConnectorImplementationDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ConnectorImplementationDescription::label (o); + pop_ (); + } + + void ConnectorImplementationDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ConnectorImplementationDescription::UUID (o); + pop_ (); + } + + void ConnectorImplementationDescription:: + implements (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implements"), top_ ())); + Traversal::ConnectorImplementationDescription::implements (o); + pop_ (); + } + + void ConnectorImplementationDescription:: + assemblyImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("assemblyImpl"), top_ ())); + Traversal::ConnectorImplementationDescription::assemblyImpl (o); + pop_ (); + } + + void ConnectorImplementationDescription:: + monolithicImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("monolithicImpl"), top_ ())); + Traversal::ConnectorImplementationDescription::monolithicImpl (o); + pop_ (); + } + + void ConnectorImplementationDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void ConnectorImplementationDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void ConnectorImplementationDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void ConnectorImplementationDescription:: + capability_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("capability"), top_ ())); + } + + void ConnectorImplementationDescription:: + capability_next (Type const& o) + { + capability_post (o); + capability_pre (o); + } + + void ConnectorImplementationDescription:: + capability_post (Type const&) + { + pop_ (); + } + + void ConnectorImplementationDescription:: + dependsOn_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("dependsOn"), top_ ())); + } + + void ConnectorImplementationDescription:: + dependsOn_next (Type const& o) + { + dependsOn_post (o); + dependsOn_pre (o); + } + + void ConnectorImplementationDescription:: + dependsOn_post (Type const&) + { + pop_ (); + } + + void ConnectorImplementationDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ConnectorImplementationDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ConnectorImplementationDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ConnectorImplementationDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ConnectorImplementationDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/cid.hpp b/modules/CIAO/tools/Config_Handlers/cid.hpp new file mode 100644 index 00000000000..dbf48c94913 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cid.hpp @@ -0,0 +1,2885 @@ +/* $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 + +#ifndef CID_HPP +#define CID_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentPackageReference; + class SubcomponentInstantiationDescription; + class SubcomponentPropertyReference; + class AssemblyPropertyMapping; + class LocalityKind; + class Locality; + class ComponentAssemblyDescription; + class MonolithicImplementationDescription; + class ComponentImplementationDescription; + class ConnectorImplementationDescription; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +#include "ccd.hpp" + +#include "iad.hpp" + +#include "pcd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export ComponentPackageReference : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentPackageReference, ACE_Null_Mutex > _ptr; + + // requiredUUID + // + public: + bool requiredUUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& requiredUUID () const; + void requiredUUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requiredUUID_; + + // requiredName + // + public: + bool requiredName_p () const; + ::XMLSchema::string< ACE_TCHAR > const& requiredName () const; + void requiredName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requiredName_; + + // requiredType + // + public: + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& requiredType () const; + void requiredType (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > requiredType_; + + public: + ComponentPackageReference (::CIAO::Config_Handlers::ComponentInterfaceDescription const& requiredType__); + + ComponentPackageReference (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPackageReference (ComponentPackageReference const& s); + + ComponentPackageReference& + operator= (ComponentPackageReference const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SubcomponentInstantiationDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SubcomponentInstantiationDescription, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // basePackage + // + public: + bool basePackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageDescription const& basePackage () const; + void basePackage (::CIAO::Config_Handlers::ComponentPackageDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > basePackage_; + + // specializedConfig + // + public: + bool specializedConfig_p () const; + ::CIAO::Config_Handlers::PackageConfiguration const& specializedConfig () const; + void specializedConfig (::CIAO::Config_Handlers::PackageConfiguration const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > specializedConfig_; + + // selectRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator selectRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator selectRequirement_const_iterator; + selectRequirement_iterator begin_selectRequirement (); + selectRequirement_iterator end_selectRequirement (); + selectRequirement_const_iterator begin_selectRequirement () const; + selectRequirement_const_iterator end_selectRequirement () const; + void add_selectRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* selectRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_selectRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > selectRequirement_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // referencedPackage + // + public: + bool referencedPackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageReference const& referencedPackage () const; + void referencedPackage (::CIAO::Config_Handlers::ComponentPackageReference const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > referencedPackage_; + + // importedPackage + // + public: + bool importedPackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageImport const& importedPackage () const; + void importedPackage (::CIAO::Config_Handlers::ComponentPackageImport const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > importedPackage_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + SubcomponentInstantiationDescription (::XMLSchema::string< ACE_TCHAR > const& name__); + + SubcomponentInstantiationDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + SubcomponentInstantiationDescription (SubcomponentInstantiationDescription const& s); + + SubcomponentInstantiationDescription& + operator= (SubcomponentInstantiationDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export SubcomponentPropertyReference : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < SubcomponentPropertyReference, ACE_Null_Mutex > _ptr; + + // propertyName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& propertyName () const; + void propertyName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > propertyName_; + + // instance + // + public: + ::CIAO::Config_Handlers::IdRef const& instance () const; + void instance (::CIAO::Config_Handlers::IdRef const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > instance_; + + public: + SubcomponentPropertyReference (::XMLSchema::string< ACE_TCHAR > const& propertyName__, + ::CIAO::Config_Handlers::IdRef const& instance__); + + SubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR > const&); + SubcomponentPropertyReference (SubcomponentPropertyReference const& s); + + SubcomponentPropertyReference& + operator= (SubcomponentPropertyReference const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export AssemblyPropertyMapping : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < AssemblyPropertyMapping, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // externalName + // + public: + ::XMLSchema::string< ACE_TCHAR > const& externalName () const; + void externalName (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > externalName_; + + // delegatesTo + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > >::iterator delegatesTo_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > >::const_iterator delegatesTo_const_iterator; + delegatesTo_iterator begin_delegatesTo (); + delegatesTo_iterator end_delegatesTo (); + delegatesTo_const_iterator begin_delegatesTo () const; + delegatesTo_const_iterator end_delegatesTo () const; + void add_delegatesTo ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > const& ); + XSCRT::Type* delegatesTo_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_delegatesTo (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentPropertyReference, ACE_Null_Mutex > > delegatesTo_; + + public: + AssemblyPropertyMapping (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& externalName__); + + AssemblyPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR > const&); + AssemblyPropertyMapping (AssemblyPropertyMapping const& s); + + AssemblyPropertyMapping& + operator= (AssemblyPropertyMapping const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export LocalityKind : public ::XSCRT::Type + { + public: + LocalityKind (::XSCRT::XML::Element< ACE_TCHAR > const&); + LocalityKind (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static LocalityKind const SameNodeAnyProcess; + static LocalityKind const SameNodeSameProcess; + static LocalityKind const SameNodeDifferentProcess; + static LocalityKind const DifferentNode; + static LocalityKind const DifferentProcess; + static LocalityKind const NoConstraint; + + enum Value + { + SameNodeAnyProcess_l, SameNodeSameProcess_l, SameNodeDifferentProcess_l, DifferentNode_l, DifferentProcess_l, NoConstraint_l + }; + + + Value + integral () const; + + friend bool XSC_XML_Handlers_Export + operator== (LocalityKind const& a, LocalityKind const& b); + + friend bool XSC_XML_Handlers_Export + operator!= (LocalityKind const& a, LocalityKind const& b); + + private: + LocalityKind (Value v); + + Value v_; + }; + + bool XSC_XML_Handlers_Export operator== (LocalityKind const &a, LocalityKind const &b); + + bool XSC_XML_Handlers_Export operator!= (LocalityKind const &a, LocalityKind const &b); + + + class XSC_XML_Handlers_Export Locality : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < Locality, ACE_Null_Mutex > _ptr; + + // constraint + // + public: + ::CIAO::Config_Handlers::LocalityKind const& constraint () const; + void constraint (::CIAO::Config_Handlers::LocalityKind const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::LocalityKind > constraint_; + + // constrainedInstance + // + public: + ::CIAO::Config_Handlers::IdRef const& constrainedInstance () const; + void constrainedInstance (::CIAO::Config_Handlers::IdRef const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::IdRef > constrainedInstance_; + + public: + Locality (::CIAO::Config_Handlers::LocalityKind const& constraint__, + ::CIAO::Config_Handlers::IdRef const& constrainedInstance__); + + Locality (::XSCRT::XML::Element< ACE_TCHAR > const&); + Locality (Locality const& s); + + Locality& + operator= (Locality const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ComponentAssemblyDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentAssemblyDescription, ACE_Null_Mutex > _ptr; + + // instance + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > >::iterator instance_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > >::const_iterator instance_const_iterator; + instance_iterator begin_instance (); + instance_iterator end_instance (); + instance_const_iterator begin_instance () const; + instance_const_iterator end_instance () const; + void add_instance ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* instance_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_instance (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::SubcomponentInstantiationDescription, ACE_Null_Mutex > > instance_; + + // connection + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > >::iterator connection_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > >::const_iterator connection_const_iterator; + connection_iterator begin_connection (); + connection_iterator end_connection (); + connection_const_iterator begin_connection () const; + connection_const_iterator end_connection () const; + void add_connection ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* connection_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_connection (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyConnectionDescription, ACE_Null_Mutex > > connection_; + + // externalProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > >::iterator externalProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > >::const_iterator externalProperty_const_iterator; + externalProperty_iterator begin_externalProperty (); + externalProperty_iterator end_externalProperty (); + externalProperty_const_iterator begin_externalProperty () const; + externalProperty_const_iterator end_externalProperty () const; + void add_externalProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > const& ); + XSCRT::Type* externalProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_externalProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::AssemblyPropertyMapping, ACE_Null_Mutex > > externalProperty_; + + // locality + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > >::iterator locality_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > >::const_iterator locality_const_iterator; + locality_iterator begin_locality (); + locality_iterator end_locality (); + locality_const_iterator begin_locality () const; + locality_const_iterator end_locality () const; + void add_locality ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > const& ); + XSCRT::Type* locality_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_locality (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Locality, ACE_Null_Mutex > > locality_; + + public: + ComponentAssemblyDescription (); + + ComponentAssemblyDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentAssemblyDescription (ComponentAssemblyDescription const& s); + + ComponentAssemblyDescription& + operator= (ComponentAssemblyDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export MonolithicImplementationDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < MonolithicImplementationDescription, ACE_Null_Mutex > _ptr; + + // nodeExecParameter + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator nodeExecParameter_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator nodeExecParameter_const_iterator; + nodeExecParameter_iterator begin_nodeExecParameter (); + nodeExecParameter_iterator end_nodeExecParameter (); + nodeExecParameter_const_iterator begin_nodeExecParameter () const; + nodeExecParameter_const_iterator end_nodeExecParameter () const; + void add_nodeExecParameter ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* nodeExecParameter_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_nodeExecParameter (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > nodeExecParameter_; + + // componentExecParameter + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator componentExecParameter_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator componentExecParameter_const_iterator; + componentExecParameter_iterator begin_componentExecParameter (); + componentExecParameter_iterator end_componentExecParameter (); + componentExecParameter_const_iterator begin_componentExecParameter () const; + componentExecParameter_const_iterator end_componentExecParameter () const; + void add_componentExecParameter ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* componentExecParameter_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_componentExecParameter (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > componentExecParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationRequirement, ACE_Null_Mutex > > deployRequirement_; + + // primaryArtifact + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > >::iterator primaryArtifact_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > >::const_iterator primaryArtifact_const_iterator; + primaryArtifact_iterator begin_primaryArtifact (); + primaryArtifact_iterator end_primaryArtifact (); + primaryArtifact_const_iterator begin_primaryArtifact () const; + primaryArtifact_const_iterator end_primaryArtifact () const; + void add_primaryArtifact ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > const& ); + XSCRT::Type* primaryArtifact_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_primaryArtifact (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > > primaryArtifact_; + + public: + MonolithicImplementationDescription (); + + MonolithicImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + MonolithicImplementationDescription (MonolithicImplementationDescription const& s); + + MonolithicImplementationDescription& + operator= (MonolithicImplementationDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ComponentImplementationDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentImplementationDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // implements + // + public: + bool implements_p () const; + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& implements () const; + void implements (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > implements_; + + // assemblyImpl + // + public: + bool assemblyImpl_p () const; + ::CIAO::Config_Handlers::ComponentAssemblyDescription const& assemblyImpl () const; + void assemblyImpl (::CIAO::Config_Handlers::ComponentAssemblyDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentAssemblyDescription > assemblyImpl_; + + // monolithicImpl + // + public: + bool monolithicImpl_p () const; + ::CIAO::Config_Handlers::MonolithicImplementationDescription const& monolithicImpl () const; + void monolithicImpl (::CIAO::Config_Handlers::MonolithicImplementationDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > monolithicImpl_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // capability + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > >::iterator capability_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > >::const_iterator capability_const_iterator; + capability_iterator begin_capability (); + capability_iterator end_capability (); + capability_const_iterator begin_capability () const; + capability_const_iterator end_capability () const; + void add_capability ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > const& ); + XSCRT::Type* capability_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_capability (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > > capability_; + + // dependsOn + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::iterator dependsOn_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::const_iterator dependsOn_const_iterator; + dependsOn_iterator begin_dependsOn (); + dependsOn_iterator end_dependsOn (); + dependsOn_const_iterator begin_dependsOn () const; + dependsOn_const_iterator end_dependsOn () const; + void add_dependsOn ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& ); + XSCRT::Type* dependsOn_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > > dependsOn_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ComponentImplementationDescription (); + + ComponentImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentImplementationDescription (ComponentImplementationDescription const& s); + + ComponentImplementationDescription& + operator= (ComponentImplementationDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ConnectorImplementationDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ConnectorImplementationDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // implements + // + public: + bool implements_p () const; + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& implements () const; + void implements (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > implements_; + + // assemblyImpl + // + public: + bool assemblyImpl_p () const; + ::CIAO::Config_Handlers::ComponentAssemblyDescription const& assemblyImpl () const; + void assemblyImpl (::CIAO::Config_Handlers::ComponentAssemblyDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentAssemblyDescription > assemblyImpl_; + + // monolithicImpl + // + public: + bool monolithicImpl_p () const; + ::CIAO::Config_Handlers::MonolithicImplementationDescription const& monolithicImpl () const; + void monolithicImpl (::CIAO::Config_Handlers::MonolithicImplementationDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > monolithicImpl_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // capability + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > >::iterator capability_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > >::const_iterator capability_const_iterator; + capability_iterator begin_capability (); + capability_iterator end_capability (); + capability_const_iterator begin_capability () const; + capability_const_iterator end_capability () const; + void add_capability ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > const& ); + XSCRT::Type* capability_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_capability (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Capability, ACE_Null_Mutex > > capability_; + + // dependsOn + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::iterator dependsOn_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > >::const_iterator dependsOn_const_iterator; + dependsOn_iterator begin_dependsOn (); + dependsOn_iterator end_dependsOn (); + dependsOn_const_iterator begin_dependsOn () const; + dependsOn_const_iterator end_dependsOn () const; + void add_dependsOn ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > const& ); + XSCRT::Type* dependsOn_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ImplementationDependency, ACE_Null_Mutex > > dependsOn_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ConnectorImplementationDescription (); + + ConnectorImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ConnectorImplementationDescription (ConnectorImplementationDescription const& s); + + ConnectorImplementationDescription& + operator= (ConnectorImplementationDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export ComponentPackageReference : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentPackageReference > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + requiredUUID (Type&); + + virtual void + requiredUUID (Type const&); + + virtual void + requiredUUID_none (Type&); + + virtual void + requiredUUID_none (Type const&); + + virtual void + requiredName (Type&); + + virtual void + requiredName (Type const&); + + virtual void + requiredName_none (Type&); + + virtual void + requiredName_none (Type const&); + + virtual void + requiredType (Type&); + + virtual void + requiredType (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export SubcomponentInstantiationDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + basePackage (Type&); + + virtual void + basePackage (Type const&); + + virtual void + basePackage_none (Type&); + + virtual void + basePackage_none (Type const&); + + virtual void + specializedConfig (Type&); + + virtual void + specializedConfig (Type const&); + + virtual void + specializedConfig_none (Type&); + + virtual void + specializedConfig_none (Type const&); + + virtual void + selectRequirement (Type&); + + virtual void + selectRequirement (Type const&); + + virtual void + selectRequirement_pre (Type&); + + virtual void + selectRequirement_pre (Type const&); + + virtual void + selectRequirement_next (Type&); + + virtual void + selectRequirement_next (Type const&); + + virtual void + selectRequirement_post (Type&); + + virtual void + selectRequirement_post (Type const&); + + virtual void + selectRequirement_none (Type&); + + virtual void + selectRequirement_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + referencedPackage (Type&); + + virtual void + referencedPackage (Type const&); + + virtual void + referencedPackage_none (Type&); + + virtual void + referencedPackage_none (Type const&); + + virtual void + importedPackage (Type&); + + virtual void + importedPackage (Type const&); + + virtual void + importedPackage_none (Type&); + + virtual void + importedPackage_none (Type const&); + + virtual void + id (Type&); + + virtual void + id (Type const&); + + virtual void + id_none (Type&); + + virtual void + id_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export SubcomponentPropertyReference : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::SubcomponentPropertyReference > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + propertyName (Type&); + + virtual void + propertyName (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export AssemblyPropertyMapping : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::AssemblyPropertyMapping > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + externalName (Type&); + + virtual void + externalName (Type const&); + + virtual void + delegatesTo (Type&); + + virtual void + delegatesTo (Type const&); + + virtual void + delegatesTo_pre (Type&); + + virtual void + delegatesTo_pre (Type const&); + + virtual void + delegatesTo_next (Type&); + + virtual void + delegatesTo_next (Type const&); + + virtual void + delegatesTo_post (Type&); + + virtual void + delegatesTo_post (Type const&); + + virtual void + delegatesTo_none (Type&); + + virtual void + delegatesTo_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::LocalityKind > + LocalityKind; + + struct XSC_XML_Handlers_Export Locality : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Locality > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + constraint (Type&); + + virtual void + constraint (Type const&); + + virtual void + constrainedInstance (Type&); + + virtual void + constrainedInstance (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ComponentAssemblyDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentAssemblyDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + instance (Type&); + + virtual void + instance (Type const&); + + virtual void + instance_pre (Type&); + + virtual void + instance_pre (Type const&); + + virtual void + instance_next (Type&); + + virtual void + instance_next (Type const&); + + virtual void + instance_post (Type&); + + virtual void + instance_post (Type const&); + + virtual void + instance_none (Type&); + + virtual void + instance_none (Type const&); + + virtual void + connection (Type&); + + virtual void + connection (Type const&); + + virtual void + connection_pre (Type&); + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type&); + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type&); + + virtual void + connection_post (Type const&); + + virtual void + connection_none (Type&); + + virtual void + connection_none (Type const&); + + virtual void + externalProperty (Type&); + + virtual void + externalProperty (Type const&); + + virtual void + externalProperty_pre (Type&); + + virtual void + externalProperty_pre (Type const&); + + virtual void + externalProperty_next (Type&); + + virtual void + externalProperty_next (Type const&); + + virtual void + externalProperty_post (Type&); + + virtual void + externalProperty_post (Type const&); + + virtual void + externalProperty_none (Type&); + + virtual void + externalProperty_none (Type const&); + + virtual void + locality (Type&); + + virtual void + locality (Type const&); + + virtual void + locality_pre (Type&); + + virtual void + locality_pre (Type const&); + + virtual void + locality_next (Type&); + + virtual void + locality_next (Type const&); + + virtual void + locality_post (Type&); + + virtual void + locality_post (Type const&); + + virtual void + locality_none (Type&); + + virtual void + locality_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export MonolithicImplementationDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::MonolithicImplementationDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + nodeExecParameter (Type&); + + virtual void + nodeExecParameter (Type const&); + + virtual void + nodeExecParameter_pre (Type&); + + virtual void + nodeExecParameter_pre (Type const&); + + virtual void + nodeExecParameter_next (Type&); + + virtual void + nodeExecParameter_next (Type const&); + + virtual void + nodeExecParameter_post (Type&); + + virtual void + nodeExecParameter_post (Type const&); + + virtual void + nodeExecParameter_none (Type&); + + virtual void + nodeExecParameter_none (Type const&); + + virtual void + componentExecParameter (Type&); + + virtual void + componentExecParameter (Type const&); + + virtual void + componentExecParameter_pre (Type&); + + virtual void + componentExecParameter_pre (Type const&); + + virtual void + componentExecParameter_next (Type&); + + virtual void + componentExecParameter_next (Type const&); + + virtual void + componentExecParameter_post (Type&); + + virtual void + componentExecParameter_post (Type const&); + + virtual void + componentExecParameter_none (Type&); + + virtual void + componentExecParameter_none (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + primaryArtifact (Type&); + + virtual void + primaryArtifact (Type const&); + + virtual void + primaryArtifact_pre (Type&); + + virtual void + primaryArtifact_pre (Type const&); + + virtual void + primaryArtifact_next (Type&); + + virtual void + primaryArtifact_next (Type const&); + + virtual void + primaryArtifact_post (Type&); + + virtual void + primaryArtifact_post (Type const&); + + virtual void + primaryArtifact_none (Type&); + + virtual void + primaryArtifact_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ComponentImplementationDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentImplementationDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + implements (Type&); + + virtual void + implements (Type const&); + + virtual void + implements_none (Type&); + + virtual void + implements_none (Type const&); + + virtual void + assemblyImpl (Type&); + + virtual void + assemblyImpl (Type const&); + + virtual void + assemblyImpl_none (Type&); + + virtual void + assemblyImpl_none (Type const&); + + virtual void + monolithicImpl (Type&); + + virtual void + monolithicImpl (Type const&); + + virtual void + monolithicImpl_none (Type&); + + virtual void + monolithicImpl_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + capability (Type&); + + virtual void + capability (Type const&); + + virtual void + capability_pre (Type&); + + virtual void + capability_pre (Type const&); + + virtual void + capability_next (Type&); + + virtual void + capability_next (Type const&); + + virtual void + capability_post (Type&); + + virtual void + capability_post (Type const&); + + virtual void + capability_none (Type&); + + virtual void + capability_none (Type const&); + + virtual void + dependsOn (Type&); + + virtual void + dependsOn (Type const&); + + virtual void + dependsOn_pre (Type&); + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type&); + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type&); + + virtual void + dependsOn_post (Type const&); + + virtual void + dependsOn_none (Type&); + + virtual void + dependsOn_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ConnectorImplementationDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ConnectorImplementationDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + implements (Type&); + + virtual void + implements (Type const&); + + virtual void + implements_none (Type&); + + virtual void + implements_none (Type const&); + + virtual void + assemblyImpl (Type&); + + virtual void + assemblyImpl (Type const&); + + virtual void + assemblyImpl_none (Type&); + + virtual void + assemblyImpl_none (Type const&); + + virtual void + monolithicImpl (Type&); + + virtual void + monolithicImpl (Type const&); + + virtual void + monolithicImpl_none (Type&); + + virtual void + monolithicImpl_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + capability (Type&); + + virtual void + capability (Type const&); + + virtual void + capability_pre (Type&); + + virtual void + capability_pre (Type const&); + + virtual void + capability_next (Type&); + + virtual void + capability_next (Type const&); + + virtual void + capability_post (Type&); + + virtual void + capability_post (Type const&); + + virtual void + capability_none (Type&); + + virtual void + capability_none (Type const&); + + virtual void + dependsOn (Type&); + + virtual void + dependsOn (Type const&); + + virtual void + dependsOn_pre (Type&); + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type&); + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type&); + + virtual void + dependsOn_post (Type const&); + + virtual void + dependsOn_none (Type&); + + virtual void + dependsOn_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct ComponentPackageReference : Traversal::ComponentPackageReference, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentPackageReference Type; + ComponentPackageReference (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + requiredUUID (Type &o) + { + this->requiredUUID (const_cast <Type const &> (o)); + } + + virtual void + requiredUUID (Type const&); + + virtual void + requiredName (Type &o) + { + this->requiredName (const_cast <Type const &> (o)); + } + + virtual void + requiredName (Type const&); + + virtual void + requiredType (Type &o) + { + this->requiredType (const_cast <Type const &> (o)); + } + + virtual void + requiredType (Type const&); + + protected: + ComponentPackageReference (); + }; + + struct SubcomponentInstantiationDescription : Traversal::SubcomponentInstantiationDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SubcomponentInstantiationDescription Type; + SubcomponentInstantiationDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + basePackage (Type &o) + { + this->basePackage (const_cast <Type const &> (o)); + } + + virtual void + basePackage (Type const&); + + virtual void + specializedConfig (Type &o) + { + this->specializedConfig (const_cast <Type const &> (o)); + } + + virtual void + specializedConfig (Type const&); + + virtual void + selectRequirement_pre (Type &o) + { + this->selectRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_pre (Type const&); + + virtual void + selectRequirement_next (Type &o) + { + this->selectRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_next (Type const&); + + virtual void + selectRequirement_post (Type &o) + { + this->selectRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_post (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + referencedPackage (Type &o) + { + this->referencedPackage (const_cast <Type const &> (o)); + } + + virtual void + referencedPackage (Type const&); + + virtual void + importedPackage (Type &o) + { + this->importedPackage (const_cast <Type const &> (o)); + } + + virtual void + importedPackage (Type const&); + + virtual void + id (Type &o) + { + this->id (const_cast <Type const &> (o)); + } + + virtual void + id (Type const&); + + protected: + SubcomponentInstantiationDescription (); + }; + + struct SubcomponentPropertyReference : Traversal::SubcomponentPropertyReference, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::SubcomponentPropertyReference Type; + SubcomponentPropertyReference (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + propertyName (Type &o) + { + this->propertyName (const_cast <Type const &> (o)); + } + + virtual void + propertyName (Type const&); + + virtual void + instance (Type &o) + { + this->instance (const_cast <Type const &> (o)); + } + + virtual void + instance (Type const&); + + protected: + SubcomponentPropertyReference (); + }; + + struct AssemblyPropertyMapping : Traversal::AssemblyPropertyMapping, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::AssemblyPropertyMapping Type; + AssemblyPropertyMapping (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + externalName (Type &o) + { + this->externalName (const_cast <Type const &> (o)); + } + + virtual void + externalName (Type const&); + + virtual void + delegatesTo_pre (Type &o) + { + this->delegatesTo_pre (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_pre (Type const&); + + virtual void + delegatesTo_next (Type &o) + { + this->delegatesTo_next (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_next (Type const&); + + virtual void + delegatesTo_post (Type &o) + { + this->delegatesTo_post (const_cast <Type const &> (o)); + } + + virtual void + delegatesTo_post (Type const&); + + protected: + AssemblyPropertyMapping (); + }; + + struct LocalityKind : Traversal::LocalityKind, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + LocalityKind (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + LocalityKind (); + }; + + struct Locality : Traversal::Locality, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Locality Type; + Locality (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + constraint (Type &o) + { + this->constraint (const_cast <Type const &> (o)); + } + + virtual void + constraint (Type const&); + + virtual void + constrainedInstance (Type &o) + { + this->constrainedInstance (const_cast <Type const &> (o)); + } + + virtual void + constrainedInstance (Type const&); + + protected: + Locality (); + }; + + struct ComponentAssemblyDescription : Traversal::ComponentAssemblyDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentAssemblyDescription Type; + ComponentAssemblyDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + instance_pre (Type &o) + { + this->instance_pre (const_cast <Type const &> (o)); + } + + virtual void + instance_pre (Type const&); + + virtual void + instance_next (Type &o) + { + this->instance_next (const_cast <Type const &> (o)); + } + + virtual void + instance_next (Type const&); + + virtual void + instance_post (Type &o) + { + this->instance_post (const_cast <Type const &> (o)); + } + + virtual void + instance_post (Type const&); + + virtual void + connection_pre (Type &o) + { + this->connection_pre (const_cast <Type const &> (o)); + } + + virtual void + connection_pre (Type const&); + + virtual void + connection_next (Type &o) + { + this->connection_next (const_cast <Type const &> (o)); + } + + virtual void + connection_next (Type const&); + + virtual void + connection_post (Type &o) + { + this->connection_post (const_cast <Type const &> (o)); + } + + virtual void + connection_post (Type const&); + + virtual void + externalProperty_pre (Type &o) + { + this->externalProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_pre (Type const&); + + virtual void + externalProperty_next (Type &o) + { + this->externalProperty_next (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_next (Type const&); + + virtual void + externalProperty_post (Type &o) + { + this->externalProperty_post (const_cast <Type const &> (o)); + } + + virtual void + externalProperty_post (Type const&); + + virtual void + locality_pre (Type &o) + { + this->locality_pre (const_cast <Type const &> (o)); + } + + virtual void + locality_pre (Type const&); + + virtual void + locality_next (Type &o) + { + this->locality_next (const_cast <Type const &> (o)); + } + + virtual void + locality_next (Type const&); + + virtual void + locality_post (Type &o) + { + this->locality_post (const_cast <Type const &> (o)); + } + + virtual void + locality_post (Type const&); + + protected: + ComponentAssemblyDescription (); + }; + + struct MonolithicImplementationDescription : Traversal::MonolithicImplementationDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::MonolithicImplementationDescription Type; + MonolithicImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + nodeExecParameter_pre (Type &o) + { + this->nodeExecParameter_pre (const_cast <Type const &> (o)); + } + + virtual void + nodeExecParameter_pre (Type const&); + + virtual void + nodeExecParameter_next (Type &o) + { + this->nodeExecParameter_next (const_cast <Type const &> (o)); + } + + virtual void + nodeExecParameter_next (Type const&); + + virtual void + nodeExecParameter_post (Type &o) + { + this->nodeExecParameter_post (const_cast <Type const &> (o)); + } + + virtual void + nodeExecParameter_post (Type const&); + + virtual void + componentExecParameter_pre (Type &o) + { + this->componentExecParameter_pre (const_cast <Type const &> (o)); + } + + virtual void + componentExecParameter_pre (Type const&); + + virtual void + componentExecParameter_next (Type &o) + { + this->componentExecParameter_next (const_cast <Type const &> (o)); + } + + virtual void + componentExecParameter_next (Type const&); + + virtual void + componentExecParameter_post (Type &o) + { + this->componentExecParameter_post (const_cast <Type const &> (o)); + } + + virtual void + componentExecParameter_post (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + primaryArtifact_pre (Type &o) + { + this->primaryArtifact_pre (const_cast <Type const &> (o)); + } + + virtual void + primaryArtifact_pre (Type const&); + + virtual void + primaryArtifact_next (Type &o) + { + this->primaryArtifact_next (const_cast <Type const &> (o)); + } + + virtual void + primaryArtifact_next (Type const&); + + virtual void + primaryArtifact_post (Type &o) + { + this->primaryArtifact_post (const_cast <Type const &> (o)); + } + + virtual void + primaryArtifact_post (Type const&); + + protected: + MonolithicImplementationDescription (); + }; + + struct ComponentImplementationDescription : Traversal::ComponentImplementationDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentImplementationDescription Type; + ComponentImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + implements (Type &o) + { + this->implements (const_cast <Type const &> (o)); + } + + virtual void + implements (Type const&); + + virtual void + assemblyImpl (Type &o) + { + this->assemblyImpl (const_cast <Type const &> (o)); + } + + virtual void + assemblyImpl (Type const&); + + virtual void + monolithicImpl (Type &o) + { + this->monolithicImpl (const_cast <Type const &> (o)); + } + + virtual void + monolithicImpl (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + capability_pre (Type &o) + { + this->capability_pre (const_cast <Type const &> (o)); + } + + virtual void + capability_pre (Type const&); + + virtual void + capability_next (Type &o) + { + this->capability_next (const_cast <Type const &> (o)); + } + + virtual void + capability_next (Type const&); + + virtual void + capability_post (Type &o) + { + this->capability_post (const_cast <Type const &> (o)); + } + + virtual void + capability_post (Type const&); + + virtual void + dependsOn_pre (Type &o) + { + this->dependsOn_pre (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type &o) + { + this->dependsOn_next (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type &o) + { + this->dependsOn_post (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ComponentImplementationDescription (); + }; + + struct ConnectorImplementationDescription : Traversal::ConnectorImplementationDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ConnectorImplementationDescription Type; + ConnectorImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + implements (Type &o) + { + this->implements (const_cast <Type const &> (o)); + } + + virtual void + implements (Type const&); + + virtual void + assemblyImpl (Type &o) + { + this->assemblyImpl (const_cast <Type const &> (o)); + } + + virtual void + assemblyImpl (Type const&); + + virtual void + monolithicImpl (Type &o) + { + this->monolithicImpl (const_cast <Type const &> (o)); + } + + virtual void + monolithicImpl (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + capability_pre (Type &o) + { + this->capability_pre (const_cast <Type const &> (o)); + } + + virtual void + capability_pre (Type const&); + + virtual void + capability_next (Type &o) + { + this->capability_next (const_cast <Type const &> (o)); + } + + virtual void + capability_next (Type const&); + + virtual void + capability_post (Type &o) + { + this->capability_post (const_cast <Type const &> (o)); + } + + virtual void + capability_post (Type const&); + + virtual void + dependsOn_pre (Type &o) + { + this->dependsOn_pre (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type &o) + { + this->dependsOn_next (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type &o) + { + this->dependsOn_post (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ConnectorImplementationDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CID_HPP diff --git a/modules/CIAO/tools/Config_Handlers/cpd.cpp b/modules/CIAO/tools/Config_Handlers/cpd.cpp new file mode 100644 index 00000000000..14774d2a6f0 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cpd.cpp @@ -0,0 +1,2081 @@ +/* $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 "cpd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // PackagedComponentImplementation + // + + PackagedComponentImplementation:: + PackagedComponentImplementation (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::ComponentImplementationDescription const& referencedImplementation__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + referencedImplementation_ (new ::CIAO::Config_Handlers::ComponentImplementationDescription (referencedImplementation__)), + regulator__ () + { + name_->container (this); + referencedImplementation_->container (this); + } + + PackagedComponentImplementation:: + PackagedComponentImplementation (PackagedComponentImplementation const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + referencedImplementation_ (new ::CIAO::Config_Handlers::ComponentImplementationDescription (*s.referencedImplementation_)), + regulator__ () + { + name_->container (this); + referencedImplementation_->container (this); + } + + PackagedComponentImplementation& PackagedComponentImplementation:: + operator= (PackagedComponentImplementation const& s) + { + name (*s.name_); + + referencedImplementation (*s.referencedImplementation_); + + return *this; + } + + + // PackagedComponentImplementation + // + ::XMLSchema::string< ACE_TCHAR > const& PackagedComponentImplementation:: + name () const + { + return *name_; + } + + void PackagedComponentImplementation:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // PackagedComponentImplementation + // + ::CIAO::Config_Handlers::ComponentImplementationDescription const& PackagedComponentImplementation:: + referencedImplementation () const + { + return *referencedImplementation_; + } + + void PackagedComponentImplementation:: + referencedImplementation (::CIAO::Config_Handlers::ComponentImplementationDescription const& e) + { + *referencedImplementation_ = e; + } + + + // ComponentPackageDescription + // + + ComponentPackageDescription:: + ComponentPackageDescription () + : + regulator__ () + { + } + + ComponentPackageDescription:: + ComponentPackageDescription (ComponentPackageDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + realizes_ (s.realizes_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.realizes_) : 0), + configProperty_ (s.configProperty_), + implementation_ (s.implementation_), + infoProperty_ (s.infoProperty_), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (realizes_.get ()) realizes_->container (this); + if (href_.get ()) href_->container (this); + } + + ComponentPackageDescription& ComponentPackageDescription:: + operator= (ComponentPackageDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.realizes_.get ()) + realizes (*(s.realizes_)); + else + realizes_.reset (0); + + configProperty_ = s.configProperty_; + + implementation_ = s.implementation_; + + infoProperty_ = s.infoProperty_; + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ComponentPackageDescription + // + bool ComponentPackageDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageDescription:: + label () const + { + return *label_; + } + + void ComponentPackageDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ComponentPackageDescription + // + bool ComponentPackageDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageDescription:: + UUID () const + { + return *UUID_; + } + + void ComponentPackageDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ComponentPackageDescription + // + bool ComponentPackageDescription:: + realizes_p () const + { + return realizes_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ComponentPackageDescription:: + realizes () const + { + return *realizes_; + } + + void ComponentPackageDescription:: + realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + if (realizes_.get ()) + { + *realizes_ = e; + } + + else + { + realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + realizes_->container (this); + } + } + + // ComponentPackageDescription + // + ComponentPackageDescription::configProperty_iterator ComponentPackageDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + ComponentPackageDescription::configProperty_iterator ComponentPackageDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + ComponentPackageDescription::configProperty_const_iterator ComponentPackageDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + ComponentPackageDescription::configProperty_const_iterator ComponentPackageDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void ComponentPackageDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t ComponentPackageDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // ComponentPackageDescription + // + ComponentPackageDescription::implementation_iterator ComponentPackageDescription:: + begin_implementation () + { + return implementation_.begin (); + } + + ComponentPackageDescription::implementation_iterator ComponentPackageDescription:: + end_implementation () + { + return implementation_.end (); + } + + ComponentPackageDescription::implementation_const_iterator ComponentPackageDescription:: + begin_implementation () const + { + return implementation_.begin (); + } + + ComponentPackageDescription::implementation_const_iterator ComponentPackageDescription:: + end_implementation () const + { + return implementation_.end (); + } + + void ComponentPackageDescription:: + add_implementation (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > const& e) + { + implementation_.push_back (e); + } + + size_t ComponentPackageDescription:: + count_implementation(void) const + { + return implementation_.size (); + } + + // ComponentPackageDescription + // + ComponentPackageDescription::infoProperty_iterator ComponentPackageDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ComponentPackageDescription::infoProperty_iterator ComponentPackageDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ComponentPackageDescription::infoProperty_const_iterator ComponentPackageDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ComponentPackageDescription::infoProperty_const_iterator ComponentPackageDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ComponentPackageDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ComponentPackageDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ComponentPackageDescription + // + bool ComponentPackageDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ComponentPackageDescription:: + href () + { + return *href_; + } + + void ComponentPackageDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + + + // ConnectorPackageDescription + // + + ConnectorPackageDescription:: + ConnectorPackageDescription () + : + regulator__ () + { + } + + ConnectorPackageDescription:: + ConnectorPackageDescription (ConnectorPackageDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + realizes_ (s.realizes_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.realizes_) : 0), + configProperty_ (s.configProperty_), + implementation_ (s.implementation_), + infoProperty_ (s.infoProperty_), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (realizes_.get ()) realizes_->container (this); + if (href_.get ()) href_->container (this); + } + + ConnectorPackageDescription& ConnectorPackageDescription:: + operator= (ConnectorPackageDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.realizes_.get ()) + realizes (*(s.realizes_)); + else + realizes_.reset (0); + + configProperty_ = s.configProperty_; + + implementation_ = s.implementation_; + + infoProperty_ = s.infoProperty_; + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ConnectorPackageDescription + // + bool ConnectorPackageDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorPackageDescription:: + label () const + { + return *label_; + } + + void ConnectorPackageDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ConnectorPackageDescription + // + bool ConnectorPackageDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorPackageDescription:: + UUID () const + { + return *UUID_; + } + + void ConnectorPackageDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ConnectorPackageDescription + // + bool ConnectorPackageDescription:: + realizes_p () const + { + return realizes_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ConnectorPackageDescription:: + realizes () const + { + return *realizes_; + } + + void ConnectorPackageDescription:: + realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e) + { + if (realizes_.get ()) + { + *realizes_ = e; + } + + else + { + realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (e)); + realizes_->container (this); + } + } + + // ConnectorPackageDescription + // + ConnectorPackageDescription::configProperty_iterator ConnectorPackageDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + ConnectorPackageDescription::configProperty_iterator ConnectorPackageDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + ConnectorPackageDescription::configProperty_const_iterator ConnectorPackageDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + ConnectorPackageDescription::configProperty_const_iterator ConnectorPackageDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void ConnectorPackageDescription:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t ConnectorPackageDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // ConnectorPackageDescription + // + ConnectorPackageDescription::implementation_iterator ConnectorPackageDescription:: + begin_implementation () + { + return implementation_.begin (); + } + + ConnectorPackageDescription::implementation_iterator ConnectorPackageDescription:: + end_implementation () + { + return implementation_.end (); + } + + ConnectorPackageDescription::implementation_const_iterator ConnectorPackageDescription:: + begin_implementation () const + { + return implementation_.begin (); + } + + ConnectorPackageDescription::implementation_const_iterator ConnectorPackageDescription:: + end_implementation () const + { + return implementation_.end (); + } + + void ConnectorPackageDescription:: + add_implementation (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > const& e) + { + implementation_.push_back (e); + } + + size_t ConnectorPackageDescription:: + count_implementation(void) const + { + return implementation_.size (); + } + + // ConnectorPackageDescription + // + ConnectorPackageDescription::infoProperty_iterator ConnectorPackageDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ConnectorPackageDescription::infoProperty_iterator ConnectorPackageDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ConnectorPackageDescription::infoProperty_const_iterator ConnectorPackageDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ConnectorPackageDescription::infoProperty_const_iterator ConnectorPackageDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ConnectorPackageDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ConnectorPackageDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ConnectorPackageDescription + // + bool ConnectorPackageDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ConnectorPackageDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ConnectorPackageDescription:: + href () + { + return *href_; + } + + void ConnectorPackageDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // PackagedComponentImplementation + // + + PackagedComponentImplementation:: + PackagedComponentImplementation (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("referencedImplementation")) + { + referencedImplementation_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentImplementationDescription > (new ::CIAO::Config_Handlers::ComponentImplementationDescription (e)); + referencedImplementation_->container (this); + } + + else + { + } + } + } + + // ComponentPackageDescription + // + + ComponentPackageDescription:: + ComponentPackageDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("realizes")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + realizes (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("implementation")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PackagedComponentImplementation (e)); + add_implementation (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (t); + } + + else + { + } + } + } + + // ConnectorPackageDescription + // + + ConnectorPackageDescription:: + ConnectorPackageDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("realizes")) + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + realizes (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("implementation")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::ConnectorImplementationDescription (e)); + add_implementation (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (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 PackagedComponentImplementationTypeInfoInitializer + { + PackagedComponentImplementationTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::PackagedComponentImplementation)); + ::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)); + } + }; + + PackagedComponentImplementationTypeInfoInitializer PackagedComponentImplementationTypeInfoInitializer_; + + struct ComponentPackageDescriptionTypeInfoInitializer + { + ComponentPackageDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ComponentPackageDescription)); + ::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)); + } + }; + + ComponentPackageDescriptionTypeInfoInitializer ComponentPackageDescriptionTypeInfoInitializer_; + + struct ConnectorPackageDescriptionTypeInfoInitializer + { + ConnectorPackageDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ConnectorPackageDescription)); + ::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)); + } + }; + + ConnectorPackageDescriptionTypeInfoInitializer ConnectorPackageDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // PackagedComponentImplementation + // + // + + void PackagedComponentImplementation:: + traverse (Type& o) + { + pre (o); + name (o); + referencedImplementation (o); + post (o); + } + + void PackagedComponentImplementation:: + traverse (Type const& o) + { + pre (o); + name (o); + referencedImplementation (o); + post (o); + } + + void PackagedComponentImplementation:: + pre (Type&) + { + } + + void PackagedComponentImplementation:: + pre (Type const&) + { + } + + void PackagedComponentImplementation:: + name (Type& o) + { + dispatch (o.name ()); + } + + void PackagedComponentImplementation:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void PackagedComponentImplementation:: + referencedImplementation (Type& o) + { + dispatch (o.referencedImplementation ()); + } + + void PackagedComponentImplementation:: + referencedImplementation (Type const& o) + { + dispatch (o.referencedImplementation ()); + } + + void PackagedComponentImplementation:: + post (Type&) + { + } + + void PackagedComponentImplementation:: + post (Type const&) + { + } + + // ComponentPackageDescription + // + // + + void ComponentPackageDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + configProperty (o); + implementation (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentPackageDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + configProperty (o); + implementation (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ComponentPackageDescription:: + pre (Type&) + { + } + + void ComponentPackageDescription:: + pre (Type const&) + { + } + + void ComponentPackageDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ComponentPackageDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ComponentPackageDescription:: + label_none (Type&) + { + } + + void ComponentPackageDescription:: + label_none (Type const&) + { + } + + void ComponentPackageDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ComponentPackageDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ComponentPackageDescription:: + UUID_none (Type&) + { + } + + void ComponentPackageDescription:: + UUID_none (Type const&) + { + } + + void ComponentPackageDescription:: + realizes (Type& o) + { + dispatch (o.realizes ()); + } + + void ComponentPackageDescription:: + realizes (Type const& o) + { + dispatch (o.realizes ()); + } + + void ComponentPackageDescription:: + realizes_none (Type&) + { + } + + void ComponentPackageDescription:: + realizes_none (Type const&) + { + } + + void ComponentPackageDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::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 ComponentPackageDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::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 ComponentPackageDescription:: + configProperty_pre (Type&) + { + } + + void ComponentPackageDescription:: + configProperty_pre (Type const&) + { + } + + void ComponentPackageDescription:: + configProperty_next (Type&) + { + } + + void ComponentPackageDescription:: + configProperty_next (Type const&) + { + } + + void ComponentPackageDescription:: + configProperty_post (Type&) + { + } + + void ComponentPackageDescription:: + configProperty_post (Type const&) + { + } + + void ComponentPackageDescription:: + configProperty_none (Type&) + { + } + + void ComponentPackageDescription:: + configProperty_none (Type const&) + { + } + + void ComponentPackageDescription:: + implementation (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::implementation_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void ComponentPackageDescription:: + implementation (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::implementation_const_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void ComponentPackageDescription:: + implementation_pre (Type&) + { + } + + void ComponentPackageDescription:: + implementation_pre (Type const&) + { + } + + void ComponentPackageDescription:: + implementation_next (Type&) + { + } + + void ComponentPackageDescription:: + implementation_next (Type const&) + { + } + + void ComponentPackageDescription:: + implementation_post (Type&) + { + } + + void ComponentPackageDescription:: + implementation_post (Type const&) + { + } + + void ComponentPackageDescription:: + implementation_none (Type&) + { + } + + void ComponentPackageDescription:: + implementation_none (Type const&) + { + } + + void ComponentPackageDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentPackageDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ComponentPackageDescription:: + infoProperty_pre (Type&) + { + } + + void ComponentPackageDescription:: + infoProperty_pre (Type const&) + { + } + + void ComponentPackageDescription:: + infoProperty_next (Type&) + { + } + + void ComponentPackageDescription:: + infoProperty_next (Type const&) + { + } + + void ComponentPackageDescription:: + infoProperty_post (Type&) + { + } + + void ComponentPackageDescription:: + infoProperty_post (Type const&) + { + } + + void ComponentPackageDescription:: + infoProperty_none (Type&) + { + } + + void ComponentPackageDescription:: + infoProperty_none (Type const&) + { + } + + void ComponentPackageDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ComponentPackageDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ComponentPackageDescription:: + href_none (Type&) + { + } + + void ComponentPackageDescription:: + href_none (Type const&) + { + } + + void ComponentPackageDescription:: + post (Type&) + { + } + + void ComponentPackageDescription:: + post (Type const&) + { + } + + // ConnectorPackageDescription + // + // + + void ConnectorPackageDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + configProperty (o); + implementation (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ConnectorPackageDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.realizes_p ()) realizes (o); + else realizes_none (o); + configProperty (o); + implementation (o); + infoProperty (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ConnectorPackageDescription:: + pre (Type&) + { + } + + void ConnectorPackageDescription:: + pre (Type const&) + { + } + + void ConnectorPackageDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ConnectorPackageDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ConnectorPackageDescription:: + label_none (Type&) + { + } + + void ConnectorPackageDescription:: + label_none (Type const&) + { + } + + void ConnectorPackageDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ConnectorPackageDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ConnectorPackageDescription:: + UUID_none (Type&) + { + } + + void ConnectorPackageDescription:: + UUID_none (Type const&) + { + } + + void ConnectorPackageDescription:: + realizes (Type& o) + { + dispatch (o.realizes ()); + } + + void ConnectorPackageDescription:: + realizes (Type const& o) + { + dispatch (o.realizes ()); + } + + void ConnectorPackageDescription:: + realizes_none (Type&) + { + } + + void ConnectorPackageDescription:: + realizes_none (Type const&) + { + } + + void ConnectorPackageDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::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 ConnectorPackageDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::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 ConnectorPackageDescription:: + configProperty_pre (Type&) + { + } + + void ConnectorPackageDescription:: + configProperty_pre (Type const&) + { + } + + void ConnectorPackageDescription:: + configProperty_next (Type&) + { + } + + void ConnectorPackageDescription:: + configProperty_next (Type const&) + { + } + + void ConnectorPackageDescription:: + configProperty_post (Type&) + { + } + + void ConnectorPackageDescription:: + configProperty_post (Type const&) + { + } + + void ConnectorPackageDescription:: + configProperty_none (Type&) + { + } + + void ConnectorPackageDescription:: + configProperty_none (Type const&) + { + } + + void ConnectorPackageDescription:: + implementation (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::implementation_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void ConnectorPackageDescription:: + implementation (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::implementation_const_iterator b (o.begin_implementation()), e (o.end_implementation()); + + if (b != e) + { + implementation_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) implementation_next (o); + } + + implementation_post (o); + } + + else implementation_none (o); + } + + void ConnectorPackageDescription:: + implementation_pre (Type&) + { + } + + void ConnectorPackageDescription:: + implementation_pre (Type const&) + { + } + + void ConnectorPackageDescription:: + implementation_next (Type&) + { + } + + void ConnectorPackageDescription:: + implementation_next (Type const&) + { + } + + void ConnectorPackageDescription:: + implementation_post (Type&) + { + } + + void ConnectorPackageDescription:: + implementation_post (Type const&) + { + } + + void ConnectorPackageDescription:: + implementation_none (Type&) + { + } + + void ConnectorPackageDescription:: + implementation_none (Type const&) + { + } + + void ConnectorPackageDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ConnectorPackageDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ConnectorPackageDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ConnectorPackageDescription:: + infoProperty_pre (Type&) + { + } + + void ConnectorPackageDescription:: + infoProperty_pre (Type const&) + { + } + + void ConnectorPackageDescription:: + infoProperty_next (Type&) + { + } + + void ConnectorPackageDescription:: + infoProperty_next (Type const&) + { + } + + void ConnectorPackageDescription:: + infoProperty_post (Type&) + { + } + + void ConnectorPackageDescription:: + infoProperty_post (Type const&) + { + } + + void ConnectorPackageDescription:: + infoProperty_none (Type&) + { + } + + void ConnectorPackageDescription:: + infoProperty_none (Type const&) + { + } + + void ConnectorPackageDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ConnectorPackageDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ConnectorPackageDescription:: + href_none (Type&) + { + } + + void ConnectorPackageDescription:: + href_none (Type const&) + { + } + + void ConnectorPackageDescription:: + post (Type&) + { + } + + void ConnectorPackageDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // PackagedComponentImplementation + // + // + + PackagedComponentImplementation:: + PackagedComponentImplementation (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PackagedComponentImplementation:: + PackagedComponentImplementation () + { + } + + void PackagedComponentImplementation:: + traverse (Type const& o) + { + Traversal::PackagedComponentImplementation::traverse (o); + } + + void PackagedComponentImplementation:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::PackagedComponentImplementation::name (o); + pop_ (); + } + + void PackagedComponentImplementation:: + referencedImplementation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("referencedImplementation"), top_ ())); + Traversal::PackagedComponentImplementation::referencedImplementation (o); + pop_ (); + } + + // ComponentPackageDescription + // + // + + ComponentPackageDescription:: + ComponentPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPackageDescription:: + ComponentPackageDescription () + { + } + + void ComponentPackageDescription:: + traverse (Type const& o) + { + Traversal::ComponentPackageDescription::traverse (o); + } + + void ComponentPackageDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ComponentPackageDescription::label (o); + pop_ (); + } + + void ComponentPackageDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ComponentPackageDescription::UUID (o); + pop_ (); + } + + void ComponentPackageDescription:: + realizes (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("realizes"), top_ ())); + Traversal::ComponentPackageDescription::realizes (o); + pop_ (); + } + + void ComponentPackageDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void ComponentPackageDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void ComponentPackageDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void ComponentPackageDescription:: + implementation_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implementation"), top_ ())); + } + + void ComponentPackageDescription:: + implementation_next (Type const& o) + { + implementation_post (o); + implementation_pre (o); + } + + void ComponentPackageDescription:: + implementation_post (Type const&) + { + pop_ (); + } + + void ComponentPackageDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ComponentPackageDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ComponentPackageDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ComponentPackageDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ComponentPackageDescription::href (o); + attr_ (0); + } + + // ConnectorPackageDescription + // + // + + ConnectorPackageDescription:: + ConnectorPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ConnectorPackageDescription:: + ConnectorPackageDescription () + { + } + + void ConnectorPackageDescription:: + traverse (Type const& o) + { + Traversal::ConnectorPackageDescription::traverse (o); + } + + void ConnectorPackageDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ConnectorPackageDescription::label (o); + pop_ (); + } + + void ConnectorPackageDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ConnectorPackageDescription::UUID (o); + pop_ (); + } + + void ConnectorPackageDescription:: + realizes (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("realizes"), top_ ())); + Traversal::ConnectorPackageDescription::realizes (o); + pop_ (); + } + + void ConnectorPackageDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void ConnectorPackageDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void ConnectorPackageDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void ConnectorPackageDescription:: + implementation_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("implementation"), top_ ())); + } + + void ConnectorPackageDescription:: + implementation_next (Type const& o) + { + implementation_post (o); + implementation_pre (o); + } + + void ConnectorPackageDescription:: + implementation_post (Type const&) + { + pop_ (); + } + + void ConnectorPackageDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ConnectorPackageDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ConnectorPackageDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ConnectorPackageDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ConnectorPackageDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/cpd.hpp b/modules/CIAO/tools/Config_Handlers/cpd.hpp new file mode 100644 index 00000000000..a6a295393bb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/cpd.hpp @@ -0,0 +1,1008 @@ +/* $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 + +#ifndef CPD_HPP +#define CPD_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class PackagedComponentImplementation; + class ComponentPackageDescription; + class ConnectorPackageDescription; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "cid.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export PackagedComponentImplementation : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PackagedComponentImplementation, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // referencedImplementation + // + public: + ::CIAO::Config_Handlers::ComponentImplementationDescription const& referencedImplementation () const; + void referencedImplementation (::CIAO::Config_Handlers::ComponentImplementationDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentImplementationDescription > referencedImplementation_; + + public: + PackagedComponentImplementation (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::ComponentImplementationDescription const& referencedImplementation__); + + PackagedComponentImplementation (::XSCRT::XML::Element< ACE_TCHAR > const&); + PackagedComponentImplementation (PackagedComponentImplementation const& s); + + PackagedComponentImplementation& + operator= (PackagedComponentImplementation const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ComponentPackageDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentPackageDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // realizes + // + public: + bool realizes_p () const; + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& realizes () const; + void realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > realizes_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // implementation + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > >::iterator implementation_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > >::const_iterator implementation_const_iterator; + implementation_iterator begin_implementation (); + implementation_iterator end_implementation (); + implementation_const_iterator begin_implementation () const; + implementation_const_iterator end_implementation () const; + void add_implementation ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > const& ); + XSCRT::Type* implementation_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_implementation (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackagedComponentImplementation, ACE_Null_Mutex > > implementation_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ComponentPackageDescription (); + + ComponentPackageDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPackageDescription (ComponentPackageDescription const& s); + + ComponentPackageDescription& + operator= (ComponentPackageDescription const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ConnectorPackageDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ConnectorPackageDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // realizes + // + public: + bool realizes_p () const; + ::CIAO::Config_Handlers::ComponentInterfaceDescription const& realizes () const; + void realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > realizes_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // implementation + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > >::iterator implementation_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > >::const_iterator implementation_const_iterator; + implementation_iterator begin_implementation (); + implementation_iterator end_implementation (); + implementation_const_iterator begin_implementation () const; + implementation_const_iterator end_implementation () const; + void add_implementation ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > const& ); + XSCRT::Type* implementation_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_implementation (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::ConnectorImplementationDescription, ACE_Null_Mutex > > implementation_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ConnectorPackageDescription (); + + ConnectorPackageDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ConnectorPackageDescription (ConnectorPackageDescription const& s); + + ConnectorPackageDescription& + operator= (ConnectorPackageDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export PackagedComponentImplementation : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PackagedComponentImplementation > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + referencedImplementation (Type&); + + virtual void + referencedImplementation (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ComponentPackageDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentPackageDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + realizes (Type&); + + virtual void + realizes (Type const&); + + virtual void + realizes_none (Type&); + + virtual void + realizes_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + implementation (Type&); + + virtual void + implementation (Type const&); + + virtual void + implementation_pre (Type&); + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type&); + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type&); + + virtual void + implementation_post (Type const&); + + virtual void + implementation_none (Type&); + + virtual void + implementation_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ConnectorPackageDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ConnectorPackageDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + realizes (Type&); + + virtual void + realizes (Type const&); + + virtual void + realizes_none (Type&); + + virtual void + realizes_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + implementation (Type&); + + virtual void + implementation (Type const&); + + virtual void + implementation_pre (Type&); + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type&); + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type&); + + virtual void + implementation_post (Type const&); + + virtual void + implementation_none (Type&); + + virtual void + implementation_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct PackagedComponentImplementation : Traversal::PackagedComponentImplementation, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PackagedComponentImplementation Type; + PackagedComponentImplementation (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + referencedImplementation (Type &o) + { + this->referencedImplementation (const_cast <Type const &> (o)); + } + + virtual void + referencedImplementation (Type const&); + + protected: + PackagedComponentImplementation (); + }; + + struct ComponentPackageDescription : Traversal::ComponentPackageDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentPackageDescription Type; + ComponentPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + realizes (Type &o) + { + this->realizes (const_cast <Type const &> (o)); + } + + virtual void + realizes (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + implementation_pre (Type &o) + { + this->implementation_pre (const_cast <Type const &> (o)); + } + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type &o) + { + this->implementation_next (const_cast <Type const &> (o)); + } + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type &o) + { + this->implementation_post (const_cast <Type const &> (o)); + } + + virtual void + implementation_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ComponentPackageDescription (); + }; + + struct ConnectorPackageDescription : Traversal::ConnectorPackageDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ConnectorPackageDescription Type; + ConnectorPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + realizes (Type &o) + { + this->realizes (const_cast <Type const &> (o)); + } + + virtual void + realizes (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + implementation_pre (Type &o) + { + this->implementation_pre (const_cast <Type const &> (o)); + } + + virtual void + implementation_pre (Type const&); + + virtual void + implementation_next (Type &o) + { + this->implementation_next (const_cast <Type const &> (o)); + } + + virtual void + implementation_next (Type const&); + + virtual void + implementation_post (Type &o) + { + this->implementation_post (const_cast <Type const &> (o)); + } + + virtual void + implementation_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ConnectorPackageDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CPD_HPP diff --git a/modules/CIAO/tools/Config_Handlers/iad.cpp b/modules/CIAO/tools/Config_Handlers/iad.cpp new file mode 100644 index 00000000000..a3fbba62363 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/iad.cpp @@ -0,0 +1,1491 @@ +/* $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 "iad.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // NamedImplementationArtifact + // + + NamedImplementationArtifact:: + NamedImplementationArtifact (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::ImplementationArtifactDescription const& referencedArtifact__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + referencedArtifact_ (new ::CIAO::Config_Handlers::ImplementationArtifactDescription (referencedArtifact__)), + regulator__ () + { + name_->container (this); + referencedArtifact_->container (this); + } + + NamedImplementationArtifact:: + NamedImplementationArtifact (NamedImplementationArtifact const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + referencedArtifact_ (new ::CIAO::Config_Handlers::ImplementationArtifactDescription (*s.referencedArtifact_)), + regulator__ () + { + name_->container (this); + referencedArtifact_->container (this); + } + + NamedImplementationArtifact& NamedImplementationArtifact:: + operator= (NamedImplementationArtifact const& s) + { + name (*s.name_); + + referencedArtifact (*s.referencedArtifact_); + + return *this; + } + + + // NamedImplementationArtifact + // + ::XMLSchema::string< ACE_TCHAR > const& NamedImplementationArtifact:: + name () const + { + return *name_; + } + + void NamedImplementationArtifact:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // NamedImplementationArtifact + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription const& NamedImplementationArtifact:: + referencedArtifact () const + { + return *referencedArtifact_; + } + + void NamedImplementationArtifact:: + referencedArtifact (::CIAO::Config_Handlers::ImplementationArtifactDescription const& e) + { + *referencedArtifact_ = e; + } + + + // ImplementationArtifactDescription + // + + ImplementationArtifactDescription:: + ImplementationArtifactDescription () + : + regulator__ () + { + } + + ImplementationArtifactDescription:: + ImplementationArtifactDescription (ImplementationArtifactDescription const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + location_ (s.location_), + dependsOn_ (s.dependsOn_), + execParameter_ (s.execParameter_), + infoProperty_ (s.infoProperty_), + deployRequirement_ (s.deployRequirement_), + contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.contentLocation_) : 0), + href_ (s.href_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.href_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ImplementationArtifactDescription& ImplementationArtifactDescription:: + operator= (ImplementationArtifactDescription const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + location_ = s.location_; + + dependsOn_ = s.dependsOn_; + + execParameter_ = s.execParameter_; + + infoProperty_ = s.infoProperty_; + + deployRequirement_ = s.deployRequirement_; + + if (s.contentLocation_.get ()) + contentLocation (*(s.contentLocation_)); + else + contentLocation_.reset (0); + + if (s.href_.get ()) href (*(s.href_)); + else href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ImplementationArtifactDescription + // + bool ImplementationArtifactDescription:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationArtifactDescription:: + label () const + { + return *label_; + } + + void ImplementationArtifactDescription:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // ImplementationArtifactDescription + // + bool ImplementationArtifactDescription:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationArtifactDescription:: + UUID () const + { + return *UUID_; + } + + void ImplementationArtifactDescription:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // ImplementationArtifactDescription + // + ImplementationArtifactDescription::location_iterator ImplementationArtifactDescription:: + begin_location () + { + return location_.begin (); + } + + ImplementationArtifactDescription::location_iterator ImplementationArtifactDescription:: + end_location () + { + return location_.end (); + } + + ImplementationArtifactDescription::location_const_iterator ImplementationArtifactDescription:: + begin_location () const + { + return location_.begin (); + } + + ImplementationArtifactDescription::location_const_iterator ImplementationArtifactDescription:: + end_location () const + { + return location_.end (); + } + + void ImplementationArtifactDescription:: + add_location (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + location_.push_back (e); + } + + size_t ImplementationArtifactDescription:: + count_location(void) const + { + return location_.size (); + } + + // ImplementationArtifactDescription + // + ImplementationArtifactDescription::dependsOn_iterator ImplementationArtifactDescription:: + begin_dependsOn () + { + return dependsOn_.begin (); + } + + ImplementationArtifactDescription::dependsOn_iterator ImplementationArtifactDescription:: + end_dependsOn () + { + return dependsOn_.end (); + } + + ImplementationArtifactDescription::dependsOn_const_iterator ImplementationArtifactDescription:: + begin_dependsOn () const + { + return dependsOn_.begin (); + } + + ImplementationArtifactDescription::dependsOn_const_iterator ImplementationArtifactDescription:: + end_dependsOn () const + { + return dependsOn_.end (); + } + + void ImplementationArtifactDescription:: + add_dependsOn (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > const& e) + { + dependsOn_.push_back (e); + } + + size_t ImplementationArtifactDescription:: + count_dependsOn(void) const + { + return dependsOn_.size (); + } + + // ImplementationArtifactDescription + // + ImplementationArtifactDescription::execParameter_iterator ImplementationArtifactDescription:: + begin_execParameter () + { + return execParameter_.begin (); + } + + ImplementationArtifactDescription::execParameter_iterator ImplementationArtifactDescription:: + end_execParameter () + { + return execParameter_.end (); + } + + ImplementationArtifactDescription::execParameter_const_iterator ImplementationArtifactDescription:: + begin_execParameter () const + { + return execParameter_.begin (); + } + + ImplementationArtifactDescription::execParameter_const_iterator ImplementationArtifactDescription:: + end_execParameter () const + { + return execParameter_.end (); + } + + void ImplementationArtifactDescription:: + add_execParameter (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + execParameter_.push_back (e); + } + + size_t ImplementationArtifactDescription:: + count_execParameter(void) const + { + return execParameter_.size (); + } + + // ImplementationArtifactDescription + // + ImplementationArtifactDescription::infoProperty_iterator ImplementationArtifactDescription:: + begin_infoProperty () + { + return infoProperty_.begin (); + } + + ImplementationArtifactDescription::infoProperty_iterator ImplementationArtifactDescription:: + end_infoProperty () + { + return infoProperty_.end (); + } + + ImplementationArtifactDescription::infoProperty_const_iterator ImplementationArtifactDescription:: + begin_infoProperty () const + { + return infoProperty_.begin (); + } + + ImplementationArtifactDescription::infoProperty_const_iterator ImplementationArtifactDescription:: + end_infoProperty () const + { + return infoProperty_.end (); + } + + void ImplementationArtifactDescription:: + add_infoProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + infoProperty_.push_back (e); + } + + size_t ImplementationArtifactDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ImplementationArtifactDescription + // + ImplementationArtifactDescription::deployRequirement_iterator ImplementationArtifactDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + ImplementationArtifactDescription::deployRequirement_iterator ImplementationArtifactDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + ImplementationArtifactDescription::deployRequirement_const_iterator ImplementationArtifactDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + ImplementationArtifactDescription::deployRequirement_const_iterator ImplementationArtifactDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void ImplementationArtifactDescription:: + add_deployRequirement (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& e) + { + deployRequirement_.push_back (e); + } + + size_t ImplementationArtifactDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // ImplementationArtifactDescription + // + bool ImplementationArtifactDescription:: + contentLocation_p () const + { + return contentLocation_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationArtifactDescription:: + contentLocation () const + { + return *contentLocation_; + } + + void ImplementationArtifactDescription:: + contentLocation (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (contentLocation_.get ()) + { + *contentLocation_ = e; + } + + else + { + contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + contentLocation_->container (this); + } + } + + // ImplementationArtifactDescription + // + bool ImplementationArtifactDescription:: + href_p () const + { + return href_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationArtifactDescription:: + href () const + { + return *href_; + } + + ::XMLSchema::string< ACE_TCHAR >& ImplementationArtifactDescription:: + href () + { + return *href_; + } + + void ImplementationArtifactDescription:: + href (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (href_.get ()) + { + *href_ = e; + } + + else + { + href_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + href_->container (this); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // NamedImplementationArtifact + // + + NamedImplementationArtifact:: + NamedImplementationArtifact (::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 == ACE_TEXT("name")) + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == ACE_TEXT("referencedArtifact")) + { + referencedArtifact_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationArtifactDescription > (new ::CIAO::Config_Handlers::ImplementationArtifactDescription (e)); + referencedArtifact_->container (this); + } + + else + { + } + } + } + + // ImplementationArtifactDescription + // + + ImplementationArtifactDescription:: + ImplementationArtifactDescription (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("location")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_location (t); + } + + else if (n == ACE_TEXT("dependsOn")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::NamedImplementationArtifact (e)); + add_dependsOn (t); + } + + else if (n == ACE_TEXT("execParameter")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_execParameter (t); + } + + else if (n == ACE_TEXT("infoProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_infoProperty (t); + } + + else if (n == ACE_TEXT("deployRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_deployRequirement (t); + } + + else if (n == ACE_TEXT("contentLocation")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + contentLocation (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 == ACE_TEXT ("href")) + { + ::XMLSchema::string< ACE_TCHAR > t (a); + href (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 NamedImplementationArtifactTypeInfoInitializer + { + NamedImplementationArtifactTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::NamedImplementationArtifact)); + ::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)); + } + }; + + NamedImplementationArtifactTypeInfoInitializer NamedImplementationArtifactTypeInfoInitializer_; + + struct ImplementationArtifactDescriptionTypeInfoInitializer + { + ImplementationArtifactDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ImplementationArtifactDescription)); + ::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)); + } + }; + + ImplementationArtifactDescriptionTypeInfoInitializer ImplementationArtifactDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // NamedImplementationArtifact + // + // + + void NamedImplementationArtifact:: + traverse (Type& o) + { + pre (o); + name (o); + referencedArtifact (o); + post (o); + } + + void NamedImplementationArtifact:: + traverse (Type const& o) + { + pre (o); + name (o); + referencedArtifact (o); + post (o); + } + + void NamedImplementationArtifact:: + pre (Type&) + { + } + + void NamedImplementationArtifact:: + pre (Type const&) + { + } + + void NamedImplementationArtifact:: + name (Type& o) + { + dispatch (o.name ()); + } + + void NamedImplementationArtifact:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void NamedImplementationArtifact:: + referencedArtifact (Type& o) + { + dispatch (o.referencedArtifact ()); + } + + void NamedImplementationArtifact:: + referencedArtifact (Type const& o) + { + dispatch (o.referencedArtifact ()); + } + + void NamedImplementationArtifact:: + post (Type&) + { + } + + void NamedImplementationArtifact:: + post (Type const&) + { + } + + // ImplementationArtifactDescription + // + // + + void ImplementationArtifactDescription:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + location (o); + dependsOn (o); + execParameter (o); + infoProperty (o); + deployRequirement (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ImplementationArtifactDescription:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + location (o); + dependsOn (o); + execParameter (o); + infoProperty (o); + deployRequirement (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + if (o.href_p ()) href (o); + else href_none (o); + post (o); + } + + void ImplementationArtifactDescription:: + pre (Type&) + { + } + + void ImplementationArtifactDescription:: + pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + label (Type& o) + { + dispatch (o.label ()); + } + + void ImplementationArtifactDescription:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void ImplementationArtifactDescription:: + label_none (Type&) + { + } + + void ImplementationArtifactDescription:: + label_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void ImplementationArtifactDescription:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void ImplementationArtifactDescription:: + UUID_none (Type&) + { + } + + void ImplementationArtifactDescription:: + UUID_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + location (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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); + } + + else location_none (o); + } + + void ImplementationArtifactDescription:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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); + } + + else location_none (o); + } + + void ImplementationArtifactDescription:: + location_pre (Type&) + { + } + + void ImplementationArtifactDescription:: + location_pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + location_next (Type&) + { + } + + void ImplementationArtifactDescription:: + location_next (Type const&) + { + } + + void ImplementationArtifactDescription:: + location_post (Type&) + { + } + + void ImplementationArtifactDescription:: + location_post (Type const&) + { + } + + void ImplementationArtifactDescription:: + location_none (Type&) + { + } + + void ImplementationArtifactDescription:: + location_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + dependsOn (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::dependsOn_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ImplementationArtifactDescription:: + dependsOn (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::dependsOn_const_iterator b (o.begin_dependsOn()), e (o.end_dependsOn()); + + if (b != e) + { + dependsOn_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) dependsOn_next (o); + } + + dependsOn_post (o); + } + + else dependsOn_none (o); + } + + void ImplementationArtifactDescription:: + dependsOn_pre (Type&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_next (Type&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_next (Type const&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_post (Type&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_post (Type const&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_none (Type&) + { + } + + void ImplementationArtifactDescription:: + dependsOn_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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 ImplementationArtifactDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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 ImplementationArtifactDescription:: + execParameter_pre (Type&) + { + } + + void ImplementationArtifactDescription:: + execParameter_pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + execParameter_next (Type&) + { + } + + void ImplementationArtifactDescription:: + execParameter_next (Type const&) + { + } + + void ImplementationArtifactDescription:: + execParameter_post (Type&) + { + } + + void ImplementationArtifactDescription:: + execParameter_post (Type const&) + { + } + + void ImplementationArtifactDescription:: + execParameter_none (Type&) + { + } + + void ImplementationArtifactDescription:: + execParameter_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + infoProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::infoProperty_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ImplementationArtifactDescription:: + infoProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::infoProperty_const_iterator b (o.begin_infoProperty()), e (o.end_infoProperty()); + + if (b != e) + { + infoProperty_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) infoProperty_next (o); + } + + infoProperty_post (o); + } + + else infoProperty_none (o); + } + + void ImplementationArtifactDescription:: + infoProperty_pre (Type&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_next (Type&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_next (Type const&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_post (Type&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_post (Type const&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_none (Type&) + { + } + + void ImplementationArtifactDescription:: + infoProperty_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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 ImplementationArtifactDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ImplementationArtifactDescription::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 ImplementationArtifactDescription:: + deployRequirement_pre (Type&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_pre (Type const&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_next (Type&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_next (Type const&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_post (Type&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_post (Type const&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_none (Type&) + { + } + + void ImplementationArtifactDescription:: + deployRequirement_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + contentLocation (Type& o) + { + dispatch (o.contentLocation ()); + } + + void ImplementationArtifactDescription:: + contentLocation (Type const& o) + { + dispatch (o.contentLocation ()); + } + + void ImplementationArtifactDescription:: + contentLocation_none (Type&) + { + } + + void ImplementationArtifactDescription:: + contentLocation_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + href (Type& o) + { + dispatch (o.href ()); + } + + void ImplementationArtifactDescription:: + href (Type const& o) + { + dispatch (o.href ()); + } + + void ImplementationArtifactDescription:: + href_none (Type&) + { + } + + void ImplementationArtifactDescription:: + href_none (Type const&) + { + } + + void ImplementationArtifactDescription:: + post (Type&) + { + } + + void ImplementationArtifactDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // NamedImplementationArtifact + // + // + + NamedImplementationArtifact:: + NamedImplementationArtifact (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + NamedImplementationArtifact:: + NamedImplementationArtifact () + { + } + + void NamedImplementationArtifact:: + traverse (Type const& o) + { + Traversal::NamedImplementationArtifact::traverse (o); + } + + void NamedImplementationArtifact:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("name"), top_ ())); + Traversal::NamedImplementationArtifact::name (o); + pop_ (); + } + + void NamedImplementationArtifact:: + referencedArtifact (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("referencedArtifact"), top_ ())); + Traversal::NamedImplementationArtifact::referencedArtifact (o); + pop_ (); + } + + // ImplementationArtifactDescription + // + // + + ImplementationArtifactDescription:: + ImplementationArtifactDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ImplementationArtifactDescription:: + ImplementationArtifactDescription () + { + } + + void ImplementationArtifactDescription:: + traverse (Type const& o) + { + Traversal::ImplementationArtifactDescription::traverse (o); + } + + void ImplementationArtifactDescription:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::ImplementationArtifactDescription::label (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::ImplementationArtifactDescription::UUID (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("location"), top_ ())); + } + + void ImplementationArtifactDescription:: + location_next (Type const& o) + { + location_post (o); + location_pre (o); + } + + void ImplementationArtifactDescription:: + location_post (Type const&) + { + pop_ (); + } + + void ImplementationArtifactDescription:: + dependsOn_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("dependsOn"), top_ ())); + } + + void ImplementationArtifactDescription:: + dependsOn_next (Type const& o) + { + dependsOn_post (o); + dependsOn_pre (o); + } + + void ImplementationArtifactDescription:: + dependsOn_post (Type const&) + { + pop_ (); + } + + void ImplementationArtifactDescription:: + execParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("execParameter"), top_ ())); + } + + void ImplementationArtifactDescription:: + execParameter_next (Type const& o) + { + execParameter_post (o); + execParameter_pre (o); + } + + void ImplementationArtifactDescription:: + execParameter_post (Type const&) + { + pop_ (); + } + + void ImplementationArtifactDescription:: + infoProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("infoProperty"), top_ ())); + } + + void ImplementationArtifactDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ImplementationArtifactDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ImplementationArtifactDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("deployRequirement"), top_ ())); + } + + void ImplementationArtifactDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void ImplementationArtifactDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void ImplementationArtifactDescription:: + contentLocation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("contentLocation"), top_ ())); + Traversal::ImplementationArtifactDescription::contentLocation (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (ACE_TEXT ("href"), ACE_TEXT (""), top_ ()); + attr_ (&a); + Traversal::ImplementationArtifactDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/iad.hpp b/modules/CIAO/tools/Config_Handlers/iad.hpp new file mode 100644 index 00000000000..e26a5a4e1fb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/iad.hpp @@ -0,0 +1,748 @@ +/* $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 + +#ifndef IAD_HPP +#define IAD_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class NamedImplementationArtifact; + class ImplementationArtifactDescription; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export NamedImplementationArtifact : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < NamedImplementationArtifact, ACE_Null_Mutex > _ptr; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // referencedArtifact + // + public: + ::CIAO::Config_Handlers::ImplementationArtifactDescription const& referencedArtifact () const; + void referencedArtifact (::CIAO::Config_Handlers::ImplementationArtifactDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationArtifactDescription > referencedArtifact_; + + public: + NamedImplementationArtifact (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::ImplementationArtifactDescription const& referencedArtifact__); + + NamedImplementationArtifact (::XSCRT::XML::Element< ACE_TCHAR > const&); + NamedImplementationArtifact (NamedImplementationArtifact const& s); + + NamedImplementationArtifact& + operator= (NamedImplementationArtifact const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export ImplementationArtifactDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ImplementationArtifactDescription, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // location + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator location_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator location_const_iterator; + location_iterator begin_location (); + location_iterator end_location (); + location_const_iterator begin_location () const; + location_const_iterator end_location () const; + void add_location ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* location_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_location (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > location_; + + // dependsOn + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > >::iterator dependsOn_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > >::const_iterator dependsOn_const_iterator; + dependsOn_iterator begin_dependsOn (); + dependsOn_iterator end_dependsOn (); + dependsOn_const_iterator begin_dependsOn () const; + dependsOn_const_iterator end_dependsOn () const; + void add_dependsOn ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > const& ); + XSCRT::Type* dependsOn_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::NamedImplementationArtifact, ACE_Null_Mutex > > dependsOn_; + + // execParameter + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator execParameter_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator execParameter_const_iterator; + execParameter_iterator begin_execParameter (); + execParameter_iterator end_execParameter (); + execParameter_const_iterator begin_execParameter () const; + execParameter_const_iterator end_execParameter () const; + void add_execParameter ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* execParameter_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > execParameter_; + + // infoProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator infoProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator infoProperty_const_iterator; + infoProperty_iterator begin_infoProperty (); + infoProperty_iterator end_infoProperty (); + infoProperty_const_iterator begin_infoProperty () const; + infoProperty_const_iterator end_infoProperty () const; + void add_infoProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* infoProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > infoProperty_; + + // deployRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator deployRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator deployRequirement_const_iterator; + deployRequirement_iterator begin_deployRequirement (); + deployRequirement_iterator end_deployRequirement (); + deployRequirement_const_iterator begin_deployRequirement () const; + deployRequirement_const_iterator end_deployRequirement () const; + void add_deployRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* deployRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > deployRequirement_; + + // contentLocation + // + public: + bool contentLocation_p () const; + ::XMLSchema::string< ACE_TCHAR > const& contentLocation () const; + void contentLocation (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > contentLocation_; + + // href + // + public: + bool href_p () const; + ::XMLSchema::string< ACE_TCHAR > const& href () const; + ::XMLSchema::string< ACE_TCHAR >& href (); + void href (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > href_; + + public: + ImplementationArtifactDescription (); + + ImplementationArtifactDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ImplementationArtifactDescription (ImplementationArtifactDescription const& s); + + ImplementationArtifactDescription& + operator= (ImplementationArtifactDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export NamedImplementationArtifact : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::NamedImplementationArtifact > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + name (Type&); + + virtual void + name (Type const&); + + virtual void + referencedArtifact (Type&); + + virtual void + referencedArtifact (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export ImplementationArtifactDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ImplementationArtifactDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + location (Type&); + + virtual void + location (Type const&); + + virtual void + location_pre (Type&); + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type&); + + virtual void + location_next (Type const&); + + virtual void + location_post (Type&); + + virtual void + location_post (Type const&); + + virtual void + location_none (Type&); + + virtual void + location_none (Type const&); + + virtual void + dependsOn (Type&); + + virtual void + dependsOn (Type const&); + + virtual void + dependsOn_pre (Type&); + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type&); + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type&); + + virtual void + dependsOn_post (Type const&); + + virtual void + dependsOn_none (Type&); + + virtual void + dependsOn_none (Type const&); + + virtual void + execParameter (Type&); + + virtual void + execParameter (Type const&); + + virtual void + execParameter_pre (Type&); + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type&); + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type&); + + virtual void + execParameter_post (Type const&); + + virtual void + execParameter_none (Type&); + + virtual void + execParameter_none (Type const&); + + virtual void + infoProperty (Type&); + + virtual void + infoProperty (Type const&); + + virtual void + infoProperty_pre (Type&); + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type&); + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type&); + + virtual void + infoProperty_post (Type const&); + + virtual void + infoProperty_none (Type&); + + virtual void + infoProperty_none (Type const&); + + virtual void + deployRequirement (Type&); + + virtual void + deployRequirement (Type const&); + + virtual void + deployRequirement_pre (Type&); + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type&); + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type&); + + virtual void + deployRequirement_post (Type const&); + + virtual void + deployRequirement_none (Type&); + + virtual void + deployRequirement_none (Type const&); + + virtual void + contentLocation (Type&); + + virtual void + contentLocation (Type const&); + + virtual void + contentLocation_none (Type&); + + virtual void + contentLocation_none (Type const&); + + virtual void + href (Type&); + + virtual void + href (Type const&); + + virtual void + href_none (Type&); + + virtual void + href_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct NamedImplementationArtifact : Traversal::NamedImplementationArtifact, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::NamedImplementationArtifact Type; + NamedImplementationArtifact (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + name (Type &o) + { + this->name (const_cast <Type const &> (o)); + } + + virtual void + name (Type const&); + + virtual void + referencedArtifact (Type &o) + { + this->referencedArtifact (const_cast <Type const &> (o)); + } + + virtual void + referencedArtifact (Type const&); + + protected: + NamedImplementationArtifact (); + }; + + struct ImplementationArtifactDescription : Traversal::ImplementationArtifactDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ImplementationArtifactDescription Type; + ImplementationArtifactDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + location_pre (Type &o) + { + this->location_pre (const_cast <Type const &> (o)); + } + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type &o) + { + this->location_next (const_cast <Type const &> (o)); + } + + virtual void + location_next (Type const&); + + virtual void + location_post (Type &o) + { + this->location_post (const_cast <Type const &> (o)); + } + + virtual void + location_post (Type const&); + + virtual void + dependsOn_pre (Type &o) + { + this->dependsOn_pre (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_pre (Type const&); + + virtual void + dependsOn_next (Type &o) + { + this->dependsOn_next (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_next (Type const&); + + virtual void + dependsOn_post (Type &o) + { + this->dependsOn_post (const_cast <Type const &> (o)); + } + + virtual void + dependsOn_post (Type const&); + + virtual void + execParameter_pre (Type &o) + { + this->execParameter_pre (const_cast <Type const &> (o)); + } + + virtual void + execParameter_pre (Type const&); + + virtual void + execParameter_next (Type &o) + { + this->execParameter_next (const_cast <Type const &> (o)); + } + + virtual void + execParameter_next (Type const&); + + virtual void + execParameter_post (Type &o) + { + this->execParameter_post (const_cast <Type const &> (o)); + } + + virtual void + execParameter_post (Type const&); + + virtual void + infoProperty_pre (Type &o) + { + this->infoProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_pre (Type const&); + + virtual void + infoProperty_next (Type &o) + { + this->infoProperty_next (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_next (Type const&); + + virtual void + infoProperty_post (Type &o) + { + this->infoProperty_post (const_cast <Type const &> (o)); + } + + virtual void + infoProperty_post (Type const&); + + virtual void + deployRequirement_pre (Type &o) + { + this->deployRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_pre (Type const&); + + virtual void + deployRequirement_next (Type &o) + { + this->deployRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_next (Type const&); + + virtual void + deployRequirement_post (Type &o) + { + this->deployRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + deployRequirement_post (Type const&); + + virtual void + contentLocation (Type &o) + { + this->contentLocation (const_cast <Type const &> (o)); + } + + virtual void + contentLocation (Type const&); + + virtual void + href (Type &o) + { + this->href (const_cast <Type const &> (o)); + } + + virtual void + href (Type const&); + + protected: + ImplementationArtifactDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // IAD_HPP diff --git a/modules/CIAO/tools/Config_Handlers/pcd.cpp b/modules/CIAO/tools/Config_Handlers/pcd.cpp new file mode 100644 index 00000000000..6418d0172dc --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/pcd.cpp @@ -0,0 +1,1304 @@ +/* $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 "pcd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // ComponentPackageImport + // + + ComponentPackageImport:: + ComponentPackageImport () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ComponentPackageImport:: + ComponentPackageImport (ComponentPackageImport const& s) + : + ::XSCRT::Type (), + location_ (s.location_), + regulator__ () + { + } + + ComponentPackageImport& ComponentPackageImport:: + operator= (ComponentPackageImport const& s) + { + location_ = s.location_; + + return *this; + } + + + // ComponentPackageImport + // + ComponentPackageImport::location_iterator ComponentPackageImport:: + begin_location () + { + return location_.begin (); + } + + ComponentPackageImport::location_iterator ComponentPackageImport:: + end_location () + { + return location_.end (); + } + + ComponentPackageImport::location_const_iterator ComponentPackageImport:: + begin_location () const + { + return location_.begin (); + } + + ComponentPackageImport::location_const_iterator ComponentPackageImport:: + end_location () const + { + return location_.end (); + } + + void ComponentPackageImport:: + add_location (ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& e) + { + location_.push_back (e); + } + + size_t ComponentPackageImport:: + count_location(void) const + { + return location_.size (); + } + + + // PackageConfiguration + // + + PackageConfiguration:: + PackageConfiguration () + : + regulator__ () + { + } + + PackageConfiguration:: + PackageConfiguration (PackageConfiguration const& s) + : + ::XSCRT::Type (), + label_ (s.label_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.label_) : 0), + UUID_ (s.UUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.UUID_) : 0), + basePackage_ (s.basePackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageDescription (*s.basePackage_) : 0), + specializedConfig_ (s.specializedConfig_.get () ? new ::CIAO::Config_Handlers::PackageConfiguration (*s.specializedConfig_) : 0), + importedPackage_ (s.importedPackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageImport (*s.importedPackage_) : 0), + referencedPackage_ (s.referencedPackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageReference (*s.referencedPackage_) : 0), + selectRequirement_ (s.selectRequirement_), + configProperty_ (s.configProperty_), + contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.contentLocation_) : 0), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (basePackage_.get ()) basePackage_->container (this); + if (specializedConfig_.get ()) specializedConfig_->container (this); + if (importedPackage_.get ()) importedPackage_->container (this); + if (referencedPackage_.get ()) referencedPackage_->container (this); + if (contentLocation_.get ()) contentLocation_->container (this); + } + + PackageConfiguration& PackageConfiguration:: + operator= (PackageConfiguration const& s) + { + if (s.label_.get ()) + label (*(s.label_)); + else + label_.reset (0); + + if (s.UUID_.get ()) + UUID (*(s.UUID_)); + else + UUID_.reset (0); + + if (s.basePackage_.get ()) + basePackage (*(s.basePackage_)); + else + basePackage_.reset (0); + + if (s.specializedConfig_.get ()) + specializedConfig (*(s.specializedConfig_)); + else + specializedConfig_.reset (0); + + if (s.importedPackage_.get ()) + importedPackage (*(s.importedPackage_)); + else + importedPackage_.reset (0); + + if (s.referencedPackage_.get ()) + referencedPackage (*(s.referencedPackage_)); + else + referencedPackage_.reset (0); + + selectRequirement_ = s.selectRequirement_; + + configProperty_ = s.configProperty_; + + if (s.contentLocation_.get ()) + contentLocation (*(s.contentLocation_)); + else + contentLocation_.reset (0); + + return *this; + } + + + // PackageConfiguration + // + bool PackageConfiguration:: + label_p () const + { + return label_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PackageConfiguration:: + label () const + { + return *label_; + } + + void PackageConfiguration:: + label (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (label_.get ()) + { + *label_ = e; + } + + else + { + label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + label_->container (this); + } + } + + // PackageConfiguration + // + bool PackageConfiguration:: + UUID_p () const + { + return UUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PackageConfiguration:: + UUID () const + { + return *UUID_; + } + + void PackageConfiguration:: + UUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (UUID_.get ()) + { + *UUID_ = e; + } + + else + { + UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + UUID_->container (this); + } + } + + // PackageConfiguration + // + bool PackageConfiguration:: + basePackage_p () const + { + return basePackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageDescription const& PackageConfiguration:: + basePackage () const + { + return *basePackage_; + } + + void PackageConfiguration:: + basePackage (::CIAO::Config_Handlers::ComponentPackageDescription const& e) + { + if (basePackage_.get ()) + { + *basePackage_ = e; + } + + else + { + basePackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > (new ::CIAO::Config_Handlers::ComponentPackageDescription (e)); + basePackage_->container (this); + } + } + + // PackageConfiguration + // + bool PackageConfiguration:: + specializedConfig_p () const + { + return specializedConfig_.get () != 0; + } + + ::CIAO::Config_Handlers::PackageConfiguration const& PackageConfiguration:: + specializedConfig () const + { + return *specializedConfig_; + } + + void PackageConfiguration:: + specializedConfig (::CIAO::Config_Handlers::PackageConfiguration const& e) + { + if (specializedConfig_.get ()) + { + *specializedConfig_ = e; + } + + else + { + specializedConfig_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > (new ::CIAO::Config_Handlers::PackageConfiguration (e)); + specializedConfig_->container (this); + } + } + + // PackageConfiguration + // + bool PackageConfiguration:: + importedPackage_p () const + { + return importedPackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageImport const& PackageConfiguration:: + importedPackage () const + { + return *importedPackage_; + } + + void PackageConfiguration:: + importedPackage (::CIAO::Config_Handlers::ComponentPackageImport const& e) + { + if (importedPackage_.get ()) + { + *importedPackage_ = e; + } + + else + { + importedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > (new ::CIAO::Config_Handlers::ComponentPackageImport (e)); + importedPackage_->container (this); + } + } + + // PackageConfiguration + // + bool PackageConfiguration:: + referencedPackage_p () const + { + return referencedPackage_.get () != 0; + } + + ::CIAO::Config_Handlers::ComponentPackageReference const& PackageConfiguration:: + referencedPackage () const + { + return *referencedPackage_; + } + + void PackageConfiguration:: + referencedPackage (::CIAO::Config_Handlers::ComponentPackageReference const& e) + { + if (referencedPackage_.get ()) + { + *referencedPackage_ = e; + } + + else + { + referencedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (new ::CIAO::Config_Handlers::ComponentPackageReference (e)); + referencedPackage_->container (this); + } + } + + // PackageConfiguration + // + PackageConfiguration::selectRequirement_iterator PackageConfiguration:: + begin_selectRequirement () + { + return selectRequirement_.begin (); + } + + PackageConfiguration::selectRequirement_iterator PackageConfiguration:: + end_selectRequirement () + { + return selectRequirement_.end (); + } + + PackageConfiguration::selectRequirement_const_iterator PackageConfiguration:: + begin_selectRequirement () const + { + return selectRequirement_.begin (); + } + + PackageConfiguration::selectRequirement_const_iterator PackageConfiguration:: + end_selectRequirement () const + { + return selectRequirement_.end (); + } + + void PackageConfiguration:: + add_selectRequirement (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& e) + { + selectRequirement_.push_back (e); + } + + size_t PackageConfiguration:: + count_selectRequirement(void) const + { + return selectRequirement_.size (); + } + + // PackageConfiguration + // + PackageConfiguration::configProperty_iterator PackageConfiguration:: + begin_configProperty () + { + return configProperty_.begin (); + } + + PackageConfiguration::configProperty_iterator PackageConfiguration:: + end_configProperty () + { + return configProperty_.end (); + } + + PackageConfiguration::configProperty_const_iterator PackageConfiguration:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + PackageConfiguration::configProperty_const_iterator PackageConfiguration:: + end_configProperty () const + { + return configProperty_.end (); + } + + void PackageConfiguration:: + add_configProperty (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& e) + { + configProperty_.push_back (e); + } + + size_t PackageConfiguration:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // PackageConfiguration + // + bool PackageConfiguration:: + contentLocation_p () const + { + return contentLocation_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PackageConfiguration:: + contentLocation () const + { + return *contentLocation_; + } + + void PackageConfiguration:: + contentLocation (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (contentLocation_.get ()) + { + *contentLocation_ = e; + } + + else + { + contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + contentLocation_->container (this); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // ComponentPackageImport + // + + ComponentPackageImport:: + ComponentPackageImport (::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 == ACE_TEXT("location")) + { + ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > t (new ::XMLSchema::string< ACE_TCHAR > (e)); + add_location (t); + } + + else + { + } + } + } + + // PackageConfiguration + // + + PackageConfiguration:: + PackageConfiguration (::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 == ACE_TEXT("label")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == ACE_TEXT("UUID")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == ACE_TEXT("basePackage")) + { + ::CIAO::Config_Handlers::ComponentPackageDescription t (e); + basePackage (t); + } + + else if (n == ACE_TEXT("specializedConfig")) + { + ::CIAO::Config_Handlers::PackageConfiguration t (e); + specializedConfig (t); + } + + else if (n == ACE_TEXT("importedPackage")) + { + ::CIAO::Config_Handlers::ComponentPackageImport t (e); + importedPackage (t); + } + + else if (n == ACE_TEXT("referencedPackage")) + { + ::CIAO::Config_Handlers::ComponentPackageReference t (e); + referencedPackage (t); + } + + else if (n == ACE_TEXT("selectRequirement")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Requirement (e)); + add_selectRequirement (t); + } + + else if (n == ACE_TEXT("configProperty")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::Property (e)); + add_configProperty (t); + } + + else if (n == ACE_TEXT("contentLocation")) + { + ::XMLSchema::string< ACE_TCHAR > t (e); + contentLocation (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 ComponentPackageImportTypeInfoInitializer + { + ComponentPackageImportTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::ComponentPackageImport)); + ::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)); + } + }; + + ComponentPackageImportTypeInfoInitializer ComponentPackageImportTypeInfoInitializer_; + + struct PackageConfigurationTypeInfoInitializer + { + PackageConfigurationTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::PackageConfiguration)); + ::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)); + } + }; + + PackageConfigurationTypeInfoInitializer PackageConfigurationTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // ComponentPackageImport + // + // + + void ComponentPackageImport:: + traverse (Type& o) + { + pre (o); + location (o); + post (o); + } + + void ComponentPackageImport:: + traverse (Type const& o) + { + pre (o); + location (o); + post (o); + } + + void ComponentPackageImport:: + pre (Type&) + { + } + + void ComponentPackageImport:: + pre (Type const&) + { + } + + void ComponentPackageImport:: + location (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageImport::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); + } + + else location_none (o); + } + + void ComponentPackageImport:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::ComponentPackageImport::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); + } + + else location_none (o); + } + + void ComponentPackageImport:: + location_pre (Type&) + { + } + + void ComponentPackageImport:: + location_pre (Type const&) + { + } + + void ComponentPackageImport:: + location_next (Type&) + { + } + + void ComponentPackageImport:: + location_next (Type const&) + { + } + + void ComponentPackageImport:: + location_post (Type&) + { + } + + void ComponentPackageImport:: + location_post (Type const&) + { + } + + void ComponentPackageImport:: + location_none (Type&) + { + } + + void ComponentPackageImport:: + location_none (Type const&) + { + } + + void ComponentPackageImport:: + post (Type&) + { + } + + void ComponentPackageImport:: + post (Type const&) + { + } + + // PackageConfiguration + // + // + + void PackageConfiguration:: + traverse (Type& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.basePackage_p ()) basePackage (o); + else basePackage_none (o); + if (o.specializedConfig_p ()) specializedConfig (o); + else specializedConfig_none (o); + if (o.importedPackage_p ()) importedPackage (o); + else importedPackage_none (o); + if (o.referencedPackage_p ()) referencedPackage (o); + else referencedPackage_none (o); + selectRequirement (o); + configProperty (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + post (o); + } + + void PackageConfiguration:: + traverse (Type const& o) + { + pre (o); + if (o.label_p ()) label (o); + else label_none (o); + if (o.UUID_p ()) UUID (o); + else UUID_none (o); + if (o.basePackage_p ()) basePackage (o); + else basePackage_none (o); + if (o.specializedConfig_p ()) specializedConfig (o); + else specializedConfig_none (o); + if (o.importedPackage_p ()) importedPackage (o); + else importedPackage_none (o); + if (o.referencedPackage_p ()) referencedPackage (o); + else referencedPackage_none (o); + selectRequirement (o); + configProperty (o); + if (o.contentLocation_p ()) contentLocation (o); + else contentLocation_none (o); + post (o); + } + + void PackageConfiguration:: + pre (Type&) + { + } + + void PackageConfiguration:: + pre (Type const&) + { + } + + void PackageConfiguration:: + label (Type& o) + { + dispatch (o.label ()); + } + + void PackageConfiguration:: + label (Type const& o) + { + dispatch (o.label ()); + } + + void PackageConfiguration:: + label_none (Type&) + { + } + + void PackageConfiguration:: + label_none (Type const&) + { + } + + void PackageConfiguration:: + UUID (Type& o) + { + dispatch (o.UUID ()); + } + + void PackageConfiguration:: + UUID (Type const& o) + { + dispatch (o.UUID ()); + } + + void PackageConfiguration:: + UUID_none (Type&) + { + } + + void PackageConfiguration:: + UUID_none (Type const&) + { + } + + void PackageConfiguration:: + basePackage (Type& o) + { + dispatch (o.basePackage ()); + } + + void PackageConfiguration:: + basePackage (Type const& o) + { + dispatch (o.basePackage ()); + } + + void PackageConfiguration:: + basePackage_none (Type&) + { + } + + void PackageConfiguration:: + basePackage_none (Type const&) + { + } + + void PackageConfiguration:: + specializedConfig (Type& o) + { + dispatch (o.specializedConfig ()); + } + + void PackageConfiguration:: + specializedConfig (Type const& o) + { + dispatch (o.specializedConfig ()); + } + + void PackageConfiguration:: + specializedConfig_none (Type&) + { + } + + void PackageConfiguration:: + specializedConfig_none (Type const&) + { + } + + void PackageConfiguration:: + importedPackage (Type& o) + { + dispatch (o.importedPackage ()); + } + + void PackageConfiguration:: + importedPackage (Type const& o) + { + dispatch (o.importedPackage ()); + } + + void PackageConfiguration:: + importedPackage_none (Type&) + { + } + + void PackageConfiguration:: + importedPackage_none (Type const&) + { + } + + void PackageConfiguration:: + referencedPackage (Type& o) + { + dispatch (o.referencedPackage ()); + } + + void PackageConfiguration:: + referencedPackage (Type const& o) + { + dispatch (o.referencedPackage ()); + } + + void PackageConfiguration:: + referencedPackage_none (Type&) + { + } + + void PackageConfiguration:: + referencedPackage_none (Type const&) + { + } + + void PackageConfiguration:: + selectRequirement (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PackageConfiguration::selectRequirement_iterator b (o.begin_selectRequirement()), e (o.end_selectRequirement()); + + if (b != e) + { + selectRequirement_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) selectRequirement_next (o); + } + + selectRequirement_post (o); + } + + else selectRequirement_none (o); + } + + void PackageConfiguration:: + selectRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PackageConfiguration::selectRequirement_const_iterator b (o.begin_selectRequirement()), e (o.end_selectRequirement()); + + if (b != e) + { + selectRequirement_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) selectRequirement_next (o); + } + + selectRequirement_post (o); + } + + else selectRequirement_none (o); + } + + void PackageConfiguration:: + selectRequirement_pre (Type&) + { + } + + void PackageConfiguration:: + selectRequirement_pre (Type const&) + { + } + + void PackageConfiguration:: + selectRequirement_next (Type&) + { + } + + void PackageConfiguration:: + selectRequirement_next (Type const&) + { + } + + void PackageConfiguration:: + selectRequirement_post (Type&) + { + } + + void PackageConfiguration:: + selectRequirement_post (Type const&) + { + } + + void PackageConfiguration:: + selectRequirement_none (Type&) + { + } + + void PackageConfiguration:: + selectRequirement_none (Type const&) + { + } + + void PackageConfiguration:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PackageConfiguration::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 PackageConfiguration:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::PackageConfiguration::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 PackageConfiguration:: + configProperty_pre (Type&) + { + } + + void PackageConfiguration:: + configProperty_pre (Type const&) + { + } + + void PackageConfiguration:: + configProperty_next (Type&) + { + } + + void PackageConfiguration:: + configProperty_next (Type const&) + { + } + + void PackageConfiguration:: + configProperty_post (Type&) + { + } + + void PackageConfiguration:: + configProperty_post (Type const&) + { + } + + void PackageConfiguration:: + configProperty_none (Type&) + { + } + + void PackageConfiguration:: + configProperty_none (Type const&) + { + } + + void PackageConfiguration:: + contentLocation (Type& o) + { + dispatch (o.contentLocation ()); + } + + void PackageConfiguration:: + contentLocation (Type const& o) + { + dispatch (o.contentLocation ()); + } + + void PackageConfiguration:: + contentLocation_none (Type&) + { + } + + void PackageConfiguration:: + contentLocation_none (Type const&) + { + } + + void PackageConfiguration:: + post (Type&) + { + } + + void PackageConfiguration:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // ComponentPackageImport + // + // + + ComponentPackageImport:: + ComponentPackageImport (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPackageImport:: + ComponentPackageImport () + { + } + + void ComponentPackageImport:: + traverse (Type const& o) + { + Traversal::ComponentPackageImport::traverse (o); + } + + void ComponentPackageImport:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("location"), top_ ())); + } + + void ComponentPackageImport:: + location_next (Type const& o) + { + location_post (o); + location_pre (o); + } + + void ComponentPackageImport:: + location_post (Type const&) + { + pop_ (); + } + + // PackageConfiguration + // + // + + PackageConfiguration:: + PackageConfiguration (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PackageConfiguration:: + PackageConfiguration () + { + } + + void PackageConfiguration:: + traverse (Type const& o) + { + Traversal::PackageConfiguration::traverse (o); + } + + void PackageConfiguration:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("label"), top_ ())); + Traversal::PackageConfiguration::label (o); + pop_ (); + } + + void PackageConfiguration:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("UUID"), top_ ())); + Traversal::PackageConfiguration::UUID (o); + pop_ (); + } + + void PackageConfiguration:: + basePackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("basePackage"), top_ ())); + Traversal::PackageConfiguration::basePackage (o); + pop_ (); + } + + void PackageConfiguration:: + specializedConfig (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("specializedConfig"), top_ ())); + Traversal::PackageConfiguration::specializedConfig (o); + pop_ (); + } + + void PackageConfiguration:: + importedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("importedPackage"), top_ ())); + Traversal::PackageConfiguration::importedPackage (o); + pop_ (); + } + + void PackageConfiguration:: + referencedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("referencedPackage"), top_ ())); + Traversal::PackageConfiguration::referencedPackage (o); + pop_ (); + } + + void PackageConfiguration:: + selectRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("selectRequirement"), top_ ())); + } + + void PackageConfiguration:: + selectRequirement_next (Type const& o) + { + selectRequirement_post (o); + selectRequirement_pre (o); + } + + void PackageConfiguration:: + selectRequirement_post (Type const&) + { + pop_ (); + } + + void PackageConfiguration:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("configProperty"), top_ ())); + } + + void PackageConfiguration:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void PackageConfiguration:: + configProperty_post (Type const&) + { + pop_ (); + } + + void PackageConfiguration:: + contentLocation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("contentLocation"), top_ ())); + Traversal::PackageConfiguration::contentLocation (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/pcd.hpp b/modules/CIAO/tools/Config_Handlers/pcd.hpp new file mode 100644 index 00000000000..8d8d6828bab --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/pcd.hpp @@ -0,0 +1,647 @@ +/* $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 + +#ifndef PCD_HPP +#define PCD_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class ComponentPackageImport; + class PackageConfiguration; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "Basic_Deployment_Data.hpp" + +#include "cpd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export ComponentPackageImport : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < ComponentPackageImport, ACE_Null_Mutex > _ptr; + + // location + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::iterator location_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > >::const_iterator location_const_iterator; + location_iterator begin_location (); + location_iterator end_location (); + location_const_iterator begin_location () const; + location_const_iterator end_location () const; + void add_location ( ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > const& ); + XSCRT::Type* location_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_location (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::XMLSchema::string< ACE_TCHAR >, ACE_Null_Mutex > > location_; + + public: + ComponentPackageImport (); + + ComponentPackageImport (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPackageImport (ComponentPackageImport const& s); + + ComponentPackageImport& + operator= (ComponentPackageImport const& s); + + private: + char regulator__; + }; + + + class XSC_XML_Handlers_Export PackageConfiguration : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < PackageConfiguration, ACE_Null_Mutex > _ptr; + + // label + // + public: + bool label_p () const; + ::XMLSchema::string< ACE_TCHAR > const& label () const; + void label (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > label_; + + // UUID + // + public: + bool UUID_p () const; + ::XMLSchema::string< ACE_TCHAR > const& UUID () const; + void UUID (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > UUID_; + + // basePackage + // + public: + bool basePackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageDescription const& basePackage () const; + void basePackage (::CIAO::Config_Handlers::ComponentPackageDescription const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > basePackage_; + + // specializedConfig + // + public: + bool specializedConfig_p () const; + ::CIAO::Config_Handlers::PackageConfiguration const& specializedConfig () const; + void specializedConfig (::CIAO::Config_Handlers::PackageConfiguration const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > specializedConfig_; + + // importedPackage + // + public: + bool importedPackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageImport const& importedPackage () const; + void importedPackage (::CIAO::Config_Handlers::ComponentPackageImport const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > importedPackage_; + + // referencedPackage + // + public: + bool referencedPackage_p () const; + ::CIAO::Config_Handlers::ComponentPackageReference const& referencedPackage () const; + void referencedPackage (::CIAO::Config_Handlers::ComponentPackageReference const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > referencedPackage_; + + // selectRequirement + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::iterator selectRequirement_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > >::const_iterator selectRequirement_const_iterator; + selectRequirement_iterator begin_selectRequirement (); + selectRequirement_iterator end_selectRequirement (); + selectRequirement_const_iterator begin_selectRequirement () const; + selectRequirement_const_iterator end_selectRequirement () const; + void add_selectRequirement ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > const& ); + XSCRT::Type* selectRequirement_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_selectRequirement (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Requirement, ACE_Null_Mutex > > selectRequirement_; + + // configProperty + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::iterator configProperty_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > >::const_iterator configProperty_const_iterator; + configProperty_iterator begin_configProperty (); + configProperty_iterator end_configProperty (); + configProperty_const_iterator begin_configProperty () const; + configProperty_const_iterator end_configProperty () const; + void add_configProperty ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > const& ); + XSCRT::Type* configProperty_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::Property, ACE_Null_Mutex > > configProperty_; + + // contentLocation + // + public: + bool contentLocation_p () const; + ::XMLSchema::string< ACE_TCHAR > const& contentLocation () const; + void contentLocation (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > contentLocation_; + + public: + PackageConfiguration (); + + PackageConfiguration (::XSCRT::XML::Element< ACE_TCHAR > const&); + PackageConfiguration (PackageConfiguration const& s); + + PackageConfiguration& + operator= (PackageConfiguration const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export ComponentPackageImport : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ComponentPackageImport > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + location (Type&); + + virtual void + location (Type const&); + + virtual void + location_pre (Type&); + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type&); + + virtual void + location_next (Type const&); + + virtual void + location_post (Type&); + + virtual void + location_post (Type const&); + + virtual void + location_none (Type&); + + virtual void + location_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct XSC_XML_Handlers_Export PackageConfiguration : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PackageConfiguration > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + label (Type&); + + virtual void + label (Type const&); + + virtual void + label_none (Type&); + + virtual void + label_none (Type const&); + + virtual void + UUID (Type&); + + virtual void + UUID (Type const&); + + virtual void + UUID_none (Type&); + + virtual void + UUID_none (Type const&); + + virtual void + basePackage (Type&); + + virtual void + basePackage (Type const&); + + virtual void + basePackage_none (Type&); + + virtual void + basePackage_none (Type const&); + + virtual void + specializedConfig (Type&); + + virtual void + specializedConfig (Type const&); + + virtual void + specializedConfig_none (Type&); + + virtual void + specializedConfig_none (Type const&); + + virtual void + importedPackage (Type&); + + virtual void + importedPackage (Type const&); + + virtual void + importedPackage_none (Type&); + + virtual void + importedPackage_none (Type const&); + + virtual void + referencedPackage (Type&); + + virtual void + referencedPackage (Type const&); + + virtual void + referencedPackage_none (Type&); + + virtual void + referencedPackage_none (Type const&); + + virtual void + selectRequirement (Type&); + + virtual void + selectRequirement (Type const&); + + virtual void + selectRequirement_pre (Type&); + + virtual void + selectRequirement_pre (Type const&); + + virtual void + selectRequirement_next (Type&); + + virtual void + selectRequirement_next (Type const&); + + virtual void + selectRequirement_post (Type&); + + virtual void + selectRequirement_post (Type const&); + + virtual void + selectRequirement_none (Type&); + + virtual void + selectRequirement_none (Type const&); + + virtual void + configProperty (Type&); + + virtual void + configProperty (Type const&); + + virtual void + configProperty_pre (Type&); + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type&); + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type&); + + virtual void + configProperty_post (Type const&); + + virtual void + configProperty_none (Type&); + + virtual void + configProperty_none (Type const&); + + virtual void + contentLocation (Type&); + + virtual void + contentLocation (Type const&); + + virtual void + contentLocation_none (Type&); + + virtual void + contentLocation_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct ComponentPackageImport : Traversal::ComponentPackageImport, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ComponentPackageImport Type; + ComponentPackageImport (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + location_pre (Type &o) + { + this->location_pre (const_cast <Type const &> (o)); + } + + virtual void + location_pre (Type const&); + + virtual void + location_next (Type &o) + { + this->location_next (const_cast <Type const &> (o)); + } + + virtual void + location_next (Type const&); + + virtual void + location_post (Type &o) + { + this->location_post (const_cast <Type const &> (o)); + } + + virtual void + location_post (Type const&); + + protected: + ComponentPackageImport (); + }; + + struct PackageConfiguration : Traversal::PackageConfiguration, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PackageConfiguration Type; + PackageConfiguration (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + label (Type &o) + { + this->label (const_cast <Type const &> (o)); + } + + virtual void + label (Type const&); + + virtual void + UUID (Type &o) + { + this->UUID (const_cast <Type const &> (o)); + } + + virtual void + UUID (Type const&); + + virtual void + basePackage (Type &o) + { + this->basePackage (const_cast <Type const &> (o)); + } + + virtual void + basePackage (Type const&); + + virtual void + specializedConfig (Type &o) + { + this->specializedConfig (const_cast <Type const &> (o)); + } + + virtual void + specializedConfig (Type const&); + + virtual void + importedPackage (Type &o) + { + this->importedPackage (const_cast <Type const &> (o)); + } + + virtual void + importedPackage (Type const&); + + virtual void + referencedPackage (Type &o) + { + this->referencedPackage (const_cast <Type const &> (o)); + } + + virtual void + referencedPackage (Type const&); + + virtual void + selectRequirement_pre (Type &o) + { + this->selectRequirement_pre (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_pre (Type const&); + + virtual void + selectRequirement_next (Type &o) + { + this->selectRequirement_next (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_next (Type const&); + + virtual void + selectRequirement_post (Type &o) + { + this->selectRequirement_post (const_cast <Type const &> (o)); + } + + virtual void + selectRequirement_post (Type const&); + + virtual void + configProperty_pre (Type &o) + { + this->configProperty_pre (const_cast <Type const &> (o)); + } + + virtual void + configProperty_pre (Type const&); + + virtual void + configProperty_next (Type &o) + { + this->configProperty_next (const_cast <Type const &> (o)); + } + + virtual void + configProperty_next (Type const&); + + virtual void + configProperty_post (Type &o) + { + this->configProperty_post (const_cast <Type const &> (o)); + } + + virtual void + configProperty_post (Type const&); + + virtual void + contentLocation (Type &o) + { + this->contentLocation (const_cast <Type const &> (o)); + } + + virtual void + contentLocation (Type const&); + + protected: + PackageConfiguration (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // PCD_HPP diff --git a/modules/CIAO/tools/Config_Handlers/test.cdp b/modules/CIAO/tools/Config_Handlers/test.cdp new file mode 100644 index 00000000000..2430859601b --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/test.cdp @@ -0,0 +1,1827 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no" ?> +<Deployment:deploymentPlan xmlns:Deployment="http://www.omg.org/Deployment" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.omg.org/Deployment Deployment.xsd"> + +<UUID>8E8594AF-3310-446F-95E2-4440D622D5CE</UUID> + +<implementation id="_2D19FD96-440B-48D4-8D68-4E9B466B2BCC"> +<name>RT1H_Combined.ComponentImplementations.Config_Op_Impl.Config_Op</name> +<source/> +<artifact>_304555B7-9E3A-4DC5-9535-FA774FAA5070</artifact> +<artifact>_358C7270-F290-465E-B0E4-5FD390980B44</artifact> +<artifact>_C4A896EE-C035-45F1-8F14-2320383B1991</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_DA5C3C13-030E-4971-A0BF-8631563EFDF3"> +<name>RT1H_Combined.ComponentImplementations.Planner_One_Impl.MonolithicImplementation</name> +<source/> +<artifact>_6C7AA3D5-7A09-4DEF-8D49-60A4E1DE173D</artifact> +<artifact>_1DAD54BC-F7B5-41E3-9FFC-3E0AE255D989</artifact> +<artifact>_66E9CA12-F886-4760-A9B3-DB1E3F27B920</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_A7DAA16F-D455-4C63-92CE-05B98DD34B15"> +<name>RT1H_Combined.ComponentImplementations.Planner_Three_Impl.MonolithicImplementation</name> +<source/> +<artifact>_2748D2D1-AAE5-4934-A43F-1639241C4351</artifact> +<artifact>_556249CC-E874-4BC6-9411-1B33EB2B895B</artifact> +<artifact>_458C6E27-87CA-4F77-8036-C9F612511B6F</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_A8181747-270E-43FF-B723-50825AA8EA74"> +<name>RT1H_Combined.ComponentImplementations.Env_Dectector_Impl.MonolithicImplementation</name> +<source/> +<artifact>_1A46D81D-989F-406B-9E87-A57D63ADDF43</artifact> +<artifact>_208D7378-B123-4F15-B376-CAA58B5CB1E0</artifact> +<artifact>_5D7CAC69-4E3B-45F9-BACD-B12D3A86AC7A</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_05FAFE3F-76B3-4C6E-A86B-0225B9E76909"> +<name>RT1H_Combined.ComponentImplementations.Effector_Main_Impl.MonolithicImplementation</name> +<source/> +<artifact>_D40E03AB-CE43-49D6-A7FF-C1231FE98898</artifact> +<artifact>_840618C0-5513-4389-97A4-C53EB87B29A0</artifact> +<artifact>_E1AF706E-0B37-480B-8B26-E844FE2E9C3E</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_8D45FC0E-C3DD-4671-926D-A08430B37D37"> +<name>RT1H_Combined.ComponentImplementations.Effector_Secondary_Impl.MonolithicImplementation</name> +<source/> +<artifact>__31B2C21F-86C7-4306-AA10-33687687B5D0</artifact> +<artifact>__C7A0B01C-6C13-4EAA-8527-155035BF1A00</artifact> +<artifact>__2F43BA6B-2749-4744-B9C4-18F4AEAC16C9</artifact> +<execParameter> +<name>LoadAverage</name> +<value> +<type> +<kind>tk_double</kind> +</type> +<value> +<double>.25</double> +</value> +</value> +</execParameter> +</implementation> + +<implementation id="_2DF6D3BE-F1A2-43E1-BEA0-54576784FF96"> +<name>RT1H_Combined.CUTS_ComponentImplementations.BDC_Implementation.BDC_Monolithic_Impl</name> +<source/> +<artifact>__55C2DCD4-30B1-46A3-86B2-229896D74D0D</artifact> +<artifact>__BF5CDECF-AF12-4876-9B6C-211B7BF0B22F</artifact> +<artifact>_0E615519-6CC8-4EA5-B67A-65FF73586F04</artifact> +</implementation> + +<implementation id="_BA0C4535-191E-4BE0-9BF4-A054EB2C4139"> +<name>RT1H_Combined.CUTS_ComponentImplementations.BDC_Ex_Implementation.BDC_Ex_Impl</name> +<source/> +<artifact>_2DBFA82B-1D1F-48C6-9BDC-014E789E6A77</artifact> +<artifact>_5CE1793F-38DD-427D-A21E-E6D870E769E4</artifact> +<artifact>_0B8A6C29-8962-4DA6-99F4-25FEECD77E97</artifact> +</implementation> + +<implementation id="_D98AF36F-11FA-43A4-8FAD-C14A461437FF"> +<name>RT1H_Combined.RACE_ComponentImplementations.ControllerImplementation.ControllerMonolithicImpl</name> +<source/> +<artifact>__032AE7B6-3ABD-478A-B0D7-56BC4AAEF0B7</artifact> +<artifact>__00B105AB-50F5-49B7-A822-9B267F2D8896</artifact> +<artifact>__BF4AE6A2-BE32-4B8E-9919-C812EC18BF00</artifact> +</implementation> + +<implementation id="_CA363CD1-4E23-4A4B-B25B-C38B939E2B25"> +<name>RT1H_Combined.RACE_ComponentImplementations.TargetManagerImplImplementation.TargetManagerImplMonolithicImpl</name> +<source/> +<artifact>__C22D0B06-6CDA-4652-B1CE-586E0C23251F</artifact> +<artifact>__9CB3A43B-397F-4FA9-97AA-EBFC3A22BFEC</artifact> +<artifact>__0F176DA2-9953-482A-9268-7DA5E69A88FE</artifact> +</implementation> + +<implementation id="_7A233158-69BB-4382-BDE0-72432BF3D48E"> +<name>RT1H_Combined.RA_ComponentImplementations.AnalyzerImplementation.AnalyzerMonolithicImpl</name> +<source/> +<artifact>__315FC65C-0582-4E0E-BB8B-C23A1238C67F</artifact> +<artifact>__7AD332BC-90DC-4E7D-B026-8D5053F2552E</artifact> +<artifact>__84974D39-AE18-4C0A-B81A-B1EC349E93BB</artifact> +</implementation> + +<implementation id="_14E77757-BC3A-49F4-8D45-FB447FA7F626"> +<name>RT1H_Combined.RA_ComponentImplementations.SimpleAllocationAnalyzerImplementation.SimpleAllocationAnalyzerMonolithicImpl</name> +<source/> +<artifact>__6BDE830C-FFA8-4F2D-9733-34F02F35020F</artifact> +<artifact>__138A0FE1-D8AA-4C1E-BB5E-4EC9714F4CA8</artifact> +<artifact>__621F3412-C507-4945-836B-CF9B81BDCC99</artifact> +</implementation> + +<implementation id="_E4DC8736-E532-44DC-9C9B-789EBA3D6B27"> +<name>RT1H_Combined.RA_ComponentImplementations.Input_AdapterImplementation.Input_AdapterMonolithicImpl</name> +<source/> +<artifact>__DC22BCBB-DB20-4072-AA64-161AFD7A9C10</artifact> +<artifact>__3E362049-0CF5-4F01-905F-67CAD769FFD5</artifact> +<artifact>__3B466B60-F8C2-4E48-A6E4-3D3D7EED9F03</artifact> +</implementation> + +<implementation id="_73898E70-9FB1-4881-9313-A2DE181EE48E"> +<name>RT1H_Combined.RA_ComponentImplementations.Interactive_Input_AdapterImplementation.Interactive_Input_AdapterMonolithicImpl</name> +<source/> +<artifact>__AD4B52E0-103C-49E2-BE47-29CAE978676F</artifact> +<artifact>__E4AF24BF-5A39-46B1-8217-6343D7D53298</artifact> +<artifact>__76A0CEFE-E2F7-4BF7-BB91-F309FB5AD33C</artifact> +</implementation> + +<implementation id="_796D9731-1CD9-4855-83F2-025AECB90C93"> +<name>RT1H_Combined.RA_ComponentImplementations.Output_AdapterImplementation.Output_AdapterMonolithicImpl</name> +<source/> +<artifact>__864DB99C-C60B-4FDD-A47D-AFD5C1599892</artifact> +<artifact>__D6EB8E01-F794-4C43-AB14-A3AFB9767D01</artifact> +<artifact>__4C78C4F9-FEF4-45AA-84A4-FFB10255A1EC</artifact> +</implementation> + +<implementation id="_A22015F9-9BC9-4767-A861-FAFF737E074B"> +<name>RT1H_Combined.RA_ComponentImplementations.Output_ManagerImplementation.Output_ManagerMonolithicImpl</name> +<source/> +<artifact>__AB498B7F-A0E8-4F59-BF24-BBB9D125EED3</artifact> +<artifact>__1BB4CD4A-38A8-4BBA-9303-4A10F5B8BC57</artifact> +<artifact>__280E6118-F4C7-4DE4-A0A4-A50637282EAE</artifact> +</implementation> + +<implementation id="_219DB379-DB2E-44D2-8308-D91FC5A42A9D"> +<name>RT1H_Combined.RA_ComponentImplementations.DAnCE_Output_AdapterImplementation.DAnCE_Output_AdapterMonolithicImpl</name> +<source/> +<artifact>__A47095F9-2E08-485E-96B4-CC0829051DF3</artifact> +<artifact>__E54AE941-14CA-48FC-BAAA-1B93269EF79B</artifact> +<artifact>__ACA6BD67-D92A-4DBF-827A-7C0B15EA3F6D</artifact> +</implementation> + +<implementation id="_5A98D073-1392-4C85-AB88-1AD6E61BF34D"> +<name>RT1H_Combined.RA_ComponentImplementations.XML_Output_AdapterImplementation.XML_Output_AdapterMonolithicImpl</name> +<source/> +<artifact>__CF7C6C9B-C6E3-4356-B9F1-598FA0B4A5B7</artifact> +<artifact>__437B6234-9DD3-40E4-9AE0-0923EBAF4548</artifact> +<artifact>__E2F1EA75-127C-4579-B692-ADD1026C6F23</artifact> +</implementation> + +<implementation id="_571F6ECC-579F-4F69-88AB-EA1603B422E8"> +<name>RT1H_Combined.RA_ComponentImplementations.PlannerImplementation.PlannerMonolithicImpl</name> +<source/> +<artifact>__B28C1F32-0231-4F7F-8FE2-164321942B87</artifact> +<artifact>__2021EE2F-3480-4BF9-9A3A-D146A99D251D</artifact> +<artifact>__D952F988-841F-43BA-9650-86846B08DF5F</artifact> +</implementation> + +<implementation id="_38C5B64C-72FD-48FF-B095-260669E2A488"> +<name>RT1H_Combined.RA_ComponentImplementations.SimpleBinPackerImplementation.SimpleBinPackerMonolithicImpl</name> +<source/> +<artifact>__2B5FE9E6-AF4C-4BC1-92A2-58101B2ECCA8</artifact> +<artifact>__4D375D8F-5470-4236-8614-EF07D08020E3</artifact> +<artifact>__D6176B6C-58E4-43D4-BFC9-3DCF98249044</artifact> +</implementation> + +<implementation id="_FD120510-765E-4B02-803D-7DADF3F5E4E6"> +<name>RT1H_Combined.RA_ComponentImplementations.Planner_ManagerImplementation.Planner_ManagerMonolithicImpl</name> +<source/> +<artifact>__5B614077-C99E-428C-B8BE-252ADD7905B7</artifact> +<artifact>__0BEB188E-3967-4D91-A6A1-CDF08EF81718</artifact> +<artifact>__A65A1FA0-8F4D-4807-9AE9-90D344154D2C</artifact> +</implementation> + +<implementation id="_5D6641D2-640C-4F80-B055-10DC69C7A636"> +<name>RT1H_Combined.RA_ComponentImplementations.Plan_AnalyzerImplementation.Plan_AnalyzerMonolithicImpl</name> +<source/> +<artifact>__1CC443DF-7EE3-4130-8ACE-EE4181AC96CD</artifact> +<artifact>__57123764-8624-4D79-9C5B-7ADF929536E6</artifact> +<artifact>__CDC7061A-483C-447B-8151-E68250566E86</artifact> +</implementation> + +<instance id="_3FD684C5-47B0-4E8C-88D0-8AD9CEB11FEB"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.EnvDetector1</name> +<node>blade44</node> +<source/> +<implementation>_A8181747-270E-43FF-B723-50825AA8EA74</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Env_Detector.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_AC6DB008-DCCB-45D7-B52D-628B74B49AC9"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.EnvDetector2</name> +<node>blade44</node> +<source/> +<implementation>_A8181747-270E-43FF-B723-50825AA8EA74</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Env_Detector.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_7529501D-B22A-42F9-A75B-0E71DC97D3AA"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.EnvDetecto3</name> +<node>blade44</node> +<source/> +<implementation>_A8181747-270E-43FF-B723-50825AA8EA74</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Env_Detector.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_FEBD6AD3-6310-4E25-A0E5-957DED0B6509"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.EnvDetector4</name> +<node>blade44</node> +<source/> +<implementation>_A8181747-270E-43FF-B723-50825AA8EA74</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Env_Detector.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_2F3B1B72-DB17-47E7-BA21-1ABEF84032EC"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Effector3</name> +<node>blade43</node> +<source/> +<implementation>_8D45FC0E-C3DD-4671-926D-A08430B37D37</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Effectory_Secondary.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_EC0045E5-7501-4E2B-B755-D8CE22BF4816"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Effector2</name> +<node>blade43</node> +<source/> +<implementation>_8D45FC0E-C3DD-4671-926D-A08430B37D37</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Effectory_Secondary.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_57B08287-3528-4862-9110-ACACD713360B"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Effector4</name> +<node>blade43</node> +<source/> +<implementation>_8D45FC0E-C3DD-4671-926D-A08430B37D37</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Effectory_Secondary.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_AB189D2B-6D86-4020-88BD-74DBECC7F7B8"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Planner_Three</name> +<node>blade39</node> +<source/> +<implementation>_A7DAA16F-D455-4C63-92CE-05B98DD34B15</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Planner_Three.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_002D7B3A-A628-43E3-AD53-B1AB8636001E"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Planner_One</name> +<node>blade42</node> +<source/> +<implementation>_DA5C3C13-030E-4971-A0BF-8631563EFDF3</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Planner_One.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_015ACD88-117F-42C9-8D04-3FFAB9F6C98E"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Effector_Main</name> +<node>blade41</node> +<source/> +<implementation>_05FAFE3F-76B3-4C6E-A86B-0225B9E76909</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Effectory_Main.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_34C61830-1F54-494F-95DE-4003BCD428C5"> +<name>RT1H_Combined.ComponentImplementations.RT1H.RT1H.Config_Op</name> +<node>blade40</node> +<source/> +<implementation>_2D19FD96-440B-48D4-8D68-4E9B466B2BCC</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>Config_Op.ior</string> +</value> +</value> +</configProperty> +</instance> + +<instance id="_7AE0BE73-48F8-4717-A5FF-524D454C58DD"> +<name>RT1H_Combined.ComponentImplementations.RACE.RACE.Benchmark_Data_Collector_Ex</name> +<node>blade10</node> +<source/> +<implementation>_BA0C4535-191E-4BE0-9BF4-A054EB2C4139</implementation> +<configProperty> +<name>ComponentIOR</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>BDC_Ex.ior</string> +</value> +</value> +</configProperty> +<configProperty> +<name>server_name</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>blade10.isislab.vanderbilt.edu</string> +</value> +</value> +</configProperty> +</instance> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_002D7B3A-A628-43E3-AD53-B1AB8636001E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_34C61830-1F54-494F-95DE-4003BCD428C5</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_57B08287-3528-4862-9110-ACACD713360B</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_2F3B1B72-DB17-47E7-BA21-1ABEF84032EC</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_EC0045E5-7501-4E2B-B755-D8CE22BF4816</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_FEBD6AD3-6310-4E25-A0E5-957DED0B6509</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_7529501D-B22A-42F9-A75B-0E71DC97D3AA</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_AC6DB008-DCCB-45D7-B52D-628B74B49AC9</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>cuts_testing_service_testing_service</name> +<internalEndpoint> +<portName>cuts_testing_service</portName> +<kind>SimplexReceptacle</kind> +<instance>_3FD684C5-47B0-4E8C-88D0-8AD9CEB11FEB</instance> +</internalEndpoint> +<internalEndpoint> +<portName>testing_service</portName> +<kind>Facet</kind> +<instance>_7AE0BE73-48F8-4717-A5FF-524D454C58DD</instance> +</internalEndpoint> +</connection> + +<connection> +<name>status_status</name> +<internalEndpoint> +<portName>status</portName> +<kind>EventPublisher</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>status</portName> +<kind>EventConsumer</kind> +<instance>_34C61830-1F54-494F-95DE-4003BCD428C5</instance> +</internalEndpoint> +</connection> + +<connection> +<name>status_status</name> +<internalEndpoint> +<portName>status</portName> +<kind>EventPublisher</kind> +<instance>_EC0045E5-7501-4E2B-B755-D8CE22BF4816</instance> +</internalEndpoint> +<internalEndpoint> +<portName>status</portName> +<kind>EventConsumer</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +</connection> + +<connection> +<name>status_status</name> +<internalEndpoint> +<portName>status</portName> +<kind>EventPublisher</kind> +<instance>_57B08287-3528-4862-9110-ACACD713360B</instance> +</internalEndpoint> +<internalEndpoint> +<portName>status</portName> +<kind>EventConsumer</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +</connection> + +<connection> +<name>status_status</name> +<internalEndpoint> +<portName>status</portName> +<kind>EventPublisher</kind> +<instance>_2F3B1B72-DB17-47E7-BA21-1ABEF84032EC</instance> +</internalEndpoint> +<internalEndpoint> +<portName>status</portName> +<kind>EventConsumer</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_34C61830-1F54-494F-95DE-4003BCD428C5</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_57B08287-3528-4862-9110-ACACD713360B</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_EC0045E5-7501-4E2B-B755-D8CE22BF4816</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_015ACD88-117F-42C9-8D04-3FFAB9F6C98E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_2F3B1B72-DB17-47E7-BA21-1ABEF84032EC</instance> +</internalEndpoint> +</connection> + +<connection> +<name>assessment_assessment</name> +<internalEndpoint> +<portName>assessment</portName> +<kind>EventPublisher</kind> +<instance>_002D7B3A-A628-43E3-AD53-B1AB8636001E</instance> +</internalEndpoint> +<internalEndpoint> +<portName>assessment</portName> +<kind>EventConsumer</kind> +<instance>_34C61830-1F54-494F-95DE-4003BCD428C5</instance> +</internalEndpoint> +</connection> + +<connection> +<name>situation_situation</name> +<internalEndpoint> +<portName>situation</portName> +<kind>EventPublisher</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>situation</portName> +<kind>EventConsumer</kind> +<instance>_002D7B3A-A628-43E3-AD53-B1AB8636001E</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_FEBD6AD3-6310-4E25-A0E5-957DED0B6509</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_3FD684C5-47B0-4E8C-88D0-8AD9CEB11FEB</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_7529501D-B22A-42F9-A75B-0E71DC97D3AA</instance> +</internalEndpoint> +</connection> + +<connection> +<name>command_command</name> +<internalEndpoint> +<portName>command</portName> +<kind>EventPublisher</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +<internalEndpoint> +<portName>command</portName> +<kind>EventConsumer</kind> +<instance>_AC6DB008-DCCB-45D7-B52D-628B74B49AC9</instance> +</internalEndpoint> +</connection> + +<connection> +<name>track_track</name> +<internalEndpoint> +<portName>track</portName> +<kind>EventPublisher</kind> +<instance>_FEBD6AD3-6310-4E25-A0E5-957DED0B6509</instance> +</internalEndpoint> +<internalEndpoint> +<portName>track</portName> +<kind>EventConsumer</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +</connection> + +<connection> +<name>track_track</name> +<internalEndpoint> +<portName>track</portName> +<kind>EventPublisher</kind> +<instance>_7529501D-B22A-42F9-A75B-0E71DC97D3AA</instance> +</internalEndpoint> +<internalEndpoint> +<portName>track</portName> +<kind>EventConsumer</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +</connection> + +<connection> +<name>track_track</name> +<internalEndpoint> +<portName>track</portName> +<kind>EventPublisher</kind> +<instance>_AC6DB008-DCCB-45D7-B52D-628B74B49AC9</instance> +</internalEndpoint> +<internalEndpoint> +<portName>track</portName> +<kind>EventConsumer</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +</connection> + +<connection> +<name>track_track</name> +<internalEndpoint> +<portName>track</portName> +<kind>EventPublisher</kind> +<instance>_3FD684C5-47B0-4E8C-88D0-8AD9CEB11FEB</instance> +</internalEndpoint> +<internalEndpoint> +<portName>track</portName> +<kind>EventConsumer</kind> +<instance>_AB189D2B-6D86-4020-88BD-74DBECC7F7B8</instance> +</internalEndpoint> +</connection> + +<artifact id="_358C7270-F290-465E-B0E4-5FD390980B44"> +<name>RT1H_Combined.ImplementationArtifacts.Config_Op_Artifacts.Config_Op_stub</name> +<source/> +<node/> +<location>Config_Op_CoWorkEr_stub</location> +</artifact> + +<artifact id="_304555B7-9E3A-4DC5-9535-FA774FAA5070"> +<name>RT1H_Combined.ImplementationArtifacts.Config_Op_Artifacts.Config_Op_svnt</name> +<source/> +<node/> +<location>Config_Op_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Config_Op_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_C4A896EE-C035-45F1-8F14-2320383B1991"> +<name>RT1H_Combined.ImplementationArtifacts.Config_Op_Artifacts.Config_Op_exec</name> +<source/> +<node/> +<location>Config_Op_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Config_Op_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_208D7378-B123-4F15-B376-CAA58B5CB1E0"> +<name>RT1H_Combined.ImplementationArtifacts.Env_Dectector_Artifacts.Env_Detector_exec</name> +<source/> +<node/> +<location>Env_Detector_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Env_Detector_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_5D7CAC69-4E3B-45F9-BACD-B12D3A86AC7A"> +<name>RT1H_Combined.ImplementationArtifacts.Env_Dectector_Artifacts.Env_Dectector_stub</name> +<source/> +<node/> +<location>Env_Detector_CoWorkEr_stub</location> +</artifact> + +<artifact id="_1A46D81D-989F-406B-9E87-A57D63ADDF43"> +<name>RT1H_Combined.ImplementationArtifacts.Env_Dectector_Artifacts.Env_Detector_svnt</name> +<source/> +<node/> +<location>Env_Detector_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Env_Detector_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_1DAD54BC-F7B5-41E3-9FFC-3E0AE255D989"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_One_Artifacts.Planner_One_stub</name> +<source/> +<node/> +<location>Planner_One_CoWorkEr_stub</location> +</artifact> + +<artifact id="_6C7AA3D5-7A09-4DEF-8D49-60A4E1DE173D"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_One_Artifacts.Planner_One_svnt</name> +<source/> +<node/> +<location>Planner_One_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Planner_One_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_66E9CA12-F886-4760-A9B3-DB1E3F27B920"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_One_Artifacts.Planner_One_exec</name> +<source/> +<node/> +<location>Planner_One_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Planner_One_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__C7A0B01C-6C13-4EAA-8527-155035BF1A00"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Secondary_Artifacts.Effector_Secondary_svnt</name> +<source/> +<node/> +<location>Effector_Secondary_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Effector_Secondary_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__31B2C21F-86C7-4306-AA10-33687687B5D0"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Secondary_Artifacts.Effector_Secondary_stub</name> +<source/> +<node/> +<location>Effector_Secondary_CoWorkEr_stub</location> +</artifact> + +<artifact id="__2F43BA6B-2749-4744-B9C4-18F4AEAC16C9"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Secondary_Artifacts.Effector_Secondary_exec</name> +<source/> +<node/> +<location>Effector_Secondary_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Effector_Secondary_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_840618C0-5513-4389-97A4-C53EB87B29A0"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Main_Artifacts.Effector_Main_svnt</name> +<source/> +<node/> +<location>Effector_Main_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Effector_Main_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_E1AF706E-0B37-480B-8B26-E844FE2E9C3E"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Main_Artifacts.Effector_Main_exec</name> +<source/> +<node/> +<location>Effector_Main_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Effector_Main_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_D40E03AB-CE43-49D6-A7FF-C1231FE98898"> +<name>RT1H_Combined.ImplementationArtifacts.Effector_Main_Artifacts.Effector_Main_stub</name> +<source/> +<node/> +<location>Effector_Main_CoWorkEr_stub</location> +</artifact> + +<artifact id="_556249CC-E874-4BC6-9411-1B33EB2B895B"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_Three_Artifacts.Planner_Three_svnt</name> +<source/> +<node/> +<location>Planner_Three_CoWorkEr_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Planner_Three_Factory_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_458C6E27-87CA-4F77-8036-C9F612511B6F"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_Three_Artifacts.Planner_Three_exec</name> +<source/> +<node/> +<location>Planner_Three_CoWorkEr_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_TSCE_Planner_Three_Factory_CoWorkEr_Factory_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_2748D2D1-AAE5-4934-A43F-1639241C4351"> +<name>RT1H_Combined.ImplementationArtifacts.Planner_Three_Artifacts.Planner_Three_stub</name> +<source/> +<node/> +<location>Planner_Three_CoWorkEr_stub</location> +</artifact> + +<artifact id="__55C2DCD4-30B1-46A3-86B2-229896D74D0D"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Artifacts.BDC_stub</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_stub</location> +</artifact> + +<artifact id="__BF5CDECF-AF12-4876-9B6C-211B7BF0B22F"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Artifacts.BDC_svnt</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CUTS_Benchmark_Data_Collector_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_0E615519-6CC8-4EA5-B67A-65FF73586F04"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Artifacts.BDC_exec</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CUTS_Benchmark_Data_Collector_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_0B8A6C29-8962-4DA6-99F4-25FEECD77E97"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Ex_Artifacts.BDC_Ex_exec</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_Ex_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CUTS_Benchmark_Data_Collector_Ex_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="_5CE1793F-38DD-427D-A21E-E6D870E769E4"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Ex_Artifacts.BDC_Ex_stub</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_Ex_stub</location> +</artifact> + +<artifact id="_2DBFA82B-1D1F-48C6-9BDC-014E789E6A77"> +<name>RT1H_Combined.CUTS_ImplementationArtifacts.BDC_Ex_Artifacts.BDC_Ex_svnt</name> +<source/> +<node/> +<location>Benchmark_Data_Collector_Ex_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CUTS_Benchmark_Data_Collector_Ex_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__032AE7B6-3ABD-478A-B0D7-56BC4AAEF0B7"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.ControllerArtifacts.Controller_stub</name> +<source/> +<node/> +<location>Controller_stub</location> +</artifact> + +<artifact id="__00B105AB-50F5-49B7-A822-9B267F2D8896"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.ControllerArtifacts.Controller_svnt</name> +<source/> +<node/> +<location>Controller_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Controller_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__BF4AE6A2-BE32-4B8E-9919-C812EC18BF00"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.ControllerArtifacts.Controller_exec</name> +<source/> +<node/> +<location>Controller_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Controller_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__C22D0B06-6CDA-4652-B1CE-586E0C23251F"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.TargetManagerImplArtifacts.TargetManager_stub</name> +<source/> +<node/> +<location>TargetManager_stub</location> +</artifact> + +<artifact id="__9CB3A43B-397F-4FA9-97AA-EBFC3A22BFEC"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.TargetManagerImplArtifacts.TargetManager_svnt</name> +<source/> +<node/> +<location>TargetManager_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_TargetManagerHome_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__0F176DA2-9953-482A-9268-7DA5E69A88FE"> +<name>RT1H_Combined.RACE_ImplementationArtifacts.TargetManagerImplArtifacts.TargetManager_exec</name> +<source/> +<node/> +<location>TargetManager_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_TargetManagerHome_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__315FC65C-0582-4E0E-BB8B-C23A1238C67F"> +<name>RT1H_Combined.RA_ImplementationArtifacts.AnalyzerArtifacts.Analyzer_stub</name> +<source/> +<node/> +<location>Analyzer_stub</location> +</artifact> + +<artifact id="__7AD332BC-90DC-4E7D-B026-8D5053F2552E"> +<name>RT1H_Combined.RA_ImplementationArtifacts.AnalyzerArtifacts.Analyzer_svnt</name> +<source/> +<node/> +<location>Analyzer_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Analyzer_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__84974D39-AE18-4C0A-B81A-B1EC349E93BB"> +<name>RT1H_Combined.RA_ImplementationArtifacts.AnalyzerArtifacts.Analyzer_exec</name> +<source/> +<node/> +<location>Analyzer_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Analyzer_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__6BDE830C-FFA8-4F2D-9733-34F02F35020F"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleAllocationAnalyzerArtifacts.SimpleAllocationAnalyzer_stub</name> +<source/> +<node/> +<location>SimpleAllocationAnalyzer_stub</location> +</artifact> + +<artifact id="__138A0FE1-D8AA-4C1E-BB5E-4EC9714F4CA8"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleAllocationAnalyzerArtifacts.SimpleAllocationAnalyzer_svnt</name> +<source/> +<node/> +<location>SimpleAllocationAnalyzer_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_SimpleAllocationAnalyzer_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__621F3412-C507-4945-836B-CF9B81BDCC99"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleAllocationAnalyzerArtifacts.SimpleAllocationAnalyzer_exec</name> +<source/> +<node/> +<location>SimpleAllocationAnalyzer_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_SimpleAllocationAnalyzer_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__DC22BCBB-DB20-4072-AA64-161AFD7A9C10"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Input_AdapterArtifacts.Input_Adapter_stub</name> +<source/> +<node/> +<location>Input_Adapter_stub</location> +</artifact> + +<artifact id="__3E362049-0CF5-4F01-905F-67CAD769FFD5"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Input_AdapterArtifacts.Input_Adapter_svnt</name> +<source/> +<node/> +<location>Input_Adapter_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Input_Adapter_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__3B466B60-F8C2-4E48-A6E4-3D3D7EED9F03"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Input_AdapterArtifacts.Input_Adapter_exec</name> +<source/> +<node/> +<location>Input_Adapter_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Input_Adapter_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__AD4B52E0-103C-49E2-BE47-29CAE978676F"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Interactive_Input_AdapterArtifacts.Interactive_Input_Adapter_stub</name> +<source/> +<node/> +<location>Interactive_Input_Adapter_stub</location> +</artifact> + +<artifact id="__E4AF24BF-5A39-46B1-8217-6343D7D53298"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Interactive_Input_AdapterArtifacts.Interactive_Input_Adapter_svnt</name> +<source/> +<node/> +<location>Interactive_Input_Adapter_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Interactive_Input_Adapter_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__76A0CEFE-E2F7-4BF7-BB91-F309FB5AD33C"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Interactive_Input_AdapterArtifacts.Interactive_Input_Adapter_exec</name> +<source/> +<node/> +<location>Interactive_Input_Adapter_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Interactive_Input_Adapter_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__864DB99C-C60B-4FDD-A47D-AFD5C1599892"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_AdapterArtifacts.Output_Adapter_stub</name> +<source/> +<node/> +<location>Output_Adapter_stub</location> +</artifact> + +<artifact id="__D6EB8E01-F794-4C43-AB14-A3AFB9767D01"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_AdapterArtifacts.Output_Adapter_svnt</name> +<source/> +<node/> +<location>Output_Adapter_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Output_Adapter_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__4C78C4F9-FEF4-45AA-84A4-FFB10255A1EC"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_AdapterArtifacts.Output_Adapter_exec</name> +<source/> +<node/> +<location>Output_Adapter_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Output_Adapter_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__AB498B7F-A0E8-4F59-BF24-BBB9D125EED3"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_ManagerArtifacts.Output_Manager_stub</name> +<source/> +<node/> +<location>Output_Manager_stub</location> +</artifact> + +<artifact id="__1BB4CD4A-38A8-4BBA-9303-4A10F5B8BC57"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_ManagerArtifacts.Output_Manager_svnt</name> +<source/> +<node/> +<location>Output_Manager_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Output_Manager_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__280E6118-F4C7-4DE4-A0A4-A50637282EAE"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Output_ManagerArtifacts.Output_Manager_exec</name> +<source/> +<node/> +<location>Output_Manager_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Output_Manager_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__A47095F9-2E08-485E-96B4-CC0829051DF3"> +<name>RT1H_Combined.RA_ImplementationArtifacts.DAnCE_Output_AdapterArtifacts.DAnCE_Output_Adapter_stub</name> +<source/> +<node/> +<location>DAnCE_Output_Adapter_stub</location> +</artifact> + +<artifact id="__E54AE941-14CA-48FC-BAAA-1B93269EF79B"> +<name>RT1H_Combined.RA_ImplementationArtifacts.DAnCE_Output_AdapterArtifacts.DAnCE_Output_Adapter_svnt</name> +<source/> +<node/> +<location>DAnCE_Output_Adapter_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_DAnCE_Output_Adapter_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__ACA6BD67-D92A-4DBF-827A-7C0B15EA3F6D"> +<name>RT1H_Combined.RA_ImplementationArtifacts.DAnCE_Output_AdapterArtifacts.DAnCE_Output_Adapter_exec</name> +<source/> +<node/> +<location>DAnCE_Output_Adapter_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_DAnCE_Output_Adapter_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__CF7C6C9B-C6E3-4356-B9F1-598FA0B4A5B7"> +<name>RT1H_Combined.RA_ImplementationArtifacts.XML_Output_AdapterArtifacts.XML_Output_Adapter_stub</name> +<source/> +<node/> +<location>XML_Output_Adapter_stub</location> +</artifact> + +<artifact id="__437B6234-9DD3-40E4-9AE0-0923EBAF4548"> +<name>RT1H_Combined.RA_ImplementationArtifacts.XML_Output_AdapterArtifacts.XML_Output_Adapter_svnt</name> +<source/> +<node/> +<location>XML_Output_Adapter_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_XML_Output_Adapter_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__E2F1EA75-127C-4579-B692-ADD1026C6F23"> +<name>RT1H_Combined.RA_ImplementationArtifacts.XML_Output_AdapterArtifacts.XML_Output_Adapter_exec</name> +<source/> +<node/> +<location>XML_Output_Adapter_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_XML_Output_Adapter_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__B28C1F32-0231-4F7F-8FE2-164321942B87"> +<name>RT1H_Combined.RA_ImplementationArtifacts.PlannerArtifacts.Planner_stub</name> +<source/> +<node/> +<location>Planner_stub</location> +</artifact> + +<artifact id="__2021EE2F-3480-4BF9-9A3A-D146A99D251D"> +<name>RT1H_Combined.RA_ImplementationArtifacts.PlannerArtifacts.Planner_svnt</name> +<source/> +<node/> +<location>Planner_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Planner_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__D952F988-841F-43BA-9650-86846B08DF5F"> +<name>RT1H_Combined.RA_ImplementationArtifacts.PlannerArtifacts.Planner_exec</name> +<source/> +<node/> +<location>Planner_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Planner_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__2B5FE9E6-AF4C-4BC1-92A2-58101B2ECCA8"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleBinPackerArtifacts.SimpleBinPacker_stub</name> +<source/> +<node/> +<location>SimpleBinPacker_stub</location> +</artifact> + +<artifact id="__4D375D8F-5470-4236-8614-EF07D08020E3"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleBinPackerArtifacts.SimpleBinPacker_svnt</name> +<source/> +<node/> +<location>SimpleBinPacker_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_SimpleBinPacker_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__D6176B6C-58E4-43D4-BFC9-3DCF98249044"> +<name>RT1H_Combined.RA_ImplementationArtifacts.SimpleBinPackerArtifacts.SimpleBinPacker_exec</name> +<source/> +<node/> +<location>SimpleBinPacker_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_SimpleBinPacker_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__5B614077-C99E-428C-B8BE-252ADD7905B7"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Planner_ManagerArtifacts.Planner_Manager_stub</name> +<source/> +<node/> +<location>Planner_Manager_stub</location> +</artifact> + +<artifact id="__0BEB188E-3967-4D91-A6A1-CDF08EF81718"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Planner_ManagerArtifacts.Planner_Manager_svnt</name> +<source/> +<node/> +<location>Planner_Manager_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Planner_Manager_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__A65A1FA0-8F4D-4807-9AE9-90D344154D2C"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Planner_ManagerArtifacts.Planner_Manager_exec</name> +<source/> +<node/> +<location>Planner_Manager_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Planner_Manager_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__1CC443DF-7EE3-4130-8ACE-EE4181AC96CD"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Plan_AnalyzerArtifacts.Plan_Analyzer_stub</name> +<source/> +<node/> +<location>Plan_Analyzer_stub</location> +</artifact> + +<artifact id="__57123764-8624-4D79-9C5B-7ADF929536E6"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Plan_AnalyzerArtifacts.Plan_Analyzer_svnt</name> +<source/> +<node/> +<location>Plan_Analyzer_svnt</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Plan_Analyzer_Home_Servant</string> +</value> +</value> +</execParameter> +</artifact> + +<artifact id="__CDC7061A-483C-447B-8151-E68250566E86"> +<name>RT1H_Combined.RA_ImplementationArtifacts.Plan_AnalyzerArtifacts.Plan_Analyzer_exec</name> +<source/> +<node/> +<location>Plan_Analyzer_exec</location> +<execParameter> +<name>entryPoint</name> +<value> +<type> +<kind>tk_string</kind> +</type> +<value> +<string>create_CIAO_RACE_Plan_Analyzer_Home_Impl</string> +</value> +</value> +</execParameter> +</artifact> + +</Deployment:deploymentPlan> diff --git a/modules/CIAO/tools/Config_Handlers/test.cpp b/modules/CIAO/tools/Config_Handlers/test.cpp new file mode 100644 index 00000000000..fd50374aa7e --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/test.cpp @@ -0,0 +1,119 @@ +// $Id$ + +#include <iostream> + +#include "Deployment.hpp" +#include "DP_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ace/Get_Opt.h" +#include "Utils/XML_Typedefs.h" +#include "tao/ORB.h" +static const char *input_file = "BasicSP.cdp"; + + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "i:"); + + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'i': + input_file = get_opts.opt_arg (); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-i <input file> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command-line + return 0; +} + +// Check to see if SRD was imported. +void check_srd (const Deployment::DeploymentPlan &); + +using namespace CIAO::Config_Handlers; + + +int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) +{ + + if (parse_args (argc, argv) != 0) + return 1; + + // Initialize an ORB so Any will work + CORBA::ORB_ptr orb = CORBA::ORB_init (argc, argv); + ACE_UNUSED_ARG (orb); + + //Create an XML_Helper for all the file work + + if (xercesc::DOMDocument *doc = + XML_Helper::XML_HELPER.create_dom (input_file)) + { + //Read in the XSC type structure from the DOMDocument + DeploymentPlan dp = deploymentPlan (doc); + + //Convert the XSC to an IDL datatype + + DP_Handler dp_handler (dp); + + std::cout << "Instance document import succeeded. Dumping contents to file\n"; + + //Retrieve the newly created IDL structure + Deployment::DeploymentPlan *idl = dp_handler.plan(); + + // Check for server resources, if present.... + check_srd (*idl); + + //Convert it back to an XSC structure with a new DP_Handler + DP_Handler reverse_handler(*idl); + + //Create a new DOMDocument for writing the XSC into XML + xercesc::DOMDocument* the_xsc + (XML_Helper::XML_HELPER.create_dom(0)); + + //Serialize the XSC into a DOMDocument + deploymentPlan(*reverse_handler.xsc(), the_xsc); + + + //Write it to test.xml + XML_Helper::XML_HELPER.write_DOM(the_xsc, "test.xml"); + + //Cleanliness is next to Godliness + delete doc; + } + + std::cout << "Test completed!\n"; + + return 0; +} + + +void check_srd (const Deployment::DeploymentPlan &dp) +{ + for (CORBA::ULong i = 0; + i < dp.infoProperty.length (); + ++i) + { + if (ACE_OS::strcmp (dp.infoProperty[i].name.in (), + "CIAOServerResources") == 0) + { + CIAO::DAnCE::ServerResource *test; + + if (dp.infoProperty[i].value >>= test) + std::cerr << "ServerResources found and successfully extracted." << std::endl; + else + std::cerr << "ERROR: ServerResource extraction failed!" << std::endl; + } + } + +} + diff --git a/modules/CIAO/tools/Config_Handlers/toplevel.cpp b/modules/CIAO/tools/Config_Handlers/toplevel.cpp new file mode 100644 index 00000000000..a59893146bb --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/toplevel.cpp @@ -0,0 +1,348 @@ +/* $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 "toplevel.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // TopLevelPackageDescription + // + + TopLevelPackageDescription:: + TopLevelPackageDescription () + : + ::XSCRT::Type (), + regulator__ () + { + } + + TopLevelPackageDescription:: + TopLevelPackageDescription (TopLevelPackageDescription const& s) + : + ::XSCRT::Type (), + package_ (s.package_), + regulator__ () + { + } + + TopLevelPackageDescription& TopLevelPackageDescription:: + operator= (TopLevelPackageDescription const& s) + { + package_ = s.package_; + + return *this; + } + + + // TopLevelPackageDescription + // + TopLevelPackageDescription::package_iterator TopLevelPackageDescription:: + begin_package () + { + return package_.begin (); + } + + TopLevelPackageDescription::package_iterator TopLevelPackageDescription:: + end_package () + { + return package_.end (); + } + + TopLevelPackageDescription::package_const_iterator TopLevelPackageDescription:: + begin_package () const + { + return package_.begin (); + } + + TopLevelPackageDescription::package_const_iterator TopLevelPackageDescription:: + end_package () const + { + return package_.end (); + } + + void TopLevelPackageDescription:: + add_package (ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > const& e) + { + package_.push_back (e); + } + + size_t TopLevelPackageDescription:: + count_package(void) const + { + return package_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // TopLevelPackageDescription + // + + TopLevelPackageDescription:: + TopLevelPackageDescription (::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 == ACE_TEXT("package")) + { + ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > t (new ::CIAO::Config_Handlers::PackageConfiguration (e)); + add_package (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 TopLevelPackageDescriptionTypeInfoInitializer + { + TopLevelPackageDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (::CIAO::Config_Handlers::TopLevelPackageDescription)); + ::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)); + } + }; + + TopLevelPackageDescriptionTypeInfoInitializer TopLevelPackageDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // TopLevelPackageDescription + // + // + + void TopLevelPackageDescription:: + traverse (Type& o) + { + pre (o); + package (o); + post (o); + } + + void TopLevelPackageDescription:: + traverse (Type const& o) + { + pre (o); + package (o); + post (o); + } + + void TopLevelPackageDescription:: + pre (Type&) + { + } + + void TopLevelPackageDescription:: + pre (Type const&) + { + } + + void TopLevelPackageDescription:: + package (Type& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::TopLevelPackageDescription::package_iterator b (o.begin_package()), e (o.end_package()); + + if (b != e) + { + package_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) package_next (o); + } + + package_post (o); + } + + else package_none (o); + } + + void TopLevelPackageDescription:: + package (Type const& o) + { + // VC6 anathema strikes again + // + ::CIAO::Config_Handlers::TopLevelPackageDescription::package_const_iterator b (o.begin_package()), e (o.end_package()); + + if (b != e) + { + package_pre (o); + for (; b != e;) + { + dispatch (*(*b)); + if (++b != e) package_next (o); + } + + package_post (o); + } + + else package_none (o); + } + + void TopLevelPackageDescription:: + package_pre (Type&) + { + } + + void TopLevelPackageDescription:: + package_pre (Type const&) + { + } + + void TopLevelPackageDescription:: + package_next (Type&) + { + } + + void TopLevelPackageDescription:: + package_next (Type const&) + { + } + + void TopLevelPackageDescription:: + package_post (Type&) + { + } + + void TopLevelPackageDescription:: + package_post (Type const&) + { + } + + void TopLevelPackageDescription:: + package_none (Type&) + { + } + + void TopLevelPackageDescription:: + package_none (Type const&) + { + } + + void TopLevelPackageDescription:: + post (Type&) + { + } + + void TopLevelPackageDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // TopLevelPackageDescription + // + // + + TopLevelPackageDescription:: + TopLevelPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + TopLevelPackageDescription:: + TopLevelPackageDescription () + { + } + + void TopLevelPackageDescription:: + traverse (Type const& o) + { + Traversal::TopLevelPackageDescription::traverse (o); + } + + void TopLevelPackageDescription:: + package_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > (ACE_TEXT ("package"), top_ ())); + } + + void TopLevelPackageDescription:: + package_next (Type const& o) + { + package_post (o); + package_pre (o); + } + + void TopLevelPackageDescription:: + package_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/modules/CIAO/tools/Config_Handlers/toplevel.hpp b/modules/CIAO/tools/Config_Handlers/toplevel.hpp new file mode 100644 index 00000000000..e88d2625e26 --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/toplevel.hpp @@ -0,0 +1,220 @@ +/* $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 + +#ifndef TOPLEVEL_HPP +#define TOPLEVEL_HPP + +#include "XSC_XML_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class TopLevelPackageDescription; + } +} + +#include <memory> +#include <string> +#include <list> +#include "XMLSchema/Types.hpp" +#include "XMLSchema/id_map.hpp" +#include "ace/Refcounted_Auto_Ptr.h" +#include "ace/Null_Mutex.h" +#include "ace/TSS_T.h" +#include "ace/ace_wchar.h" +#include "ace/Singleton.h" + +#include "pcd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export TopLevelPackageDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + public: + typedef ACE_Refcounted_Auto_Ptr < TopLevelPackageDescription, ACE_Null_Mutex > _ptr; + + // package + // + public: + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > >::iterator package_iterator; + typedef ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > >::const_iterator package_const_iterator; + package_iterator begin_package (); + package_iterator end_package (); + package_const_iterator begin_package () const; + package_const_iterator end_package () const; + void add_package ( ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > const& ); + XSCRT::Type* package_ptr ( std::basic_string<ACE_TCHAR> idref ); + size_t count_package (void) const; + + protected: + ::std::list< ACE_Refcounted_Auto_Ptr < ::CIAO::Config_Handlers::PackageConfiguration, ACE_Null_Mutex > > package_; + + public: + TopLevelPackageDescription (); + + TopLevelPackageDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + TopLevelPackageDescription (TopLevelPackageDescription const& s); + + TopLevelPackageDescription& + operator= (TopLevelPackageDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct XSC_XML_Handlers_Export TopLevelPackageDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::TopLevelPackageDescription > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + package (Type&); + + virtual void + package (Type const&); + + virtual void + package_pre (Type&); + + virtual void + package_pre (Type const&); + + virtual void + package_next (Type&); + + virtual void + package_next (Type const&); + + virtual void + package_post (Type&); + + virtual void + package_post (Type const&); + + virtual void + package_none (Type&); + + virtual void + package_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct TopLevelPackageDescription : Traversal::TopLevelPackageDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::TopLevelPackageDescription Type; + TopLevelPackageDescription (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + virtual void + package_pre (Type &o) + { + this->package_pre (const_cast <Type const &> (o)); + } + + virtual void + package_pre (Type const&); + + virtual void + package_next (Type &o) + { + this->package_next (const_cast <Type const &> (o)); + } + + virtual void + package_next (Type const&); + + virtual void + package_post (Type &o) + { + this->package_post (const_cast <Type const &> (o)); + } + + virtual void + package_post (Type const&); + + protected: + TopLevelPackageDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // TOPLEVEL_HPP diff --git a/modules/CIAO/tools/IDL3_to_IDL2/IDL3_to_IDL2.mpc b/modules/CIAO/tools/IDL3_to_IDL2/IDL3_to_IDL2.mpc new file mode 100644 index 00000000000..1b001b04943 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/IDL3_to_IDL2.mpc @@ -0,0 +1,66 @@ +// -*- MPC -*- +// $Id$ + +project(TAO_IDL3_TO_IDL2_BE) : acelib, install, ciao_output, crosscompile, tao_idl_fe { + sharedname = TAO_IDL3_TO_IDL2_BE + dynamicflags = TAO_IDL3_TO_IDL2_BE_BUILD_DLL + + // This is necessary for MPC to pull in rules.ciao.GNU + includes += $(CIAO_ROOT) + + Source_Files { + basic_visitor.cpp + be_global.cpp + be_helper.cpp + be_init.cpp + be_produce.cpp + be_sunsoft.cpp + checking_visitor.cpp + identifier_helper.cpp + idl3_to_idl2_visitor.cpp + } + + Header_Files { + basic_visitor.h + be_extern.h + be_global.h + be_helper.h + be_sunsoft.h + checking_visitor.h + identifier_helper.h + idl3_to_idl2_visitor.h + TAO_IDL3_TO_IDL2_BE_Export.h + } +} + +project(TAO_IDL3_TO_IDL2_EXE) : aceexe, install, ciao_output, crosscompile, tao_idl_mcpp, tao_idl_fe { + after += TAO_IDL3_TO_IDL2_BE + exename = tao_idl3_to_idl2 + libs += TAO_IDL3_TO_IDL2_BE + includes += $(TAO_ROOT) + exeout = $(CIAO_ROOT)/bin + + // Adding a strict ordering dependency with TAO_IDL_EXE. It appears on some systems, there + // can be a race between these two projects for tao_idl.cpp, causing some erroors. + after += TAO_IDL_EXE + + // This is necessary for MPC to pull in rules.ciao.GNU + includes += $(CIAO_ROOT) . + + verbatim(gnuace, local) { + ifeq ($(TAO_IDL_PREPROCESSOR),) + CPPFLAGS += -DTAO_IDL_PREPROCESSOR=\\\"$(strip $(CXX))\\\" + else + CPPFLAGS += -DTAO_IDL_PREPROCESSOR=\\\"$(subst \\,\\,$(TAO_IDL_PREPROCESSOR))\\\" + endif + } + + Source_Files { + $(TAO_ROOT)/TAO_IDL/driver/drv_args.cpp + $(TAO_ROOT)/TAO_IDL/tao_idl.cpp + } + + Header_Files { + $(TAO_ROOT)/TAO_IDL/include/drv_extern.h + } +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/README b/modules/CIAO/tools/IDL3_to_IDL2/README new file mode 100644 index 00000000000..b0732e2c304 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/README @@ -0,0 +1,140 @@ + + IDL3 To IDL2 Converter + +A pluggable back end used with the IDL compiler parser +and command line processor, this tool converts CCM-related +IDL constructs into their corresponding IDL2 equivalents, +in a new IDL file. For more information about CIAO, please see + +$CIAO_ROOT/docs/releasenotes/index.html + +COMPILING: + +Use the provided .mpc file to generate a project or makefile to +compile the pluggable back end library and the executable. +Make sure the TAO IDL compiler front end is already built. + +EXECUTABLE NAME: + +tao_idl3_to_idl2 + +COMMAND LINE OPTIONS: + +All the usual front-end command line options that apply to the IDL compiler +(such as path includes) work with this tool as well, since the IDL compiler +front end is simply reused. The options -? or -h will display a usage +message, including both front end and back end options. For a complete +list of IDL compiler command line options and a description of each, see +TAO/docs/compiler.html. + +BACKEND OPTIONS: + +-o <path> Also works the same as with the IDL compiler, setting the +output directory, overriding the default, which is the directory of +execution. + +-e Generates a file foo_IDL2.idl from foo.idl that simply includes +foo.idl instead of generating its IDL declarations. Note that this +option takes effect only if foo.idl contains no 'IDL3' declarations, +otherwise it's a no-op. + +Note that the original -x <filename> option (which manually excludes +an included IDL file from being transformed to an include of the +'_IDL2' decorated corresponding file) has been eliminated. This +option was intended for included IDL files that contained no IDL3 +constructs, and therefore didn't need processing by this tool. +Detection of such included files is now automatic, and the processed +include filename will appear accordingly. + +CAVEAT: + +When using the TAO IDL compiler on files that are generated by this tool, +use the command line option -Sm on the IDL compiler, which will disable +the internal generation of equivalent IDL nodes in the AST. You'll notice +from the example below that the only ones that remain are eventtypes. +The -Sm option will prevent the IDL compiler from trying to create the +corresponding xxxConsumer interface, which now already exists explicitly +in IDL. + +EXAMPLE CONVERSION: + + +// test.idl + +#include <Components.idl> + +interface Foo {}; + +eventtype Ev {}; + +component Bar +{ + uses multiple Foo needs_foo; + publishes Ev ev_pub; +}; + +home BarHome manages Bar +{ +}; + + +Typing + +tao_idl3_to_idl2 -I<CIAO_ROOT>/ciao -I<TAO_ROOT> test.idl + +will generate + + + +// test_IDL2.idl + +#include "Components.idl" + +interface Foo {}; + +eventtype Ev {}; + +interface EvConsumer : Components::EventConsumerBase +{ + void push_Ev (in Ev the_Ev); +}; + +interface Bar : Components::CCMObject +{ + struct needs_fooConnection + { + Foo objref; + Components::Cookie ck; + }; + + typedef sequence<needs_fooConnection> needs_fooConnections; + + Components::Cookie connect_needs_foo (in Foo connection) + raises (Components::ExceededConnectionLimit, Components::InvalidConnection); + + Foo disconnect_needs_foo (in Components::Cookie ck) + raises (Components::InvalidConnection); + + needs_fooConnections get_connections_needs_foo (); + + Components::Cookie subscribe_ev_pub (in EvConsumer consumer) + raises (Components::ExceededConnectionLimit); + + EvConsumer unsubscribe_ev_pub (in Components::Cookie ck) + raises (Components::InvalidConnection); +}; + +interface BarHomeExplicit : Components::CCMHome +{ +}; + +interface BarHomeImplicit : Components::KeylessCCMHome +{ + Bar create () + raises (Components::CreateFailure); +}; + +interface BarHome : BarHomeExplicit, BarHomeImplicit +{ +}; + diff --git a/modules/CIAO/tools/IDL3_to_IDL2/TAO_IDL3_TO_IDL2_BE_Export.h b/modules/CIAO/tools/IDL3_to_IDL2/TAO_IDL3_TO_IDL2_BE_Export.h new file mode 100644 index 00000000000..7b54e254326 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/TAO_IDL3_TO_IDL2_BE_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl TAO_IDL3_TO_IDL2_BE +// ------------------------------ +#ifndef TAO_IDL3_TO_IDL2_BE_EXPORT_H +#define TAO_IDL3_TO_IDL2_BE_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (TAO_IDL3_TO_IDL2_BE_HAS_DLL) +# define TAO_IDL3_TO_IDL2_BE_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && TAO_IDL3_TO_IDL2_BE_HAS_DLL */ + +#if !defined (TAO_IDL3_TO_IDL2_BE_HAS_DLL) +# define TAO_IDL3_TO_IDL2_BE_HAS_DLL 1 +#endif /* ! TAO_IDL3_TO_IDL2_BE_HAS_DLL */ + +#if defined (TAO_IDL3_TO_IDL2_BE_HAS_DLL) && (TAO_IDL3_TO_IDL2_BE_HAS_DLL == 1) +# if defined (TAO_IDL3_TO_IDL2_BE_BUILD_DLL) +# define TAO_IDL3_TO_IDL2_BE_Export ACE_Proper_Export_Flag +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* TAO_IDL3_TO_IDL2_BE_BUILD_DLL */ +# define TAO_IDL3_TO_IDL2_BE_Export ACE_Proper_Import_Flag +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* TAO_IDL3_TO_IDL2_BE_BUILD_DLL */ +#else /* TAO_IDL3_TO_IDL2_BE_HAS_DLL == 1 */ +# define TAO_IDL3_TO_IDL2_BE_Export +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARATION(T) +# define TAO_IDL3_TO_IDL2_BE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* TAO_IDL3_TO_IDL2_BE_HAS_DLL == 1 */ + +// Set TAO_IDL3_TO_IDL2_BE_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (TAO_IDL3_TO_IDL2_BE_NTRACE) +# if (ACE_NTRACE == 1) +# define TAO_IDL3_TO_IDL2_BE_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define TAO_IDL3_TO_IDL2_BE_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !TAO_IDL3_TO_IDL2_BE_NTRACE */ + +#if (TAO_IDL3_TO_IDL2_BE_NTRACE == 1) +# define TAO_IDL3_TO_IDL2_BE_TRACE(X) +#else /* (TAO_IDL3_TO_IDL2_BE_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define TAO_IDL3_TO_IDL2_BE_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (TAO_IDL3_TO_IDL2_BE_NTRACE == 1) */ + +#endif /* TAO_IDL3_TO_IDL2_BE_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.cpp b/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.cpp new file mode 100644 index 00000000000..3dcbce5c4c1 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.cpp @@ -0,0 +1,1211 @@ +/* -*- c++ -*- */ +// $Id$ + +#include "basic_visitor.h" +#include "identifier_helper.h" +#include "be_sunsoft.h" +#include "be_extern.h" + +#include "ast_argument.h" +#include "ast_array.h" +#include "ast_attribute.h" +#include "ast_enum.h" +#include "ast_enum_val.h" +#include "ast_exception.h" +#include "ast_factory.h" +#include "ast_field.h" +#include "ast_operation.h" +#include "ast_root.h" +#include "ast_sequence.h" +#include "ast_string.h" +#include "ast_structure_fwd.h" +#include "ast_union.h" +#include "ast_union_branch.h" +#include "ast_union_fwd.h" +#include "ast_union_label.h" +#include "ast_valuebox.h" +#include "ast_valuetype.h" +#include "ast_valuetype_fwd.h" +#include "ast_native.h" +#include "utl_exceptlist.h" +#include "utl_idlist.h" +#include "utl_identifier.h" +#include "nr_extern.h" + +basic_visitor::basic_visitor (void) + : os (0), + disc_type_ (0) +{ +} + +basic_visitor::~basic_visitor (void) +{ + delete this->os; + this->os = 0; +} + +int +basic_visitor::visit_decl (AST_Decl *) +{ + return 0; +} + +int +basic_visitor::visit_scope (UTL_Scope *node) +{ + for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); + !si.is_done (); + si.next ()) + { + AST_Decl *d = si.item (); + + if (this->scope_skip_type (d)) + { + continue; + } + + AST_Decl::NodeType nt = d->node_type (); + + // Want to skip the uses_xxxConnection structs added by uses + // multiple ports. + // @@@ (JP) This will go away when the visitor is finished, since + // those uses_xxxConnection structs will not be added to the AST. + if (ScopeAsDecl (node)->node_type () == AST_Decl::NT_component + && (nt == AST_Decl::NT_struct + || nt == AST_Decl::NT_sequence + || nt == AST_Decl::NT_typedef)) + { + continue; + } + + if (d->ast_accept (this) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_scope - " + "codegen for scope failed\n"), + -1); + } + } + + return 0; +} + +int +basic_visitor::visit_type (AST_Type *) +{ + return 0; +} + +int +basic_visitor::visit_predefined_type (AST_PredefinedType *) +{ + return 0; +} + +int +basic_visitor::visit_interface_fwd (AST_InterfaceFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + if (node->is_local ()) + { + *os << "local "; + } + + if (node->is_abstract ()) + { + *os << "abstract "; + } + + *os << "interface " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +int +basic_visitor::visit_template_interface (AST_Template_Interface *) +{ + return 0; +} + +int +basic_visitor::visit_valuebox (AST_ValueBox *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl + << "valuetype " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + AST_Type *bt = node->boxed_type (); + + // Keep output statements separate because of side effects. + + if (bt->node_type () == AST_Decl::NT_array) + { + this->gen_anonymous_array (bt, node); + } + else + { + *os << this->type_name (bt); + } + + *os << ";"; + + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_valuetype (AST_ValueType *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + if (node->is_abstract ()) + { + *os << "abstract "; + } + + if (node->custom ()) + { + *os << "custom "; + } + + *os << "valuetype " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + AST_Decl::NodeType nt = node->node_type (); + AST_Interface **parents = node->inherits (); + long ninherits = node->n_inherits (); + + long i = 0; + for (i = 0; i < ninherits; ++i) + { + if (i == 0) + { + *os << " : "; + } + else + { + *os << ", "; + } + + *os << IdentifierHelper::orig_sn (parents[i]->name ()).c_str (); + } + + if (nt == AST_Decl::NT_eventtype) + { + *os << (ninherits == 0 ? " : " : ", ") + << "Components::EventBase"; + } + + AST_Interface **supports = node->supports (); + + for (i = 0; i < node->n_supports (); ++i) + { + if (i == 0) + { + *os << " supports "; + } + else + { + *os << ", "; + } + + if (i == 0 && node->supports_concrete () != 0) + { + supports[i] = node->supports_concrete (); + } + + AST_Interface *supported = supports[i]; + + *os << IdentifierHelper::orig_sn (supported->name ()).c_str (); + } + + *os << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + this->check_prefix (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_valuetype - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +basic_visitor::visit_valuetype_fwd (AST_ValueTypeFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + if (node->is_abstract ()) + { + *os << "abstract "; + } + + (void) node->node_type (); + + *os << "valuetype " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +int +basic_visitor::visit_porttype (AST_PortType *) +{ + return 0; +} + +int +basic_visitor::visit_provides (AST_Provides *) +{ + return 0; +} + +int +basic_visitor::visit_uses (AST_Uses *) +{ + return 0; +} + +int +basic_visitor::visit_publishes (AST_Publishes *) +{ + return 0; +} + +int +basic_visitor::visit_emits (AST_Emits *) +{ + return 0; +} + +int +basic_visitor::visit_consumes (AST_Consumes *) +{ + return 0; +} + +int +basic_visitor::visit_factory (AST_Factory *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl; + + *os << "factory " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " ("; + + this->gen_params (node, node->argument_count ()); + + *os << ")"; + + this->gen_exception_list (node->exceptions ()); + + *os << ";"; + + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_structure (AST_Structure *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "struct " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_structure - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +basic_visitor::visit_structure_fwd (AST_StructureFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "struct " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +int +basic_visitor::visit_exception (AST_Exception *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "exception " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_exception - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +basic_visitor::visit_expression (AST_Expression *) +{ + return 0; +} + +int +basic_visitor::visit_enum (AST_Enum *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "enum " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << be_nl + << "{" << be_idt; + + for (UTL_ScopeActiveIterator i (node, UTL_Scope::IK_decls); + !i.is_done ();) + { + *os << be_nl; + + AST_EnumVal *ev = AST_EnumVal::narrow_from_decl (i.item ()); + + *os << IdentifierHelper::try_escape (ev->original_local_name ()).c_str (); + + // Advance here so the check below will work. + i.next (); + + if (!i.is_done ()) + { + *os << ","; + } + } + + *os << be_uidt_nl + << "};"; + + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_operation (AST_Operation *node) +{ + this->gen_operation (node); + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_field (AST_Field *node) +{ + AST_Field::Visibility v = node->visibility (); + + *os << be_nl + << (v == AST_Field::vis_PUBLIC + ? "public " + : (v == AST_Field::vis_PRIVATE ? "private " : "")); + + AST_Type *ft = node->field_type (); + + if (ft->node_type () == AST_Decl::NT_array) + { + this->gen_anonymous_array (ft, node); + } + else + { + // Keep these statements separate because of side effects. + *os << this->type_name (ft); + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + } + + *os << ";"; + + return 0; +} + +int +basic_visitor::visit_argument (AST_Argument *node) +{ + *os << be_nl; + + switch (node->direction ()) + { + case AST_Argument::dir_IN: + *os << "in "; + break; + case AST_Argument::dir_INOUT: + *os << "inout "; + break; + case AST_Argument::dir_OUT: + *os << "out "; + break; + default: + return -1; + } + + *os << this->type_name (node->field_type ()) + << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + return 0; +} + +int +basic_visitor::visit_attribute (AST_Attribute *node) +{ + this->gen_attribute (node); + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_union (AST_Union *node) +{ + if (node->imported ()) + { + return 0; + } + + this->disc_type_ = node->disc_type ()->unaliased_type (); + + *os << be_nl << be_nl + << "union " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " switch ("; + + *os << this->type_name (node->disc_type ()) + << ")" << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_union - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +basic_visitor::visit_union_fwd (AST_UnionFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl + << "union " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +int +basic_visitor::visit_union_branch (AST_UnionBranch *node) +{ + for (unsigned long i = 0; i < node->label_list_length (); ++i) + { + if (this->visit_union_label (node->label (i)) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_union_branch - " + "codegen for label failed\n"), + -1); + } + } + + AST_Type *ft = node->field_type (); + + if (ft->node_type () == AST_Decl::NT_array) + { + this->gen_anonymous_array (ft, node); + } + else + { + *os << this->type_name (ft); + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + } + + *os << ";"; + + return 0; +} + +int +basic_visitor::visit_union_label (AST_UnionLabel *node) +{ + *os << be_nl; + + if (node->label_kind () == AST_UnionLabel::UL_default) + { + *os << "default: "; + } + else + { + *os << "case "; + this->gen_label_value (node); + *os << ": "; + } + + return 0; +} + +int +basic_visitor::visit_constant (AST_Constant *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "const "; + + switch (node->et ()) + { + case AST_Expression::EV_short: + *os << "short"; + break; + case AST_Expression::EV_ushort: + *os << "unsigned short"; + break; + case AST_Expression::EV_long: + *os << "long"; + break; + case AST_Expression::EV_ulong: + *os << "unsigned long"; + break; + case AST_Expression::EV_longlong: + *os << "long long"; + break; + case AST_Expression::EV_ulonglong: + *os << "unsigned long long"; + break; + case AST_Expression::EV_char: + *os << "char"; + break; + case AST_Expression::EV_wchar: + *os << "wchar"; + break; + case AST_Expression::EV_bool: + *os << "boolean"; + break; + case AST_Expression::EV_octet: + *os << "octet"; + break; + case AST_Expression::EV_float: + *os << "float"; + break; + case AST_Expression::EV_double: + *os << "double"; + break; + case AST_Expression::EV_longdouble: + *os << "long double"; + break; + case AST_Expression::EV_string: + *os << "string"; + break; + case AST_Expression::EV_wstring: + *os << "wstring"; + break; + case AST_Expression::EV_enum: + *os << IdentifierHelper::orig_sn (node->enum_full_name ()).c_str (); + break; + default: + break; + } + + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " = " << node->constant_value () << ";"; + + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_enum_val (AST_EnumVal *) +{ + return 0; +} + +int +basic_visitor::visit_array (AST_Array *node) +{ + *os << IdentifierHelper::orig_sn (node->base_type ()->name ()).c_str (); + + for (unsigned long i = 0; i < node->n_dims (); ++i) + { + *os << "[" << node->dims ()[i] << "]"; + } + + return 0; +} + +int +basic_visitor::visit_sequence (AST_Sequence *node) +{ + // Keep output statements separate because of side effects. + *os << "sequence<"; + *os << this->type_name (node->base_type ()); + + if (!node->unbounded ()) + { + *os << ", " << node->max_size ()->ev ()->u.ulval; + } + + *os << "> "; + + return 0; +} + +int +basic_visitor::visit_string (AST_String *node) +{ + *os << (node->width () > 1 ? "w" : "") << "string"; + + unsigned long bound = node->max_size ()->ev ()->u.ulval; + + if (bound > 0) + { + *os << "<" << bound << ">"; + } + + return 0; +} + +int +basic_visitor::visit_typedef (AST_Typedef *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl + << "typedef "; + + AST_Type *bt = node->base_type (); + + // Keep output statements separate because of side effects. + + if (bt->node_type () == AST_Decl::NT_array) + { + this->gen_anonymous_array (bt, node); + } + else + { + *os << this->type_name (bt); + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + } + + *os << ";"; + + this->check_id_and_version (node); + + return 0; +} + +int +basic_visitor::visit_native (AST_Native *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + *os << "native " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +//======================================================== + +void +basic_visitor::check_prefix (AST_Decl *d) +{ + if (d->typeid_set ()) + { + return; + } + + const char *the_prefix = d->prefix (); + AST_Decl *p = ScopeAsDecl (d->defined_in ()); + + if (ACE_OS::strcmp (the_prefix, p->prefix ()) != 0) + { + *os << be_nl + << "typeprefix " + << IdentifierHelper::try_escape (d->original_local_name ()).c_str () + << " \"" << the_prefix << "\";"; + } +} + +void +basic_visitor::check_id_and_version (AST_Decl *d) +{ + if (d->typeid_set ()) + { + *os << be_nl + << "typeid " + << IdentifierHelper::try_escape (d->original_local_name ()).c_str () + << " \"" << d->repoID () << "\";"; + + return; + } + + const char *the_version = d->version (); + AST_Decl *p = ScopeAsDecl (d->defined_in ()); + + if (ACE_OS::strcmp (the_version, p->version ()) != 0) + { + *os << "\n" + << "#pragma version " + << IdentifierHelper::try_escape (d->original_local_name ()).c_str () + << " " << the_version; + } +} + +const char * +basic_visitor::type_name (AST_Type *t) +{ + AST_PredefinedType *pdt = 0; + + switch (t->node_type ()) + { + case AST_Decl::NT_wstring: + case AST_Decl::NT_string: + case AST_Decl::NT_sequence: + // This causes side effects so output statements + // sending us here should not be concatenated. + (void) t->ast_accept (this); + return ""; + case AST_Decl::NT_pre_defined: + pdt = AST_PredefinedType::narrow_from_decl (t); + + switch (pdt->pt ()) + { + case AST_PredefinedType::PT_pseudo: + return t->full_name (); + case AST_PredefinedType::PT_object: + return "Object"; + case AST_PredefinedType::PT_any: + return "any"; + case AST_PredefinedType::PT_long: + return "long"; + case AST_PredefinedType::PT_ulong: + return "unsigned long"; + case AST_PredefinedType::PT_longlong: + return "long long"; + case AST_PredefinedType::PT_ulonglong: + return "unsigned long long"; + case AST_PredefinedType::PT_short: + return "short"; + case AST_PredefinedType::PT_ushort: + return "unsigned short"; + case AST_PredefinedType::PT_float: + return "float"; + case AST_PredefinedType::PT_double: + return "double"; + case AST_PredefinedType::PT_longdouble: + return "long double"; + case AST_PredefinedType::PT_char: + return "char"; + case AST_PredefinedType::PT_wchar: + return "wchar"; + case AST_PredefinedType::PT_boolean: + return "boolean"; + case AST_PredefinedType::PT_octet: + return "octet"; + case AST_PredefinedType::PT_void: + return "void"; + default: + break; + } + default: + this->tmp_retval_ = IdentifierHelper::orig_sn (t->name ()).c_str (); + return this->tmp_retval_.c_str (); + } +} + +void +basic_visitor::gen_anonymous_array (AST_Type *a, + AST_Decl *wrapper) +{ + AST_Array *array = AST_Array::narrow_from_decl (a); + AST_Type *bt = array->base_type (); + + *os << this->type_name (bt); + *os << " " + << IdentifierHelper::try_escape (wrapper->original_local_name ()).c_str (); + + for (unsigned long i = 0; i < array->n_dims (); ++i) + { + *os << "[" << array->dims ()[i]->ev ()->u.ulval << "]"; + } +} + +void +basic_visitor::gen_params (UTL_Scope *s, int arg_count) +{ + if (arg_count > 0) + { + *os << be_idt << be_idt; + + for (UTL_ScopeActiveIterator si (s, UTL_Scope::IK_decls); + !si.is_done ();) + { + if (si.item ()->ast_accept (this) != 0) + { + ACE_ERROR ((LM_ERROR, + "idl3_to_idl2_visitor::gen_params - " + "codegen for parameters failed\n")); + } + + si.next (); + + if (!si.is_done ()) + { + *os << ","; + } + } + + *os << be_uidt_nl << be_uidt; + } +} + +void +basic_visitor::gen_exception_list (UTL_ExceptList *exceptions, + const char *prefix, + bool closed) +{ + if (exceptions != 0 && exceptions->length () > 0) + { + *os << be_idt_nl + << prefix << "raises ("; + + for (UTL_ExceptlistActiveIterator ei (exceptions); + !ei.is_done ();) + { + *os << IdentifierHelper::orig_sn (ei.item ()->name ()).c_str (); + + ei.next (); + + if (!ei.is_done () || !closed) + { + *os << ", "; + } + } + + if (closed) + { + *os << ")" << be_uidt; + } + } +} + +void +basic_visitor::gen_operation (AST_Operation *node) +{ + *os << be_nl << be_nl; + + if (node->flags () == AST_Operation::OP_oneway) + { + *os << "oneway "; + } + + *os << this->type_name (node->return_type ()); + + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " ("; + + this->gen_params (node, node->argument_count ()); + + *os << ")"; + + this->gen_exception_list (node->exceptions ()); + + *os << ";"; +} + +void +basic_visitor::gen_attribute (AST_Attribute *node) +{ + bool rd_only = node->readonly (); + + // Keep output statements separate because of side effects. + // No need to check for anonymous array - anonymous types not + // accepted by parser for attributes. + *os << be_nl << be_nl + << (rd_only ? "readonly " : "") << "attribute "; + *os << this->type_name (node->field_type ()); + *os << " " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + this->gen_exception_list (node->get_get_exceptions (), + rd_only ? "" : "get"); + + this->gen_exception_list (node->get_set_exceptions (), + "set"); + + *os << ";"; +} + +void +basic_visitor::gen_label_value (AST_UnionLabel *node) +{ + AST_Expression *val = node->label_val (); + AST_Expression::AST_ExprValue *ev = val->ev (); + + if (this->disc_type_->node_type () == AST_Decl::NT_enum) + { + UTL_Scope *s = this->disc_type_->defined_in (); + + if (s == 0) + { + *os << IdentifierHelper::orig_sn (val->n ()).c_str (); + } + else + { + *os << IdentifierHelper::orig_sn (ScopeAsDecl (s)->name ()).c_str () + << "::"; + + Identifier *id = + IdentifierHelper::original_local_name (val->n ()->last_component ()); + + *os << IdentifierHelper::try_escape (id).c_str (); + + id->destroy (); + delete id; + id = 0; + } + + return; + } + + switch (ev->et) + { + case AST_Expression::EV_short: + *os << ev->u.sval; + break; + case AST_Expression::EV_ushort: + *os << ev->u.usval; + break; + case AST_Expression::EV_long: + *os << ev->u.lval; + break; + case AST_Expression::EV_ulong: + *os << ev->u.ulval; + break; + case AST_Expression::EV_longlong: +#if ! defined (ACE_LACKS_LONGLONG_T) + this->os->print ("%lld", ev->u.llval); +#endif /* ! defined (ACE_LACKS_LONGLONG_T) */ + break; + case AST_Expression::EV_ulonglong: +#if ! defined (ACE_LACKS_LONGLONG_T) + *os << "ACE_UINT64_LITERAL ("; + this->os->print (ACE_UINT64_FORMAT_SPECIFIER_ASCII, ev->u.ullval); + *os << ")"; +#endif /* ! defined (ACE_LACKS_LONGLONG_T) */ + break; + case AST_Expression::EV_char: + *os << ev->u.cval; + break; + case AST_Expression::EV_wchar: + *os << ev->u.wcval; + break; + case AST_Expression::EV_bool: + *os << (ev->u.bval ? "TRUE" : "FALSE"); + break; + case AST_Expression::EV_enum: + *os << IdentifierHelper::orig_sn (val->n ()).c_str (); + break; + default: + break; + } +} + +bool +basic_visitor::scope_skip_type (AST_Decl *d) +{ + return (d->node_type () == AST_Decl::NT_pre_defined); +} + +bool +basic_visitor::can_skip_module (AST_Module *m) +{ + for (UTL_ScopeActiveIterator si (m, UTL_Scope::IK_decls); + !si.is_done (); + si.next ()) + { + AST_Decl *d = si.item (); + AST_Decl::NodeType nt = d->node_type (); + + switch (nt) + { + case AST_Decl::NT_interface: + case AST_Decl::NT_interface_fwd: + case AST_Decl::NT_component: + case AST_Decl::NT_component_fwd: + case AST_Decl::NT_eventtype: + case AST_Decl::NT_eventtype_fwd: + case AST_Decl::NT_home: + if (d->is_abstract () || d->is_local ()) + { + break; + } + + return false; + case AST_Decl::NT_module: + if (!this->can_skip_module (AST_Module::narrow_from_decl (d))) + { + return false; + } + + break; + default: + break; + } + } + + return true; +} + +bool +basic_visitor::match_excluded_file (const char *raw_filename) +{ + ACE_CString::size_type p = 0; + + // If this included IDL file matches one of the 'excluded' files, + // generate the include without tacking on the suffix. + while (p != ACE_CString::npos) + { + ACE_CString::size_type cursor = p; + p = be_global->excluded_filenames ().find (' ', cursor); + + ACE_CString one_filename = + be_global->excluded_filenames ().substr (cursor, p - cursor); + + if (one_filename == raw_filename) + { + return true; + } + + // Skip the whitespace. + if (p != ACE_CString::npos) + { + while (be_global->excluded_filenames ()[p] == ' ') + { + p++; + } + } + } + + return false; +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.h b/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.h new file mode 100644 index 00000000000..29e5b9d25f1 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/basic_visitor.h @@ -0,0 +1,129 @@ +// $Id$ + +/* -*- c++ -*- */ +// ============================================================================ +// +// = LIBRARY +// TAO_IDL3_TO_IDL2_BE_DLL +// +// = FILENAME +// basic_visitor.h +// +// = DESCRIPTION +// Base class for other visitors in this backend. +// +// ============================================================================ + +#ifndef TAO_BASIC_VISITOR_H +#define TAO_BASIC_VISITOR_H + +#include "ast_visitor.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" + +#include "ace/SString.h" + +class TAO_OutStream; +class UTL_ExceptList; + +class TAO_IDL3_TO_IDL2_BE_Export basic_visitor : public ast_visitor +{ + // + // = TITLE + // basic_visitor. + // + // = DESCRIPTION + // Base class for visitors in this backend and others. + // +public: + basic_visitor (void); + virtual ~basic_visitor (void); + + virtual int visit_decl (AST_Decl *d); + virtual int visit_scope (UTL_Scope *node); + virtual int visit_type (AST_Type *node); + virtual int visit_predefined_type (AST_PredefinedType *node); + virtual int visit_module (AST_Module *node) = 0; + virtual int visit_interface (AST_Interface *node) = 0; + virtual int visit_interface_fwd (AST_InterfaceFwd *node); + virtual int visit_template_interface (AST_Template_Interface *node); + virtual int visit_valuebox (AST_ValueBox *node); + virtual int visit_valuetype (AST_ValueType *node); + virtual int visit_valuetype_fwd (AST_ValueTypeFwd *node); + virtual int visit_component (AST_Component *node) = 0; + virtual int visit_component_fwd (AST_ComponentFwd *node) = 0; + virtual int visit_porttype (AST_PortType *node); + virtual int visit_provides (AST_Provides *node); + virtual int visit_uses (AST_Uses *node); + virtual int visit_publishes (AST_Publishes *node); + virtual int visit_emits (AST_Emits *node); + virtual int visit_consumes (AST_Consumes *node); + virtual int visit_extended_port (AST_Extended_Port *node) = 0; + virtual int visit_mirror_port (AST_Mirror_Port *node) = 0; + virtual int visit_connector (AST_Connector *node) = 0; + virtual int visit_instantiated_connector ( + AST_Instantiated_Connector *node) = 0; + virtual int visit_tmpl_port (AST_Tmpl_Port *node) = 0; + virtual int visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *node) = 0; + virtual int visit_eventtype (AST_EventType *node) = 0; + virtual int visit_eventtype_fwd (AST_EventTypeFwd *node) = 0; + virtual int visit_home (AST_Home *node) = 0; + virtual int visit_factory (AST_Factory *node); + virtual int visit_structure (AST_Structure *node); + virtual int visit_structure_fwd (AST_StructureFwd *node); + virtual int visit_exception (AST_Exception *node); + virtual int visit_expression (AST_Expression *node); + virtual int visit_enum (AST_Enum *node); + virtual int visit_operation (AST_Operation *node); + virtual int visit_field (AST_Field *node); + virtual int visit_argument (AST_Argument *node); + virtual int visit_attribute (AST_Attribute *node); + virtual int visit_union (AST_Union *node); + virtual int visit_union_fwd (AST_UnionFwd *node); + virtual int visit_union_branch (AST_UnionBranch *node); + virtual int visit_union_label (AST_UnionLabel *node); + virtual int visit_constant (AST_Constant *node); + virtual int visit_enum_val (AST_EnumVal *node); + virtual int visit_array (AST_Array *node); + virtual int visit_sequence (AST_Sequence *node); + virtual int visit_string (AST_String *node); + virtual int visit_typedef (AST_Typedef *node); + virtual int visit_root (AST_Root *node) = 0; + virtual int visit_native (AST_Native *node); + +protected: + void check_prefix (AST_Decl *d); + void check_id_and_version (AST_Decl *d); + const char *type_name (AST_Type *t); + void gen_anonymous_array (AST_Type *array, AST_Decl *wrapper); + void gen_params (UTL_Scope *s, int arg_count); + void gen_exception_list (UTL_ExceptList *exceptions, + const char *prefix = "", + bool closed = true); + void gen_operation (AST_Operation *node); + void gen_attribute (AST_Attribute *node); + void gen_label_value (AST_UnionLabel *node); + + // Overrides allow common code for visit_scope(). + virtual bool scope_skip_type (AST_Decl *d); + + // Used by derived visitors to avoid generating an empty IDL module. + bool can_skip_module (AST_Module *m); + + // Used by derived visitors to check for special include handling. + bool match_excluded_file (const char *raw_filename); + +protected: + TAO_OutStream *os; + AST_Type *disc_type_; + +private: + ACE_CString tmp_retval_; +}; + +#endif // TAO_BASIC_VISITOR_H diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_extern.h b/modules/CIAO/tools/IDL3_to_IDL2/be_extern.h new file mode 100644 index 00000000000..c7dc3daaf41 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_extern.h @@ -0,0 +1,86 @@ +// This may look like C, but it's really -*- C++ -*- +// $Id$ +/* + +COPYRIGHT + +Copyright 1992, 1993, 1994 Sun Microsystems, Inc. Printed in the United +States of America. All Rights Reserved. + +This product is protected by copyright and distributed under the following +license restricting its use. + +The Interface Definition Language Compiler Front End (CFE) is made +available for your use provided that you include this license and copyright +notice on all media and documentation and the software program in which +this product is incorporated in whole or part. You may copy and extend +functionality (but may not remove functionality) of the Interface +Definition Language CFE without charge, but you are not authorized to +license or distribute it to anyone else except as part of a product or +program developed by you or with the express written consent of Sun +Microsystems, Inc. ("Sun"). + +The names of Sun Microsystems, Inc. and any of its subsidiaries or +affiliates may not be used in advertising or publicity pertaining to +distribution of Interface Definition Language CFE as permitted herein. + +This license is effective until terminated by Sun for failure to comply +with this license. Upon termination, you shall destroy or return all code +and documentation for the Interface Definition Language CFE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF +ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS +FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF +DEALING, USAGE OR TRADE PRACTICE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT +ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES +TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT. + +SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH +RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY +INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF. + +IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR +ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL +DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +Use, duplication, or disclosure by the government is subject to +restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in +Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR +52.227-19. + +Sun, Sun Microsystems and the Sun logo are trademarks or registered +trademarks of Sun Microsystems, Inc. + +SunSoft, Inc. +2550 Garcia Avenue +Mountain View, California 94043 + +NOTE: + +SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are +trademarks or registered trademarks of Sun Microsystems, Inc. + +*/ + +#ifndef TAO_IFR_BE_EXTERN_H +#define TAO_IFR_BE_EXTERN_H + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" +#include "be_global.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +extern TAO_IDL3_TO_IDL2_BE_Export BE_GlobalData *be_global; + +extern TAO_IDL3_TO_IDL2_BE_Export int BE_init (int &, ACE_TCHAR*[]); +extern TAO_IDL3_TO_IDL2_BE_Export void BE_post_init (char *[], long); +extern TAO_IDL3_TO_IDL2_BE_Export void BE_version (void); +extern TAO_IDL3_TO_IDL2_BE_Export void BE_produce (void); +extern TAO_IDL3_TO_IDL2_BE_Export void BE_cleanup (void); +extern TAO_IDL3_TO_IDL2_BE_Export void BE_abort (void); + +#endif /* TAO_IFR_BE_EXTERN_H */ diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_global.cpp b/modules/CIAO/tools/IDL3_to_IDL2/be_global.cpp new file mode 100644 index 00000000000..eafef8eaa45 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_global.cpp @@ -0,0 +1,197 @@ +// $Id$ + +// ============================================================================ +// +// +// = LIBRARY +// TAO_IDL3_TO_IDL2L_BE_DLL +// +// = FILENAME +// be_global.cpp +// +// = DESCRIPTION +// Stores global data specific to the compiler back end. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#include "be_global.h" +#include "be_sunsoft.h" +#include "ast_generator.h" +#include "global_extern.h" +#include "idl_defines.h" +#include "utl_string.h" +#include "idl3_to_idl2_visitor.h" + +#include "ace/OS_NS_stdio.h" + +TAO_IDL3_TO_IDL2_BE_Export BE_GlobalData *be_global = 0; + +BE_GlobalData::BE_GlobalData (void) + : gen_copyright_ (true), + filename_ (0), + output_dir_ (0), + encapsulate_idl2_ (false) +{ +} + +BE_GlobalData::~BE_GlobalData (void) +{ +} + +const char* +BE_GlobalData::output_dir (void) const +{ + return this->output_dir_; +} + +void +BE_GlobalData::output_dir (const char* s) +{ + delete [] this->output_dir_; + this->output_dir_ = ACE::strnew (s); +} + +bool +BE_GlobalData::encapsulate_idl2 (void) const +{ + return this->encapsulate_idl2_; +} + +ACE_CString & +BE_GlobalData::excluded_filenames (void) +{ + return this->excluded_filenames_; +} + +void +BE_GlobalData::set_excluded_filenames (const char *filenames) +{ + this->excluded_filenames_ = filenames; +} + +bool +BE_GlobalData::gen_copyright (void) const +{ + return this->gen_copyright_; +} + +void +BE_GlobalData::parse_args (long &i, char **av) +{ + switch (av[i][1]) + { + // Directory where the generated file is to + // be kept. Default is the current directory from which + // <tao_idl3_to_idl2> is called. + case 'o': + if (av[i][2] == '\0') + { + this->output_dir (av [i + 1]); + i++; + } + else + { + this->output_dir (av[i] + 2); + } + break; + case 'e': + this->encapsulate_idl2_ = true; + break; + default: + ACE_ERROR (( + LM_ERROR, + ACE_TEXT ("IDL: I don't understand the '%s' option\n"), + av[i] + )); + + idl_global->set_compile_flags (idl_global->compile_flags () + | IDL_CF_ONLY_USAGE); + break; + } +} + +// Prepare an argument for a BE. +void +BE_GlobalData::prep_be_arg (char *) +{ +} + +void +BE_GlobalData::arg_post_proc (void) +{ +} + +void +BE_GlobalData::usage (void) const +{ + ACE_DEBUG (( + LM_DEBUG, + ACE_TEXT (" -o <dir>\t\tOutput directory for the generated file.") + ACE_TEXT (" Default is current directory\n") + )); + ACE_DEBUG (( + LM_DEBUG, + ACE_TEXT (" -e\t\t\tGenerate just an include of original IDL file") + ACE_TEXT (" if no IDL3 declarations are found\n") + )); +} + +AST_Generator * +BE_GlobalData::generator_init (void) +{ + AST_Generator *gen = 0; + ACE_NEW_RETURN (gen, + AST_Generator, + 0); + return gen; +} + +int +BE_GlobalData::outfile_init (TAO_OutStream *& os, + const char *file_prefix, + const char *file_suffix, + const char *guard_prefix, + const char *guard_suffix) +{ + ACE_NEW_RETURN (os, + TAO_SunSoft_OutStream, + -1); + + ACE_CString fn (idl_global->stripped_filename ()->get_string ()); + fn = fn.substr (0, fn.rfind ('.')); + fn += file_suffix; + + const char *path = be_global->output_dir (); + ACE_CString target_name; + + if (path != 0) + { + target_name = path; + target_name += "/"; + } + + target_name += file_prefix; + target_name += fn; + + if (os->open (target_name.c_str ()) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Failed to open file %s for writing.\n", + target_name.c_str ()), + -1); + } + + *os << be_nl; + + os->gen_ifndef_string (fn.c_str (), guard_prefix, guard_suffix); + + return 0; +} + +void +BE_GlobalData::destroy (void) +{ +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_global.h b/modules/CIAO/tools/IDL3_to_IDL2/be_global.h new file mode 100644 index 00000000000..1db2c35fd1f --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_global.h @@ -0,0 +1,116 @@ +/* -*- c++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO_IFR_BE_DLL +// +// = FILENAME +// be_global.h +// +// = DESCRIPTION +// Header file for class containing compiler back end global data. +// +// = AUTHOR +// Jeff Parsons <parsons@cs.wustl.edu> +// +// ============================================================================ + +#ifndef TAO_IFR_BE_GLOBAL_H +#define TAO_IFR_BE_GLOBAL_H + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" +#include "idl_defines.h" +#include "ace/SString.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class AST_Generator; +class TAO_OutStream; + +// Defines a class containing all back end global data. + +class TAO_IDL3_TO_IDL2_BE_Export BE_GlobalData +{ +public: + // = TITLE + // BE_GlobalData + // + // = DESCRIPTION + // Storage of global data specific to the compiler back end + // + BE_GlobalData (void); + // Constructor. + + virtual ~BE_GlobalData (void); + // Destructor. + + //======================================= + + // Data accessors. + const char* output_dir (void) const; + void output_dir (const char* s); + + bool encapsulate_idl2 (void) const; + + ACE_CString & excluded_filenames (void); + + void set_excluded_filenames (const char *filenames); + + bool gen_copyright (void) const; + + //========================================= + + virtual void parse_args (long &i, char **av); + // Parse args that affect this backend. + + void prep_be_arg (char *s); + // Special BE arg call factored out of DRV_args. + + void arg_post_proc (void); + // Checks made after parsing args. + + virtual void usage (void) const; + // Usage message for backend options. + + AST_Generator *generator_init (void); + // Create an AST node generator. + + int outfile_init (TAO_OutStream *&, + const char *file_prefix, + const char *file_suffix, + const char *guard_prefix, + const char *guard_suffix); + // Create the output file, the associated stream, and + // generate the initial #ifndef. + + void destroy (void); + // Cleanup. + +protected: + bool gen_copyright_; + // So it can be turned off in backends that inherit from this one. + +private: + char *filename_; + // Name of the IDL file we are processing. + + char *output_dir_; + // Directory where the generated file is to be + // kept. Default value is 0 for this string which means the current + // directory from which the <tao_picml> is called. + + bool encapsulate_idl2_; + // Have the generated file just include the original file if + // no IDL3 declarations are found by the checking visitor. + + ACE_CString excluded_filenames_; + // Whitespace-separated list of included IDL files + // to be passed to the output IDL file without + // adding the '_IDL2" suffix. +}; + +#endif /* TAO_IFR_BE_GLOBAL_H */ diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_helper.cpp b/modules/CIAO/tools/IDL3_to_IDL2/be_helper.cpp new file mode 100644 index 00000000000..db3968af3c5 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_helper.cpp @@ -0,0 +1,435 @@ +// $Id$ + +// ============================================================================ +// +// +// = LIBRARY +// TAO IDL +// +// = FILENAME +// be_helper.cpp +// +// = DESCRIPTION +// Provides helper classes to print generated code to the output +// +// = AUTHOR +// Aniruddha Gokhale +// +// Improvements by Carlos O'Ryan +// +// ============================================================================ + +#include "be_helper.h" +#include "be_extern.h" +#include "idl_defines.h" +#include "ace/OS_NS_stdio.h" +#include "ace/OS_NS_string.h" +#include "ace/OS_NS_ctype.h" + +ACE_RCSID (be, + be_helper, + "$Id$") + +static const char copyright[] = +"// -*- C++ -*-\n" +"//\n" +"// $I" "d$\n\n" +"// **** Code generated by the The Component Integrated ACE ORB (CIAO)" +" IDL3 to IDL2 Compiler ****\n" +"// CIAO and this tool have been developed by:\n" +"// Center for Distributed Object Computing\n" +"// Washington University\n" +"// St. Louis, MO\n" +"// USA\n" +"// http://www.cs.wustl.edu/~schmidt/doc-center.html\n" +"// and\n" +"// Distributed Object Computing Laboratory\n" +"// University of California at Irvine\n" +"// Irvine, CA\n" +"// USA\n" +"// http://doc.ece.uci.edu/\n" +"// and\n" +"// Institute for Software Integrated Systems\n" +"// Vanderbilt University\n" +"// Nashville, TN\n" +"// USA\n" +"// http://www.isis.vanderbilt.edu/\n" +"//\n" +"// Information about CIAO is available at:\n" +"// http://www.cs.wustl.edu/~schmidt/CIAO.html"; + +TAO_NL::TAO_NL (void) +{ +} + +TAO_INDENT::TAO_INDENT (int do_now) + : do_now_ (do_now) +{ +} + +TAO_UNINDENT::TAO_UNINDENT (int do_now) + : do_now_ (do_now) +{ +} + +const TAO_NL be_nl; +const TAO_INDENT be_idt; +const TAO_INDENT be_idt_nl (1); +const TAO_UNINDENT be_uidt; +const TAO_UNINDENT be_uidt_nl (1); + +// Methods of the TAO_OutStream class. + +TAO_OutStream::TAO_OutStream (void) + : fp_ (0), + indent_level_ (0) +{ +} + +TAO_OutStream::~TAO_OutStream (void) +{ + // Close the underlying I/O handle only if it exists. + if (this->fp_ != 0) + { + ACE_OS::fclose (this->fp_); + this->fp_ = 0; + } + + indent_level_ = 0; +} + +int +TAO_OutStream::open (const char *fname) +{ + if (fname != 0) + { + // File name exists, open an I/O file handle. + this->fp_ = ACE_OS::fopen (fname, "w"); + + if (this->fp_ != 0) + { + if (be_global->gen_copyright ()) + { + // Put the copyright notice. + ACE_OS::fprintf (this->fp_, + "%s\n", + copyright); + + ACE_OS::fflush (this->fp_); + } + + return 0; + } + else + { + return -1; + } + } + else + { + return -1; + } +} + +// Return the underlying lowlevel file pointer. +// indentation. +FILE * +TAO_OutStream::file (void) +{ + return this->fp_; +} + +int +TAO_OutStream::incr_indent (unsigned short flag) +{ + indent_level_++; + + if (flag != 0) + { + return this->indent (); + } + else + { + // Do not indent output. + return 0; + } +} + +// Indentation +int +TAO_OutStream::decr_indent (unsigned short flag) +{ + this->indent_level_--; + // Just in case somebody gets "unindent happy". + if (this->indent_level_ < 0) + { + // ACE_DEBUG ((LM_DEBUG, "negative indentation?\n")); + this->indent_level_ = 0; + } + if (flag != 0) + { + return this->indent (); + } + else + { + // Do not indent output. + return 0; + } +} + +int +TAO_OutStream::reset (void) +{ + this->indent_level_ = 0; + return 0; +} + +// Indented print. +int +TAO_OutStream::indent (void) +{ + // Based on the current indentation level, leave appropriate number of blank + // spaces in the output. + if (this->indent_level_ > 0) + { + for (int i = 0; i < this->indent_level_; i++) + { + ACE_OS::fprintf (this->fp_, " "); + ACE_OS::fflush (this->fp_); + } + } + + return 0; +} + +int +TAO_OutStream::nl (void) +{ + ACE_OS::fprintf (this->fp_, "\n"); + this->indent (); + return 0; +} + +// Printf style variable argument print. +int +TAO_OutStream::print (const char *format, ...) +{ + int result = 0; + va_list ap; + va_start (ap, format); + ACE_OSCALL (::vfprintf (this->fp_, + format, + ap), + int, + -1, + result); + + ACE_OS::fflush (this->fp_); + va_end (ap); + + return result; +} + +void +TAO_OutStream::gen_ifndef_string (const char *fname, + const char *prefix, + const char *suffix) +{ + static char macro_name [NAMEBUFSIZE]; + + ACE_OS::memset (macro_name, + '\0', + NAMEBUFSIZE); + + const char *extension = ACE_OS::strrchr (fname, '.'); + + if (extension == 0) + { + // File seems to have no extension, so let us take the name + // as it is. + extension = fname; + } + + ACE_OS::sprintf (macro_name, prefix); + + size_t offset = ACE_OS::strlen (prefix); + + // Convert letters in fname to upper case. + for (int i = 0; i < (extension - fname); i++) + { + if (ACE_OS::ace_isalpha (fname [i])) + { + macro_name[i + offset] = (char) ACE_OS::ace_toupper (fname [i]); + } + else if (ACE_OS::ace_isdigit (fname [i])) + { + macro_name[i + offset] = fname[i]; + } + else + { + macro_name[i + offset] = '_'; + } + } + + ACE_OS::strcat (macro_name, suffix); + + // Generate the #ifndef ... #define statements. + this->print ("#ifndef %s\n", + macro_name); + this->print ("#define %s", + macro_name); +} + +TAO_OutStream & +TAO_OutStream::operator<< (const char *str) +{ + ACE_OS::fprintf (this->fp_, "%s", str); + ACE_OS::fflush (this->fp_); + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::UShort num) +{ + ACE_OS::fprintf (this->fp_, + "%hu", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::Short num) +{ + ACE_OS::fprintf (this->fp_, + "%hd", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::ULong num) +{ + ACE_OS::fprintf (this->fp_, + "%lu", + (unsigned long) num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::Long num) +{ + ACE_OS::fprintf (this->fp_, + "%ld", + (long) num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +#if defined (ACE_WIN64) +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::ULongLong num) +{ + ACE_OS::fprintf (this->fp_, + ACE_UINT64_FORMAT_SPECIFIER, + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::LongLong num) +{ + ACE_OS::fprintf (this->fp_, + ACE_INT64_FORMAT_SPECIFIER, + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} +#endif /* ACE_WIN64 */ + +TAO_OutStream & +TAO_OutStream::operator<< (const unsigned long num) +{ + ACE_OS::fprintf (this->fp_, + "%lu", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const long num) +{ + ACE_OS::fprintf (this->fp_, + "%ld", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_NL&) +{ + ACE_OS::fprintf (this->fp_ , + "\n"); + this->indent (); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_INDENT& i) +{ + this->incr_indent (0); + + if (i.do_now_) + { + this->nl (); + } + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_UNINDENT& i) +{ + this->decr_indent (0); + + if (i.do_now_) + { + this->nl (); + } + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (Identifier *id) +{ + return this->print (id); +} + +TAO_OutStream & +TAO_OutStream::operator<< (AST_Expression *expr) +{ + return this->print (expr); +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_helper.h b/modules/CIAO/tools/IDL3_to_IDL2/be_helper.h new file mode 100644 index 00000000000..7fab4e04347 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_helper.h @@ -0,0 +1,180 @@ +/* -*- c++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO IDL +// +// = FILENAME +// be_helper.h +// +// = DESCRIPTION +// Defines the abstract class for outputting the C++ mapping. This is a +// helper class to the singleton TAO_CodeGen class +// +// = AUTHOR +// Aniruddha Gokhale +// +// Improvements by Carlos O'Ryan +// +// ============================================================================ + +#ifndef TAO_BE_OUTSTRM_H +#define TAO_BE_OUTSTRM_H + +#include "ace/CDR_Base.h" + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" + +class Identifier; +class UTL_IdList; +class AST_Expression; + +// a dummy structure to inform TAO_OutStream's << operator to put a newline +// and use the current indentation for the succeeding line +struct TAO_IDL3_TO_IDL2_BE_Export TAO_NL +{ +public: + TAO_NL (void); +}; + +struct TAO_IDL3_TO_IDL2_BE_Export TAO_INDENT +{ + // = TITLE + // Operates like a manipulator, increasing the indentation level. + // + // = DESCRIPTION + // Increase the indentation level, if the "do_now" parameter is + // not zero then the <indent> method is called on the stream. + // + TAO_INDENT (int do_now = 0); + + const int do_now_; +}; + +struct TAO_IDL3_TO_IDL2_BE_Export TAO_UNINDENT +{ + // = TITLE + // Operates like a manipulator, decreasing the indentation level. + // + // = DESCRIPTION + // Decrease the indentation level, if the "do_now" parameter is + // not zero then the <indent> method is called on the stream. + // + TAO_UNINDENT (int do_now = 0); + + const int do_now_; +}; + +extern TAO_IDL3_TO_IDL2_BE_Export const TAO_NL be_nl; +extern TAO_IDL3_TO_IDL2_BE_Export const TAO_INDENT be_idt; +extern TAO_IDL3_TO_IDL2_BE_Export const TAO_INDENT be_idt_nl; +extern TAO_IDL3_TO_IDL2_BE_Export const TAO_UNINDENT be_uidt; +extern TAO_IDL3_TO_IDL2_BE_Export const TAO_UNINDENT be_uidt_nl; + +class TAO_IDL3_TO_IDL2_BE_Export TAO_OutStream +{ + // =TITLE + // TAO_OutStream + // + // =DESCRIPTION + // Defines an interface by which the backend code generator can + // print its output to the underlying I/O handle. This is a + // helper class that will be used by the TAO_CodeGen + // class. However, this is an abstract class and classes that + // understand specific front ends must derive from this class. +public: + TAO_OutStream (void); + // constructor. + + virtual ~TAO_OutStream (void); + // destructor. + + int open (const char *fname); + // open the underlying low-level handle for output. + + + FILE *file (void); + // Return the underlying lowlevel file pointer. + + int incr_indent (unsigned short flag = 1); + // increment the indentation level and by default actually indent the output + // accordingly + + int decr_indent (unsigned short flag = 1); + // decrease the indentation level and by default actually indent the output + // accordingly + + int reset (void); + // reset indentation level to 0 + + int indent (void); + // indent starting next line + + int nl (void); + // put a newline and indent on the next line + + int print (const char *format, ...); + // "printf" style variable argument print + + void gen_ifndef_string (const char *fname, + const char *prefix, + const char *suffix); + + // =overloaded operators + + TAO_OutStream &operator<< (const char *str); + // output the char string and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::UShort num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::Short num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::ULong num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::Long num); + // output the integer and return a reference to ourselves + +#if defined (ACE_WIN64) + TAO_OutStream &operator<< (const ACE_CDR::ULongLong num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::LongLong num); + // output the integer and return a reference to ourselves +#endif /* ACE_WIN64 */ + + TAO_OutStream &operator<< (const unsigned long num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const long num); + // output the integer and return a reference to ourselves + + // = MANIPULATORS + + TAO_OutStream &operator<< (const TAO_NL& nl); + TAO_OutStream &operator<< (const TAO_INDENT& i); + TAO_OutStream &operator<< (const TAO_UNINDENT& i); + + // The following will be provided by specialized classes. + + TAO_OutStream &operator<< (Identifier *id); + TAO_OutStream &operator<< (AST_Expression *expr); + + // Provided by specialized classes. + virtual TAO_OutStream &print (Identifier *id) = 0; + + virtual TAO_OutStream &print (AST_Expression *idl) = 0; + +protected: + FILE *fp_; + // The underlying low-level I/O handle. + + int indent_level_; + // indentation level +}; + +#endif // if !defined diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_init.cpp b/modules/CIAO/tools/IDL3_to_IDL2/be_init.cpp new file mode 100644 index 00000000000..fe111e60a47 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_init.cpp @@ -0,0 +1,32 @@ +// $Id$ + +#include "global_extern.h" +#include "be_extern.h" +#include "../../ciao/Version.h" + +TAO_IDL3_TO_IDL2_BE_Export void +BE_version (void) +{ + ACE_DEBUG ((LM_DEBUG, + "%s %s\n", + ACE_TEXT ("TAO_ID3_TO_IDL2_BE, version"), + ACE_TEXT (CIAO_VERSION))); +} + +TAO_IDL3_TO_IDL2_BE_Export int +BE_init (int & /* argc */, ACE_TCHAR * /*argv */ []) +{ + // Initialize BE global data object. + ACE_NEW_RETURN (be_global, + BE_GlobalData, + -1); + + idl_global->pass_orb_idl (true); + return 0; +} + +TAO_IDL3_TO_IDL2_BE_Export void +BE_post_init (char * /* files */ [], long /* nfiles */) +{ +} + diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_produce.cpp b/modules/CIAO/tools/IDL3_to_IDL2/be_produce.cpp new file mode 100644 index 00000000000..94619136efc --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_produce.cpp @@ -0,0 +1,168 @@ +// $Id$ + +/* + +COPYRIGHT + +Copyright 1992, 1993, 1994 Sun Microsystems, Inc. Printed in the United +States of America. All Rights Reserved. + +This product is protected by copyright and distributed under the following +license restricting its use. + +The Interface Definition Language Compiler Front End (CFE) is made +available for your use provided that you include this license and copyright +notice on all media and documentation and the software program in which +this product is incorporated in whole or part. You may copy and extend +functionality (but may not remove functionality) of the Interface +Definition Language CFE without charge, but you are not authorized to +license or distribute it to anyone else except as part of a product or +program developed by you or with the express written consent of Sun +Microsystems, Inc. ("Sun"). + +The names of Sun Microsystems, Inc. and any of its subsidiaries or +affiliates may not be used in advertising or publicity pertaining to +distribution of Interface Definition Language CFE as permitted herein. + +This license is effective until terminated by Sun for failure to comply +with this license. Upon termination, you shall destroy or return all code +and documentation for the Interface Definition Language CFE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF +ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS +FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF +DEALING, USAGE OR TRADE PRACTICE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT +ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES +TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT. + +SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH +RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY +INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF. + +IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR +ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL +DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +Use, duplication, or disclosure by the government is subject to +restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in +Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR +52.227-19. + +Sun, Sun Microsystems and the Sun logo are trademarks or registered +trademarks of Sun Microsystems, Inc. + +SunSoft, Inc. +2550 Garcia Avenue +Mountain View, California 94043 + +NOTE: + +SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are +trademarks or registered trademarks of Sun Microsystems, Inc. + + */ + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" +#include "global_extern.h" +#include "be_extern.h" +#include "be_helper.h" +#include "fe_extern.h" +#include "utl_string.h" +#include "ast_root.h" +#include "checking_visitor.h" +#include "idl3_to_idl2_visitor.h" + +// Clean up before exit, whether successful or not. +TAO_IDL3_TO_IDL2_BE_Export void +BE_cleanup (void) +{ + idl_global->destroy (); +} + +// Abort this run of the BE. +TAO_IDL3_TO_IDL2_BE_Export void +BE_abort (void) +{ + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Fatal Error - Aborting\n"))); + + // BE_cleanup will be called after the exception is caught. + throw Bailout (); +} + +// Do the work of this BE. This is the starting point for code generation. +TAO_IDL3_TO_IDL2_BE_Export void +BE_produce (void) +{ + // Get the root node. + AST_Decl *d = idl_global->root (); + AST_Root *ast_root = AST_Root::narrow_from_decl (d); + + if (ast_root == 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce - ") + ACE_TEXT ("No Root\n"))); + BE_abort (); + } + + checking_visitor c_visitor; + + if (c_visitor.visit_root (ast_root) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce - failed") + ACE_TEXT (" to accept checking visitor\n"))); + + BE_abort (); + } + + // Create and launch the 'equivalent IDL' visitor only if IDL3 + // declarations were seen by the checking visitor, or if we + // are not just including an IDL2-only original file in a new file. + if (c_visitor.is_idl3 () || !be_global->encapsulate_idl2 ()) + { + idl3_to_idl2_visitor visitor; + + if (visitor.visit_root (ast_root) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce - failed to") + ACE_TEXT (" accept idl3_to_idl2 visitor\n"))); + } + } + else + { + TAO_OutStream *os = 0; + int status = be_global->outfile_init (os, + "", + "_IDL2.idl", + "_TAO_IDL_", + "_IDL_"); + + if (status == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce - ") + ACE_TEXT ("failed to initialize output file\n"))); + + delete os; + os = 0; + BE_abort (); + } + + *os << be_nl << be_nl + << "#include \"" + << idl_global->stripped_filename ()->get_string () + << "\"" << be_nl << be_nl + << "#endif /* ifndef */" << be_nl; + + delete os; + os = 0; + } + + // Clean up. + BE_cleanup (); +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.cpp b/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.cpp new file mode 100644 index 00000000000..e924ccea47d --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.cpp @@ -0,0 +1,157 @@ +// $Id$ + +#include "be_sunsoft.h" +#include "identifier_helper.h" + +#include "ast_expression.h" +#include "utl_identifier.h" +#include "utl_idlist.h" +#include "utl_string.h" + +#include "ace/OS_NS_stdio.h" +#include "ace/OS_NS_string.h" +#include "ace/OS_NS_ctype.h" + +ACE_RCSID (be, + be_sunsoft, + "$Id$") + +TAO_SunSoft_OutStream::TAO_SunSoft_OutStream (void) + : TAO_OutStream () +{ +} + +TAO_SunSoft_OutStream::~TAO_SunSoft_OutStream (void) +{ +} + +TAO_OutStream & +TAO_SunSoft_OutStream::print (Identifier *id) +{ + ACE_OS::fprintf (this->fp_, + id->get_string ()); + + return *this; +} + +TAO_OutStream& +TAO_SunSoft_OutStream::print (AST_Expression *expr) +{ + AST_Expression::AST_ExprValue *ev = expr->ev (); + + if (ev) + { + switch (ev->et) + { + case AST_Expression::EV_short: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII, ev->u.sval); + break; + case AST_Expression::EV_ushort: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.usval, 'U'); + break; + case AST_Expression::EV_long: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII, ev->u.lval); + break; + case AST_Expression::EV_ulong: + this->TAO_OutStream::print (ACE_UINT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.ulval, 'U'); + break; + // The ACE_LACKS_LONGLONG_T guards have been removed around + // the next 2 cases since the macros now used should work + // whether native 64-bit integers are defined or not. + case AST_Expression::EV_longlong: + this->TAO_OutStream::print ("ACE_INT64_LITERAL ("); + this->TAO_OutStream::print (ACE_INT64_FORMAT_SPECIFIER_ASCII, + ev->u.llval); + this->TAO_OutStream::print (")"); + break; + case AST_Expression::EV_ulonglong: + this->TAO_OutStream::print ("ACE_UINT64_LITERAL ("); + this->TAO_OutStream::print (ACE_UINT64_FORMAT_SPECIFIER_ASCII, + ev->u.ullval); + this->TAO_OutStream::print (")"); + break; + case AST_Expression::EV_float: + this->TAO_OutStream::print ("%f%c", ev->u.fval, 'F'); + break; + case AST_Expression::EV_double: + this->TAO_OutStream::print ("%24.16G", ev->u.dval); + break; + case AST_Expression::EV_longdouble: + break; + case AST_Expression::EV_char: + // isprint() sees \ and ' as printable characters + // so we have to test for them first. + if (ev->u.cval == '\\') + this->TAO_OutStream::print ("'\\\\'"); + else if (ev->u.cval == '\'') + this->TAO_OutStream::print ("'\\''"); + + // This handles hex and octal escape sequences + // that would print out either as weird characters + // or as an unsigned number too large for a char. + else if ((unsigned char) ev->u.cval > ACE_CHAR_MAX) + this->TAO_OutStream::print ("%hd", ev->u.cval); + else if (ACE_OS::ace_isprint (ev->u.cval)) + this->TAO_OutStream::print ("'%c'", ev->u.cval); + else if (ACE_OS::ace_iscntrl (ev->u.cval)) + switch (ev->u.cval) + { + case '\n': + this->TAO_OutStream::print ("'\\n'"); + break; + case '\t': + this->TAO_OutStream::print ("'\\t'"); + break; + case '\r': + this->TAO_OutStream::print ("'\\r'"); + break; + case '\v': + this->TAO_OutStream::print ("'\\v'"); + break; + case '\f': + this->TAO_OutStream::print ("'\\f'"); + break; + case '\b': + this->TAO_OutStream::print ("'\\b'"); + break; + case '\a': + this->TAO_OutStream::print ("'\\a'"); + break; + case '\?': + this->TAO_OutStream::print ("'?'"); + break; + default: + this->TAO_OutStream::print ("'\\x%x'", ev->u.cval); + } + else + this->TAO_OutStream::print ("'\\x%x'", ev->u.cval); + break; + case AST_Expression::EV_wchar: + this->TAO_OutStream::print ("L'%lc'", ev->u.wcval); + break; + case AST_Expression::EV_octet: + this->TAO_OutStream::print ("%d", ev->u.oval); + break; + case AST_Expression::EV_bool: + this->TAO_OutStream::print ("%s", ev->u.bval ? "true" : "false"); + break; + case AST_Expression::EV_string: + this->TAO_OutStream::print ("\"%s\"", ev->u.strval->get_string ()); + break; + case AST_Expression::EV_wstring: + this->TAO_OutStream::print ("L\"%s\"", ev->u.wstrval); + break; + case AST_Expression::EV_enum: + *this << IdentifierHelper::orig_sn (expr->n ()).c_str (); + break; + default: + break; + } + } + else + { + // XXXASG: need to add code here + } + + return *this; +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.h b/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.h new file mode 100644 index 00000000000..c269c8c3bc8 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/be_sunsoft.h @@ -0,0 +1,45 @@ +/* -*- c++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO IDL +// +// = FILENAME +// be_sunsoft.h +// +// = DESCRIPTION +// SunSoft specific backend output generation +// +// = AUTHOR +// Aniruddha Gokhale +// +// ============================================================================ + +#ifndef TAO_BE_HELPER_H +#define TAO_BE_HELPER_H + +#include "be_helper.h" + +class TAO_IDL3_TO_IDL2_BE_Export TAO_SunSoft_OutStream : public TAO_OutStream +{ + // =TITLE + // TAO_SunSoft_OutStream + // =DESCRIPTION + // Backend specific to SunSoft AST nodes +public: + TAO_SunSoft_OutStream (void); + // constructor + + ~TAO_SunSoft_OutStream (void); + // destuctor + + virtual TAO_OutStream &print (Identifier *id); + // output the SunSoft IDL Identifier Node + + virtual TAO_OutStream &print (AST_Expression *expr); + // output the contents of the AST_Expression node +}; + +#endif // if !defined diff --git a/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.cpp b/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.cpp new file mode 100644 index 00000000000..d0ff78e8707 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.cpp @@ -0,0 +1,461 @@ +/* -*- c++ -*- */ +// $Id$ + +#include "checking_visitor.h" +#include "identifier_helper.h" +#include "be_extern.h" + +#include "ast_component.h" +#include "ast_component_fwd.h" +#include "ast_eventtype.h" +#include "ast_eventtype_fwd.h" +#include "ast_home.h" +#include "ast_root.h" +#include "global_extern.h" +#include "nr_extern.h" + +checking_visitor::checking_visitor (void) + : is_idl3_ (false) +{ +} + +checking_visitor::~checking_visitor (void) +{ +} + +int +checking_visitor::visit_decl (AST_Decl *) +{ + return 0; +} + +int +checking_visitor::visit_scope (UTL_Scope *node) +{ + for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); + !si.is_done (); + si.next ()) + { + AST_Decl *d = si.item (); + AST_Decl::NodeType nt = d->node_type (); + + if (nt == AST_Decl::NT_typedef || nt == AST_Decl::NT_pre_defined) + { + continue; + } + + // Want to skip the uses_xxxConnection structs added by uses + // multiple ports. + // @@@ (JP) This will go away when the visitor is finished, since + // those uses_xxxConnection structs will not be added to the AST. + if (ScopeAsDecl (node)->node_type () == AST_Decl::NT_component + && nt != AST_Decl::NT_attr) + { + continue; + } + + if (d->ast_accept (this) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "checking_visitor::visit_scope - " + "codegen for scope failed\n"), + -1); + } + } + + return 0; +} + +int +checking_visitor::visit_type (AST_Type *) +{ + return 0; +} + +int +checking_visitor::visit_predefined_type (AST_PredefinedType *) +{ + return 0; +} + +int +checking_visitor::visit_module (AST_Module *node) +{ + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "checking_visitor::visit_module - " + "codegen for scope failed\n"), + -1); + } + + return 0; +} + +int +checking_visitor::visit_interface (AST_Interface *) +{ + return 0; +} + +int +checking_visitor::visit_interface_fwd (AST_InterfaceFwd *) +{ + return 0; +} + +int +checking_visitor::visit_template_interface (AST_Template_Interface *) +{ + return 0; +} + +int +checking_visitor::visit_valuebox (AST_ValueBox *) +{ + return 0; +} + +int +checking_visitor::visit_valuetype (AST_ValueType *) +{ + return 0; +} + +int +checking_visitor::visit_valuetype_fwd (AST_ValueTypeFwd *) +{ + return 0; +} + +int +checking_visitor::visit_component (AST_Component *node) +{ + this->is_idl3_ = true; + this->remove_idl2_only_filename (node->file_name ()); + return 0; +} + +int +checking_visitor::visit_component_fwd (AST_ComponentFwd *node) +{ + this->is_idl3_ = true; + this->remove_idl2_only_filename (node->file_name ()); + return 0; +} + +int +checking_visitor::visit_porttype (AST_PortType *) +{ + return 0; +} + +int +checking_visitor::visit_provides (AST_Provides *) +{ + return 0; +} + +int +checking_visitor::visit_uses (AST_Uses *) +{ + return 0; +} + +int +checking_visitor::visit_publishes (AST_Publishes *) +{ + return 0; +} + +int +checking_visitor::visit_emits (AST_Emits *) +{ + return 0; +} + +int +checking_visitor::visit_consumes (AST_Consumes *) +{ + return 0; +} + +int +checking_visitor::visit_extended_port (AST_Extended_Port *) +{ + return 0; +} + +int +checking_visitor::visit_mirror_port (AST_Mirror_Port *) +{ + return 0; +} + +int +checking_visitor::visit_connector (AST_Connector *) +{ + return 0; +} + +int +checking_visitor::visit_instantiated_connector ( + AST_Instantiated_Connector *) +{ + return 0; +} + +int +checking_visitor::visit_tmpl_port (AST_Tmpl_Port *) +{ + return 0; +} + +int +checking_visitor::visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *) +{ + return 0; +} + +int +checking_visitor::visit_eventtype (AST_EventType *node) +{ + this->is_idl3_ = true; + this->remove_idl2_only_filename (node->file_name ()); + return 0; +} + +int +checking_visitor::visit_eventtype_fwd (AST_EventTypeFwd *node) +{ + this->is_idl3_ = true; + this->remove_idl2_only_filename (node->file_name ()); + return 0; +} + +int +checking_visitor::visit_home (AST_Home *node) +{ + this->is_idl3_ = true; + this->remove_idl2_only_filename (node->file_name ()); + return 0; +} + + +int +checking_visitor::visit_factory (AST_Factory *) +{ + return 0; +} + +int +checking_visitor::visit_structure (AST_Structure *) +{ + return 0; +} + +int +checking_visitor::visit_structure_fwd (AST_StructureFwd *) +{ + return 0; +} + +int +checking_visitor::visit_exception (AST_Exception *) +{ + return 0; +} + +int +checking_visitor::visit_expression (AST_Expression *) +{ + return 0; +} + +int +checking_visitor::visit_enum (AST_Enum *) +{ + return 0; +} + + +int +checking_visitor::visit_union (AST_Union *) +{ + return 0; +} + +int +checking_visitor::visit_union_fwd (AST_UnionFwd *) +{ + return 0; +} + + +int +checking_visitor::visit_constant (AST_Constant *) +{ + return 0; +} + +int +checking_visitor::visit_enum_val (AST_EnumVal *) +{ + return 0; +} + +int +checking_visitor::visit_root (AST_Root *node) +{ + // Populate this list with all included filenames. They will be + // removed as IDL3 constructs are found in them. + for (size_t i = 0; i < idl_global->n_included_idl_files (); ++i) + { + if (! this->idl2_only_files_.empty ()) + { + this->idl2_only_files_ += " "; + } + + this->idl2_only_files_ += idl_global->included_idl_files ()[i]; + } + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "checking_visitor::visit_root - " + "codegen for scope failed\n"), + -1); + } + + // Append the remaining names in this list to the excluded + // filenames list. If a filename ends up appearing twice, it + // shouldn't matter. + be_global->set_excluded_filenames (this->idl2_only_files_.c_str ()); + + return 0; +} + +int +checking_visitor::visit_native (AST_Native *) +{ + return 0; +} + +int +checking_visitor::visit_operation (AST_Operation *) +{ + return 0; +} + +int +checking_visitor::visit_field (AST_Field *) +{ + return 0; +} + +int +checking_visitor::visit_argument (AST_Argument *) +{ + return 0; +} + +int +checking_visitor::visit_attribute (AST_Attribute *) +{ + return 0; +} + +int +checking_visitor::visit_union_branch (AST_UnionBranch *) +{ + return 0; +} + +int +checking_visitor::visit_union_label (AST_UnionLabel *) +{ + return 0; +} + +int +checking_visitor::visit_array (AST_Array *) +{ + return 0; +} + +int +checking_visitor::visit_sequence (AST_Sequence *) +{ + return 0; +} + +int +checking_visitor::visit_string (AST_String *) +{ + return 0; +} + +int +checking_visitor::visit_typedef (AST_Typedef *) +{ + return 0; +} + +bool +checking_visitor::is_idl3 (void) const +{ + return this->is_idl3_; +} + +void +checking_visitor::remove_idl2_only_filename (ACE_CString filename) +{ + if (this->idl2_only_files_.empty ()) + { + return; + } + + ACE_CString::size_type p = 0; + ACE_CString raw_local_fname (filename); + + ACE_CString::size_type pos = raw_local_fname.rfind ('/'); + + if (pos != ACE_CString::npos) + { + raw_local_fname = + raw_local_fname.substr (pos + 1); + } + + while (p != ACE_CString::npos) + { + ACE_CString::size_type cursor = p; + + if (cursor >= this->idl2_only_files_.length ()) + { + break; + } + + p = this->idl2_only_files_.find (' ', cursor); + + ACE_CString one_filename = + this->idl2_only_files_.substr (cursor, p - cursor); + + // Skip the whitespace. + if (p != ACE_CString::npos) + { + while (this->idl2_only_files_[p] == ' ') + { + p++; + } + } + + if (one_filename == raw_local_fname) + { + this->idl2_only_files_ = + this->idl2_only_files_.substr (0, cursor) + + this->idl2_only_files_.substr (p); + } + } +} + diff --git a/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.h b/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.h new file mode 100644 index 00000000000..ade99005e81 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/checking_visitor.h @@ -0,0 +1,113 @@ +// $Id$ + +/* -*- c++ -*- */ +// ============================================================================ +// +// = LIBRARY +// TAO_IDL3_TO_IDL2_BE_DLL +// +// = FILENAME +// checking_visitor.h +// +// = DESCRIPTION +// Visitor that checks input IDL3 in a separate pass. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#ifndef TAO_IDL_CHECKING_VISITOR_H +#define TAO_IDL_CHECKING_VISITOR_H + +#include "ace/SString.h" + +#include "ast_visitor.h" +#include "utl_scoped_name.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" + +class UTL_ExceptList; + +class TAO_IDL3_TO_IDL2_BE_Export checking_visitor : public ast_visitor +{ + // + // = TITLE + // checking_visitor. + // + // = DESCRIPTION + // Checks input IDL3 and sets flags used by subsequent + // equivalent IDL generating visitor. + // +public: + checking_visitor (void); + virtual ~checking_visitor (void); + + virtual int visit_decl (AST_Decl *d); + virtual int visit_scope (UTL_Scope *node); + virtual int visit_type (AST_Type *node); + virtual int visit_predefined_type (AST_PredefinedType *node); + virtual int visit_module (AST_Module *node); + virtual int visit_interface (AST_Interface *node); + virtual int visit_interface_fwd (AST_InterfaceFwd *node); + virtual int visit_template_interface (AST_Template_Interface *node); + virtual int visit_valuebox (AST_ValueBox *node); + virtual int visit_valuetype (AST_ValueType *node); + virtual int visit_valuetype_fwd (AST_ValueTypeFwd *node); + virtual int visit_component (AST_Component *node); + virtual int visit_component_fwd (AST_ComponentFwd *node); + virtual int visit_porttype (AST_PortType *node); + virtual int visit_provides (AST_Provides *node); + virtual int visit_uses (AST_Uses *node); + virtual int visit_publishes (AST_Publishes *node); + virtual int visit_emits (AST_Emits *node); + virtual int visit_consumes (AST_Consumes *node); + virtual int visit_extended_port (AST_Extended_Port *node); + virtual int visit_mirror_port (AST_Mirror_Port *node); + virtual int visit_connector (AST_Connector *node); + virtual int visit_instantiated_connector ( + AST_Instantiated_Connector *node); + virtual int visit_tmpl_port (AST_Tmpl_Port *node); + virtual int visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *node); + virtual int visit_eventtype (AST_EventType *node); + virtual int visit_eventtype_fwd (AST_EventTypeFwd *node); + virtual int visit_home (AST_Home *node); + virtual int visit_factory (AST_Factory *node); + virtual int visit_structure (AST_Structure *node); + virtual int visit_structure_fwd (AST_StructureFwd *node); + virtual int visit_exception (AST_Exception *node); + virtual int visit_expression (AST_Expression *node); + virtual int visit_enum (AST_Enum *node); + virtual int visit_operation (AST_Operation *node); + virtual int visit_field (AST_Field *node); + virtual int visit_argument (AST_Argument *node); + virtual int visit_attribute (AST_Attribute *node); + virtual int visit_union (AST_Union *node); + virtual int visit_union_fwd (AST_UnionFwd *node); + virtual int visit_union_branch (AST_UnionBranch *node); + virtual int visit_union_label (AST_UnionLabel *node); + virtual int visit_constant (AST_Constant *node); + virtual int visit_enum_val (AST_EnumVal *node); + virtual int visit_array (AST_Array *node); + virtual int visit_sequence (AST_Sequence *node); + virtual int visit_string (AST_String *node); + virtual int visit_typedef (AST_Typedef *node); + virtual int visit_root (AST_Root *node); + virtual int visit_native (AST_Native *node); + + bool is_idl3 (void) const; + +private: + void remove_idl2_only_filename (ACE_CString filename); + +private: + bool is_idl3_; + ACE_CString idl2_only_files_; +}; + +#endif /* TAO_IDL_CHECKING_VISITOR_H */ diff --git a/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.cpp b/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.cpp new file mode 100644 index 00000000000..9b8a255b9c5 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.cpp @@ -0,0 +1,123 @@ +/* -*- c++ -*- */ +// $Id$ + +#include "identifier_helper.h" +#include "utl_identifier.h" +#include "utl_string.h" +#include "fe_private.h" +#include "global_extern.h" + +Identifier * +IdentifierHelper::original_local_name (Identifier * local_name) +{ + Identifier * id = 0; + const char *lname = local_name->get_string (); + + // Remove _cxx_ if: + // 1. it occurs and + // 2. it occurs at the beginning of the string and + // 3. the rest of the string is a C++ keyword + if (ACE_OS::strstr (lname, "_cxx_") == lname) + { + TAO_IDL_CPP_Keyword_Table cpp_key_tbl; + + unsigned int len = + static_cast<unsigned int> (ACE_OS::strlen (lname + 5)); + + const TAO_IDL_CPP_Keyword_Entry *entry = + cpp_key_tbl.lookup (lname + 5, len); + + if (entry != 0) + { + // Remove _cxx_ and assign to the Identifier variable. + ACE_NEW_RETURN (id, + Identifier (lname + 5), + 0); + } + } + + if (id == 0) + { + id = local_name->copy (); + } + + return id; +} + +ACE_CString +IdentifierHelper::orig_sn (UTL_IdList * sn, bool appended_to) +{ + ACE_CString retval; + bool first = true; + bool second = false; + Identifier *id = 0; + + for (UTL_IdListActiveIterator i (sn); !i.is_done ();) + { + if (!first) + { + retval += "::"; + } + else if (second) + { + first = second = false; + } + + id = IdentifierHelper::original_local_name (i.item ()); + i.next (); + + // Append the identifier. + retval += + appended_to && i.is_done () + ? id->get_string () + : IdentifierHelper::try_escape (id).c_str (); + + if (first) + { + if (ACE_OS::strcmp (id->get_string (), "") != 0) + { + // Does not start with a "". + first = false; + } + else + { + second = true; + } + } + + id->destroy (); + delete id; + id = 0; + } + + return retval; +} + +bool +IdentifierHelper::is_idl_keyword (Identifier * local_name) +{ + UTL_String utl_tmp (local_name->get_string ()); + ACE_CString ext_id (utl_tmp.get_canonical_rep (), + 0, + false); + + int status = idl_global->idl_keywords ().find (ext_id); + utl_tmp.destroy (); + + return status == 0; +} + +ACE_CString +IdentifierHelper::try_escape (Identifier * local_name) +{ + ACE_CString s_local_name (local_name->get_string ()); + + if (IdentifierHelper::is_idl_keyword (local_name)) + { + return "_" + s_local_name; + } + else + { + return s_local_name; + } +} diff --git a/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.h b/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.h new file mode 100644 index 00000000000..a6a6fcc88df --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/identifier_helper.h @@ -0,0 +1,66 @@ +// $Id$ + +/* -*- c++ -*- */ +// ============================================================================ +// +// = LIBRARY +// TAO_IDL3_TO_IDL2_BE_DLL +// +// = FILENAME +// identifier_helper.h +// +// = DESCRIPTION +// Utilities associated with UTL_Identifier. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#ifndef IDENTIFIER_HELPER_H +#define IDENTIFIER_HELPER_H + +#include "utl_scoped_name.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" +#include "ace/SString.h" + +class Identifier; + +struct TAO_IDL3_TO_IDL2_BE_Export IdentifierHelper +{ + // + // = TITLE + // IdentifierHelper. + // + // = DESCRIPTION + // 1) keeps escape (leading underscore character in generated + // identifier in IDL + // 2) removes the '_' escape character when the identifier is + // part of another identifier such as in provides_XXX + // 3) removes any '_cxx_' in generated IDL + + static Identifier * + original_local_name (Identifier * local_name); + + // Removes '_cxx_ from segments of a scoped name, and optionally + // de-escape the last segment, if it's to be appended to. + static ACE_CString + orig_sn (UTL_ScopedName * scoped_name, bool appended_to = false); + + // Detects case-insensitive match with IDL keyword. + static bool + is_idl_keyword (Identifier * local_name); + + // Preserves the 'escape' (leading underscore) in a + // generated identifier if necessary. + static ACE_CString + try_escape (Identifier * local_name); +}; + +#endif /* IDENTIFIER_HELPER_H */ + diff --git a/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.cpp b/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.cpp new file mode 100644 index 00000000000..209c5a8e716 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.cpp @@ -0,0 +1,779 @@ +/* -*- c++ -*- */ +// $Id$ + +#include "idl3_to_idl2_visitor.h" +#include "identifier_helper.h" +#include "be_sunsoft.h" +#include "be_extern.h" + +#include "ast_component_fwd.h" +#include "ast_provides.h" +#include "ast_uses.h" +#include "ast_publishes.h" +#include "ast_emits.h" +#include "ast_consumes.h" +#include "ast_eventtype.h" +#include "ast_eventtype_fwd.h" +#include "ast_home.h" +#include "ast_operation.h" +#include "ast_root.h" +#include "utl_exceptlist.h" +#include "utl_identifier.h" +#include "global_extern.h" +#include "nr_extern.h" + +idl3_to_idl2_visitor::idl3_to_idl2_visitor (void) + : basic_visitor () +{ +} + +idl3_to_idl2_visitor::~idl3_to_idl2_visitor (void) +{ +} + +int +idl3_to_idl2_visitor::visit_module (AST_Module *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + ACE_CString name = + IdentifierHelper::try_escape (node->original_local_name ()); + + *os << "module " << name.c_str () << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + this->check_prefix (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_module - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "}; // end of module " << name.c_str (); + + return 0; +} + +int +idl3_to_idl2_visitor::visit_interface (AST_Interface *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl; + + if (node->is_local ()) + { + *os << "local "; + } + + if (node->is_abstract ()) + { + *os << "abstract "; + } + + *os << "interface " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + AST_Interface **parents = node->inherits (); + + for (long i = 0; i < node->n_inherits (); ++i) + { + if (i == 0) + { + *os << " : "; + } + else + { + *os << ", "; + } + + *os << IdentifierHelper::orig_sn (parents[i]->name ()).c_str (); + } + + *os << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + this->check_prefix (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_interface - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_component (AST_Component *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl + << "interface " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str (); + + AST_Component *base = node->base_component (); + long nsupports = node->n_supports (); + + *os << " : " + << (base != 0 + ? IdentifierHelper::orig_sn (base->name ()).c_str () + : "Components::CCMObject"); + + for (long i = 0; i < nsupports; ++i) + { + *os << ", " + << IdentifierHelper::orig_sn (node->supports ()[i]->name ()).c_str (); + } + + *os << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_component - " + "codegen for scope failed\n"), + -1); + } + + *os << be_uidt_nl + << "};"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_component_fwd (AST_ComponentFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + *os << be_nl << be_nl + << "component " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << ";"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_provides (AST_Provides *node) +{ + Identifier *orig_id = + IdentifierHelper::original_local_name (node->local_name ()); + + UTL_ScopedName *n = node->provides_type ()->name (); + ACE_CString impl_name = + IdentifierHelper::orig_sn (n); + + *os << be_nl << be_nl + << impl_name.c_str () << " provide_" << orig_id << " ();"; + + orig_id->destroy (); + delete orig_id; + orig_id = 0; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_uses (AST_Uses *node) +{ + *os << be_nl << be_nl; + + Identifier *orig_id = + IdentifierHelper::original_local_name (node->local_name ()); + + UTL_ScopedName *n = node->uses_type ()->name (); + ACE_CString impl_name = + IdentifierHelper::orig_sn (n); + + if (node->is_multiple ()) + { + *os << "struct " << orig_id << "Connection" << be_nl + << "{" << be_idt_nl + << impl_name.c_str () << " objref;" << be_nl + << "Components::Cookie ck;" << be_uidt_nl + << "};" << be_nl << be_nl + << "typedef sequence<" << orig_id << "Connection> " + << orig_id << "Connections;" + << be_nl << be_nl + << "Components::Cookie connect_" << orig_id << " (in " + << impl_name.c_str () << " connection)" << be_idt_nl + << "raises (Components::ExceededConnectionLimit, " + << "Components::InvalidConnection);" << be_uidt_nl << be_nl + << impl_name.c_str () << " disconnect_" << orig_id + << " (in Components::Cookie ck)" << be_idt_nl + << "raises (Components::InvalidConnection);" + << be_uidt_nl << be_nl + << orig_id << "Connections get_connections_" << orig_id + << " ();"; + } + else + { + *os << "void connect_" << orig_id << " (in " + << impl_name.c_str () << " conxn)" << be_idt_nl + << "raises (Components::AlreadyConnected, " + << "Components::InvalidConnection);" << be_uidt_nl << be_nl + << impl_name.c_str () << " disconnect_" << orig_id + << " ()" << be_idt_nl + << "raises (Components::NoConnection);" << be_uidt_nl << be_nl + << impl_name.c_str () << " get_connection_" << orig_id + << " ();"; + } + + orig_id->destroy (); + delete orig_id; + orig_id = 0; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_publishes (AST_Publishes *node) +{ + Identifier *orig_id = + IdentifierHelper::original_local_name (node->local_name ()); + + UTL_ScopedName *n = node->publishes_type ()->name (); + ACE_CString impl_name = + IdentifierHelper::orig_sn (n, true); + + *os << be_nl << be_nl + << "Components::Cookie subscribe_" << orig_id + << " (in " + << impl_name.c_str () << "Consumer consumer)" + << be_idt_nl + << "raises (Components::ExceededConnectionLimit);" + << be_uidt_nl << be_nl + << impl_name.c_str () << "Consumer unsubscribe_" << orig_id + << " (in Components::Cookie ck)" << be_idt_nl + << "raises (Components::InvalidConnection);" << be_uidt; + + orig_id->destroy (); + delete orig_id; + orig_id = 0; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_emits (AST_Emits *node) +{ + Identifier *orig_id = + IdentifierHelper::original_local_name (node->local_name ()); + + UTL_ScopedName *n = node->emits_type ()->name (); + ACE_CString impl_name = + IdentifierHelper::orig_sn (n, true); + + *os << be_nl << be_nl + << "void connect_" << orig_id + << " (in " + << impl_name.c_str () << "Consumer consumer)" << be_idt_nl + << "raises (Components::AlreadyConnected);" + << be_uidt_nl << be_nl + << impl_name.c_str () << "Consumer disconnect_" << orig_id + << " ()" << be_idt_nl + << "raises (Components::NoConnection);" << be_uidt; + + orig_id->destroy (); + delete orig_id; + orig_id = 0; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_consumes (AST_Consumes *node) +{ + Identifier *orig_id = + IdentifierHelper::original_local_name (node->local_name ()); + + UTL_ScopedName *n = node->consumes_type ()->name (); + ACE_CString impl_name = + IdentifierHelper::orig_sn (n, true); + + *os << be_nl << be_nl + << impl_name.c_str () << "Consumer get_consumer_" << orig_id + << " ();"; + + orig_id->destroy (); + delete orig_id; + orig_id = 0; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_extended_port (AST_Extended_Port *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_mirror_port (AST_Mirror_Port *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_connector (AST_Connector *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_instantiated_connector ( + AST_Instantiated_Connector *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_tmpl_port (AST_Tmpl_Port *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *) +{ + return 0; +} + +int +idl3_to_idl2_visitor::visit_eventtype (AST_EventType *node) +{ + if (node->imported ()) + { + return 0; + } + + if (this->visit_valuetype (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_eventtype - " + "codegen for valuetype failed\n"), + -1); + } + + *os << be_nl << be_nl + << "interface " << node->original_local_name () << "Consumer : "; + + AST_Interface *parent = 0; + AST_Decl::NodeType nt = AST_Decl::NT_native; + + if (node->n_inherits () > 0) + { + parent = node->inherits ()[0]; + AST_Type *ut = parent->unaliased_type (); + nt = ut->node_type (); + } + + if (node->n_inherits () == 0 || nt == AST_Decl::NT_valuetype) + { + *os << "Components::EventConsumerBase"; + } + else + { + *os << IdentifierHelper::orig_sn (node->inherits ()[0]->name (), true).c_str () + << "Consumer"; + } + + *os << be_nl + << "{" << be_idt_nl + << "void push_" << node->original_local_name () << " (in " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " the_" + << node->original_local_name () << ");" << be_uidt_nl + << "};"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_eventtype_fwd (AST_EventTypeFwd *node) +{ + if (node->imported ()) + { + return 0; + } + + if (this->visit_valuetype_fwd (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_eventtype_fwd - " + "codegen for valuetype_fwd failed\n"), + -1); + } + + *os << be_nl + << "interface " << node->original_local_name () << "Consumer;"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_home (AST_Home *node) +{ + if (node->imported ()) + { + return 0; + } + + ACE_CString explicit_name = node->original_local_name ()->get_string (); + explicit_name += "Explicit"; + + *os << be_nl << be_nl + << "interface " << explicit_name.c_str () << " : "; + + AST_Home *base = node->base_home (); + + if (base == 0) + { + *os << "Components::CCMHome"; + } + else + { + *os << IdentifierHelper::orig_sn (base->name (), true).c_str () + << "Explicit"; + } + + *os << be_nl + << "{" << be_idt; + + this->check_id_and_version (node); + + // Create a temporary interface node corresponding to the one we + // just generated above for the home explicit interface. + UTL_ScopedName *sn = + this->create_scoped_name (0, + explicit_name.c_str (), + 0, + ScopeAsDecl (node->defined_in ())); + + AST_Interface xplicit (sn, + 0, + 0, + 0, + 0, + false, + false); + xplicit.set_defined_in (node->defined_in ()); + + // Reset the home's decls to be defined in the explicit home interface. + this->tranfer_scope_elements (node, xplicit); + + this->gen_factories (node, xplicit); + this->gen_finders (node, xplicit); + + *os << be_uidt_nl + << "};" << be_nl << be_nl; + + xplicit.destroy (); + sn->destroy (); + delete sn; + sn = 0; + + AST_ValueType *key = node->primary_key (); + ACE_CString mng_name = + IdentifierHelper::orig_sn (node->managed_component ()->name ()); + ACE_CString key_name; + + // Generate the implicit home interface and its operations. + *os << "interface " << node->original_local_name () << "Implicit" + << (key == 0 ? " : Components::KeylessCCMHome" : "") << be_nl + << "{" << be_idt_nl + << mng_name.c_str () << " create ("; + + if (key != 0) + { + key_name = + IdentifierHelper::orig_sn (key->name ()); + + *os << "in " << key_name.c_str () << " key"; + } + + *os << ")" << be_idt_nl + << "raises (Components::CreateFailure"; + + if (key != 0) + { + *os << ", Components::InvalidKey, Components::DuplicateKeyValue"; + } + + *os << ");" << be_uidt; + + if (key != 0) + { + *os << be_nl << be_nl + << mng_name.c_str () + << " find_by_primary_key (in " << key_name.c_str () + << " key)" << be_idt_nl + << "raises (Components::InvalidKey, Components::UnknownKeyValue, " + << "Components::FinderFailure);" << be_uidt; + + *os << be_nl << be_nl + << "void remove (in " << key_name.c_str () << " key)" << be_idt_nl + << "raises (Components::InvalidKey, Components::UnknownKeyValue, " + << "Components::RemoveFailure);" << be_uidt; + + *os << be_nl << be_nl + << key_name.c_str () << " get_primary_key (in " + << mng_name.c_str () << " comp);"; + } + + *os << be_uidt_nl + << "};"; + + // Create equivalent interface. + *os << be_nl << be_nl + << "interface " + << IdentifierHelper::try_escape (node->original_local_name ()).c_str () + << " : " + << node->original_local_name () << "Explicit, " + << node->original_local_name () << "Implicit" << be_nl + << "{" << be_nl + << "};"; + + return 0; +} + +int +idl3_to_idl2_visitor::visit_root (AST_Root *node) +{ + int status = be_global->outfile_init (this->os, + "", + "_IDL2.idl", + "_TAO_IDL_", + "_IDL_"); + + if (status == -1) + { + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("idl3_to_idl2_visitor::visit_root - ") + ACE_TEXT ("failed to initialize output file\n")), + -1); + } + + ACE_CString filename; + + for (size_t i = 0; i < idl_global->n_included_idl_files (); ++i) + { + if (i == 0) + { + *os << be_nl; + } + + ACE_CString raw_filename = idl_global->included_idl_files ()[i]; + bool excluded_file_found = + this->match_excluded_file (raw_filename.c_str ()); + + if (raw_filename.find (".pidl") != ACE_CString::npos + || raw_filename == "orb.idl" + || raw_filename == "Components.idl" + || excluded_file_found) + { + filename = raw_filename; + } + else + { + filename = + raw_filename.substr (0, raw_filename.rfind ('.')) + "_IDL2.idl"; + } + + *os << be_nl + << "#include \"" << filename.c_str () << "\""; + } + + const char *pfix = node->prefix (); + + if (ACE_OS::strcmp (pfix, "") != 0) + { + *os << be_nl << be_nl + << "#pragma prefix \"" << pfix << "\""; + } + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("idl3_to_idl2_visitor::visit_root - ") + ACE_TEXT ("codegen for scope failed\n")), + -1); + } + + *os << be_nl << be_nl + << "#endif /* ifndef */" << be_nl << be_nl; + + return 0; +} + +UTL_ScopedName * +idl3_to_idl2_visitor::create_scoped_name (const char *prefix, + const char *local_name, + const char *suffix, + AST_Decl *parent) +{ + ACE_CString local_string (prefix, + 0, + false); + local_string += local_name; + local_string += suffix; + Identifier *local_id = 0; + ACE_NEW_RETURN (local_id, + Identifier (local_string.fast_rep ()), + 0); + UTL_ScopedName *last_segment = 0; + ACE_NEW_RETURN (last_segment, + UTL_ScopedName (local_id, + 0), + 0); + UTL_ScopedName *full_name = + static_cast<UTL_ScopedName *> (parent->name ()->copy ()); + full_name->nconc (last_segment); + return full_name; +} + +void +idl3_to_idl2_visitor::tranfer_scope_elements (AST_Home *src, + AST_Interface &dst) +{ + // Transfer the elements of the home's scope to the temporary + // explicit home interface. + for (UTL_ScopeActiveIterator src_iter (src, UTL_Scope::IK_decls); + ! src_iter.is_done (); + src_iter.next ()) + { + AST_Decl *d = src_iter.item (); + d->set_defined_in (&dst); + UTL_ScopedName *new_name = + this->create_scoped_name (0, + d->local_name ()->get_string (), + 0, + &dst); + d->set_name (new_name); + dst.add_to_scope (d); + } + + // Visit the transferred scope elements normally to generate the IDL. + // This way referenced items will have the interface's name in the + // scoped name instead of the home's name. + for (UTL_ScopeActiveIterator dst_iter (&dst, UTL_Scope::IK_decls); + ! dst_iter.is_done (); + dst_iter.next ()) + { + if (dst_iter.item ()->ast_accept (this) != 0) + { + ACE_ERROR ((LM_ERROR, + "idl3_to_idl2_visitor::tranfer_scope_elements - " + "codegen for destination scope failed\n")); + } + } +} + +void +idl3_to_idl2_visitor::gen_factories (AST_Home *node, + AST_Interface &) +{ + AST_Operation **item = 0; + + for (ACE_Unbounded_Queue_Iterator<AST_Operation *> i (node->factories ()); + ! i.done (); + i.advance ()) + { + i.next (item); + + *os << be_nl << be_nl + << IdentifierHelper::orig_sn (node->managed_component ()->name ()).c_str () + << " " + << IdentifierHelper::try_escape ((*item)->original_local_name ()).c_str () + << " ("; + + this->gen_params (*item, (*item)->argument_count ()); + + *os << ")"; + + UTL_ExceptList *exceps = (*item)->exceptions (); + + if (exceps != 0 && exceps->length () > 0) + { + this->gen_exception_list (exceps, "", false); + } + else + { + *os << be_idt_nl + << "raises ("; + } + + *os << "Components::CreateFailure);" << be_uidt; + } +} + +void +idl3_to_idl2_visitor::gen_finders (AST_Home *node, + AST_Interface &) +{ + AST_Operation **item = 0; + + for (ACE_Unbounded_Queue_Iterator<AST_Operation *> i (node->finders ()); + ! i.done (); + i.advance ()) + { + i.next (item); + + *os << be_nl << be_nl + << IdentifierHelper::orig_sn (node->managed_component ()->name ()).c_str () + << " " + << IdentifierHelper::try_escape( (*item)->original_local_name ()).c_str () + << " ("; + + this->gen_params (*item, (*item)->argument_count ()); + + *os << ")"; + + UTL_ExceptList *exceps = (*item)->exceptions (); + + if (exceps != 0 && exceps->length () > 0) + { + this->gen_exception_list (exceps, "", false); + } + else + { + *os << be_idt_nl + << "raises ("; + } + + *os << "Components::FinderFailure);" << be_uidt; + } +} + diff --git a/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.h b/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.h new file mode 100644 index 00000000000..b489a8b3cd9 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_IDL2/idl3_to_idl2_visitor.h @@ -0,0 +1,79 @@ +// $Id$ + +/* -*- c++ -*- */ +// ============================================================================ +// +// = LIBRARY +// TAO_IDL3_TO_IDL2_BE_DLL +// +// = FILENAME +// idl3_to_idl2_visitor.h +// +// = DESCRIPTION +// Generates equivalent IDL2 from IDL3. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#ifndef TAO_IDL3_TO_IDL2_VISITOR_H +#define TAO_IDL3_TO_IDL2_VISITOR_H + +#include "basic_visitor.h" +#include "utl_scoped_name.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "TAO_IDL3_TO_IDL2_BE_Export.h" + +class TAO_IDL3_TO_IDL2_BE_Export idl3_to_idl2_visitor : public basic_visitor +{ + // + // = TITLE + // idl3_to_idl2_visitor. + // + // = DESCRIPTION + // IDL3 to IDL2 conversion visitor. The methods are + // not pure virtual to facilitate the implementation of some + // derived visitors that override only a few. + // +public: + idl3_to_idl2_visitor (void); + virtual ~idl3_to_idl2_visitor (void); + + virtual int visit_module (AST_Module *node); + virtual int visit_interface (AST_Interface *node); + virtual int visit_component (AST_Component *node); + virtual int visit_component_fwd (AST_ComponentFwd *node); + virtual int visit_provides (AST_Provides *node); + virtual int visit_uses (AST_Uses *node); + virtual int visit_publishes (AST_Publishes *node); + virtual int visit_emits (AST_Emits *node); + virtual int visit_consumes (AST_Consumes *node); + virtual int visit_extended_port (AST_Extended_Port *node); + virtual int visit_mirror_port (AST_Mirror_Port *node); + virtual int visit_connector (AST_Connector *node); + virtual int visit_instantiated_connector ( + AST_Instantiated_Connector *node); + virtual int visit_tmpl_port (AST_Tmpl_Port *node); + virtual int visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *node); + virtual int visit_eventtype (AST_EventType *node); + virtual int visit_eventtype_fwd (AST_EventTypeFwd *node); + virtual int visit_home (AST_Home *node); + virtual int visit_root (AST_Root *node); + +private: + UTL_ScopedName *create_scoped_name (const char *prefix, + const char *local_name, + const char *suffix, + AST_Decl *parent); + void tranfer_scope_elements (AST_Home *src, AST_Interface &dst); + void gen_factories (AST_Home *node, AST_Interface &xplicit); + void gen_finders (AST_Home *node, AST_Interface &xplicit); +}; + +#endif /* TAO_IDL3_TO_IDL2_VISITOR_H */ diff --git a/modules/CIAO/tools/IDL3_to_XMI/CIAO_IDL3_TO_XMI_Export.h b/modules/CIAO/tools/IDL3_to_XMI/CIAO_IDL3_TO_XMI_Export.h new file mode 100644 index 00000000000..d34de5bdfd3 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/CIAO_IDL3_TO_XMI_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl CIAO_IDL3_TO_XMI +// ------------------------------ +#ifndef CIAO_IDL3_TO_XMI_EXPORT_H +#define CIAO_IDL3_TO_XMI_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (CIAO_IDL3_TO_XMI_HAS_DLL) +# define CIAO_IDL3_TO_XMI_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && CIAO_IDL3_TO_XMI_HAS_DLL */ + +#if !defined (CIAO_IDL3_TO_XMI_HAS_DLL) +# define CIAO_IDL3_TO_XMI_HAS_DLL 1 +#endif /* ! CIAO_IDL3_TO_XMI_HAS_DLL */ + +#if defined (CIAO_IDL3_TO_XMI_HAS_DLL) && (CIAO_IDL3_TO_XMI_HAS_DLL == 1) +# if defined (CIAO_IDL3_TO_XMI_BUILD_DLL) +# define CIAO_IDL3_TO_XMI_Export ACE_Proper_Export_Flag +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CIAO_IDL3_TO_XMI_BUILD_DLL */ +# define CIAO_IDL3_TO_XMI_Export ACE_Proper_Import_Flag +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CIAO_IDL3_TO_XMI_BUILD_DLL */ +#else /* CIAO_IDL3_TO_XMI_HAS_DLL == 1 */ +# define CIAO_IDL3_TO_XMI_Export +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARATION(T) +# define CIAO_IDL3_TO_XMI_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CIAO_IDL3_TO_XMI_HAS_DLL == 1 */ + +// Set CIAO_IDL3_TO_XMI_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CIAO_IDL3_TO_XMI_NTRACE) +# if (ACE_NTRACE == 1) +# define CIAO_IDL3_TO_XMI_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CIAO_IDL3_TO_XMI_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CIAO_IDL3_TO_XMI_NTRACE */ + +#if (CIAO_IDL3_TO_XMI_NTRACE == 1) +# define CIAO_IDL3_TO_XMI_TRACE(X) +#else /* (CIAO_IDL3_TO_XMI_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CIAO_IDL3_TO_XMI_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CIAO_IDL3_TO_XMI_NTRACE == 1) */ + +#endif /* CIAO_IDL3_TO_XMI_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/IDL3_to_XMI/IDL3_TO_XMI.mpc b/modules/CIAO/tools/IDL3_to_XMI/IDL3_TO_XMI.mpc new file mode 100644 index 00000000000..8a927291c91 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/IDL3_TO_XMI.mpc @@ -0,0 +1,65 @@ +// -*- MPC -*- +// $Id$ + +project(CIAO_IDL3_TO_XMI_BE) : acelib, install, ciao_output, crosscompile, ciao_xml_utils, tao_idl_fe { + sharedname = CIAO_IDL3_TO_XMI_BE + dynamicflags = CIAO_IDL3_TO_XMI_BUILD_DLL + + // This is necessary for MPC to pull in rules.ciao.GNU + includes += $(CIAO_ROOT) + + Source_Files { + be_global.cpp + be_helper.cpp + be_init.cpp + be_produce.cpp + be_sunsoft.cpp + IDL3_to_XMI_visitor.cpp + IR_Simulator_visitor.cpp + Literals.cpp + identifier_helper.cpp + } + + Header_Files { + be_extern.h + be_global.h + be_helper.h + be_sunsoft.h + IDL3_to_XMI_visitor.h + CIAO_IDL3_TO_XMI_Export.h + } +} + +project(CIAO_IDL3_TO_XMI_EXE) : aceexe, install, ciao_output, crosscompile, ciao_xml_utils, tao_idl_mcpp, xerces, tao_idl_fe { + after += CIAO_IDL3_TO_XMI_BE + exename = tao_idl3_to_xmi + libs += CIAO_IDL3_TO_XMI_BE + includes += $(TAO_ROOT) . + exeout = $(CIAO_ROOT)/bin + + // Adding a strict ordering dependency with TAO_IDL_EXE. It appears on some systems, there + // can be a race between these two projects for tao_idl.cpp, causing some errors. + after += TAO_IDL_EXE + + // This is necessary for MPC to pull in rules.ciao.GNU + includes += $(CIAO_ROOT) + + verbatim(gnuace, local) { + ifeq ($(TAO_IDL_PREPROCESSOR),) + CPPFLAGS += -DTAO_IDL_PREPROCESSOR=\\\"$(strip $(CXX))\\\" + else + CPPFLAGS += -DTAO_IDL_PREPROCESSOR=\\\"$(subst \\,\\,$(TAO_IDL_PREPROCESSOR))\\\" + endif + + VPATH = $(TAO_ROOT)/TAO_IDL $(TAO_ROOT)/TAO_IDL/driver + } + + Source_Files { + $(TAO_ROOT)/TAO_IDL/driver/drv_args.cpp + $(TAO_ROOT)/TAO_IDL/tao_idl.cpp + } + + Header_Files { + $(TAO_ROOT)/TAO_IDL/include/drv_extern.h + } +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.cpp b/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.cpp new file mode 100644 index 00000000000..900e1086f8e --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.cpp @@ -0,0 +1,2688 @@ +// $Id$ + +#include "IDL3_to_XMI_visitor.h" +#include "identifier_helper.h" + +#include "be_sunsoft.h" +#include "be_extern.h" + +#include "ast_argument.h" +#include "ast_array.h" +#include "ast_attribute.h" +#include "ast_component_fwd.h" +#include "ast_provides.h" +#include "ast_uses.h" +#include "ast_publishes.h" +#include "ast_emits.h" +#include "ast_consumes.h" +#include "ast_enum.h" +#include "ast_enum_val.h" +#include "ast_eventtype.h" +#include "ast_eventtype_fwd.h" +#include "ast_exception.h" +#include "ast_factory.h" +#include "ast_field.h" +#include "ast_home.h" +#include "ast_operation.h" +#include "ast_root.h" +#include "ast_sequence.h" +#include "ast_string.h" +#include "ast_structure_fwd.h" +#include "ast_union.h" +#include "ast_union_branch.h" +#include "ast_union_fwd.h" +#include "ast_union_label.h" +#include "ast_valuebox.h" +#include "ast_valuetype_fwd.h" +#include "ast_native.h" +#include "utl_exceptlist.h" +#include "utl_identifier.h" +#include "utl_idlist.h" +#include "utl_string.h" +#include "global_extern.h" +#include "nr_extern.h" +#include "ace/OS_NS_stdio.h" +#include "ace/OS_NS_sys_time.h" +#include "ace/ACE.h" + +#include "Literals.h" +#include "XML/XercesString.h" + +#include <iostream> +#include <limits> +#include <sstream> + +#include "xercesc/dom/DOM.hpp" +#include "xercesc/util/XMLChar.hpp" + +#include "XML/XML_Helper.h" + +using XERCES_CPP_NAMESPACE::DOMDocument; +using XERCES_CPP_NAMESPACE::DOMAttr; +using XERCES_CPP_NAMESPACE::DOMElement; +using XERCES_CPP_NAMESPACE::DOMText; +using XERCES_CPP_NAMESPACE::DOMDocumentType; +using XERCES_CPP_NAMESPACE::XMLChar1_1; +using CIAO::XML::XStr; + +#if 0 +struct Foo { + std::string foo_; + Foo (const char *foo) : foo_ (foo) + { + std::cout << "Entering " << foo_ << std::endl; + } + ~Foo () + { + std::cout << "Leaving " << foo_ << std::endl; + } +}; + +#define XMI_TRACE(X) Foo _foobarbaz (X); +#else +#define XMI_TRACE(X) +#endif + +namespace CIAO +{ + namespace XMI + { + size_t idl3_to_xmi_visitor::current_id_ = 0; + + template <typename T> + ACE_TCHAR * + idl3_to_xmi_visitor::number_to_string (T val) + { + std::stringstream str; + + str << val; + + return ACE::strnew (ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + } + + template <> + ACE_TCHAR * + idl3_to_xmi_visitor::number_to_string (bool val) + { + if (val) + return ACE::strnew (LITERALS[CAPS_TRUE]); + else + return ACE::strnew (LITERALS[CAPS_FALSE]); + } + + template <> + ACE_TCHAR * + idl3_to_xmi_visitor::number_to_string (char val) + { + // There is no way to convert any char to xml encoding nicely + // so we convert it to a decimal integer. This will preserve at + // least a correct char value instead of some non-printable xml. + std::stringstream str; + + str << static_cast<unsigned int>(static_cast<unsigned char> (val)); + + return ACE::strnew (ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + } + + template <> + ACE_TCHAR * + idl3_to_xmi_visitor::number_to_string (wchar_t val) + { + // There is no way to convert any char to xml encoding nicely + // so we convert it to a decimal integer. This will preserve at + // least a correct char value instead of some non-printable xml. + std::stringstream str; + + str << static_cast<unsigned long>(static_cast<wchar_t> (val)); + + return ACE::strnew (ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + } + + idl3_to_xmi_visitor::idl3_to_xmi_visitor (bool skip_imported) + : dom_ (0), + root_ (0), + generalizations_ (0), + associations_ (0), + base_id_ (idl3_to_xmi_visitor::gen_xmi_id ()), + skip_imported_ (skip_imported), + visiting_enum_ (false), + union_disc_ (0) + { + } + + idl3_to_xmi_visitor::~idl3_to_xmi_visitor (void) + { + } + + int + idl3_to_xmi_visitor::visit_decl (AST_Decl *) + { + XMI_TRACE ("got a decl"); + return 0; + } + + char * + copy_scoped_name (UTL_ScopedName *name) + { + ACE_CString fullname; + for (UTL_ScopedNameActiveIterator si (name); + !si.is_done (); + si.next ()) + { + Identifier *item = si.item (); + fullname += item->get_string (); + } + + return fullname.rep (); + } + + int + idl3_to_xmi_visitor::visit_scope (UTL_Scope *node) + { + XMI_TRACE ("got a scope"); + + this->order_ = 0; + + for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); + !si.is_done (); + si.next ()) + { + AST_Decl *d = si.item (); + d->ast_accept (this); + ++this->order_; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_type (AST_Type *) + { + XMI_TRACE ("got a type"); + return 0; + } + + int + idl3_to_xmi_visitor::visit_predefined_type (AST_PredefinedType *node) + { + XMI_TRACE ("predef type"); + + char const *local_name = 0; + switch (node->pt ()) + { + case AST_PredefinedType::PT_pseudo: + // Only a limited number of predefined pseudo types + // needs our attention. + local_name = node->original_local_name ()->get_string (); + if (ACE_OS::strcmp (local_name, "TypeCode") == 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_TC]); + } + default: + break; + } + return 0; + } + + int + idl3_to_xmi_visitor::visit_module (AST_Module *node) + { + XMI_TRACE ("module"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) == 0) + { + // If the module is reopened then put it on the stack. + NS_Guard ns_guard (ec.ns_.c_str (), this); + ES_Guard owned_guard (ec.elem_, this); + this->visit_scope (node); + // And don't do anything more. + return 0; + } + + ES_Guard package_guard (LITERALS[PACKAGE_TAG], this); + this->gen_common_elements (node, LITERALS[ST_MODULE]); + + { + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + ES_Guard owned_guard (LITERALS[OWNEDELEMENT_TAG], this); + + // Save ownedElement to add to it later if the module + // will be reopened. + this->stack_.top (ec.elem_); + // Same save namespace string. + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + + this->visit_scope (node); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_interface (AST_Interface *node) + { + XMI_TRACE ("interface"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_INTF]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + { // Operations. + ES_Guard owned_guard (LITERALS[OWNEDELEMENT_TAG], this); + this->cached_type_ = node; + this->visit_scope (node); + this->cached_type_ = 0; + } + + // Inheritance + for (long i = 0; i < node->n_inherits (); ++i) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->inherits ()[i]->repoID ()))); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_interface_fwd (AST_InterfaceFwd *node) + { + XMI_TRACE ("interface_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_INTF]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_template_interface ( + AST_Template_Interface *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_valuebox (AST_ValueBox *node) + { + XMI_TRACE ("valuebox"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_BOXVALUE]); + + // add a generalization for the value we box + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->boxed_type ()->repoID ()))); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + idl3_to_xmi_visitor::visit_valuetype_impl (AST_ValueType *node) + { + try + { + // isAbstract + if (node->is_abstract ()) + { + this->set_attribute (LITERALS[ABSTRACT], LITERALS[_TRUE]); + } + else + { + this->set_attribute (LITERALS[ABSTRACT], LITERALS[_FALSE]); + } + + if (node->inherits_concrete () != 0) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->inherits_concrete ()->repoID ()))); + } + + for (long i = 0; i < node->n_supports (); ++i) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->supports ()[i]->repoID ()))); + } + + /* NOTE: CDMW XMI generator ignores supports specifications. + // Supports + if (node->n_supports () != 0) + throw Error ("ValueTypes which support are not currently supported.", node); + */ + + ES_Guard oe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + this->cached_type_ = node; + this->visit_scope (node); + this->cached_type_ = 0; + } + catch (Error &err) + { + err.node (node); + throw; + } + } + + int + idl3_to_xmi_visitor::visit_valuetype (AST_ValueType *node) + { + XMI_TRACE ("valuetype"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_VALUE]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + this->visit_valuetype_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_valuetype_fwd (AST_ValueTypeFwd *node) + { + XMI_TRACE ("valuetype_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_VALUE]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_eventtype (AST_EventType *node) + { + XMI_TRACE ("eventtype"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_EVENT]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + this->visit_valuetype_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_eventtype_fwd (AST_EventTypeFwd *node) + { + XMI_TRACE ("eventtype_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_EVENT]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_component (AST_Component *node) + { + XMI_TRACE ("component"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_COMP]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + for (long i = 0; i < node->n_supports (); ++i) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->supports ()[i]->repoID ()))); + + } + + if (node->base_component () != 0) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->base_component ()->repoID ()))); + } + + ES_Guard oe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + this->cached_type_ = node; + this->visit_scope (node); + this->cached_type_ = 0; + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_component_fwd (AST_ComponentFwd *node) + { + XMI_TRACE ("component_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_COMP]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_provides (AST_Provides *node) + { + this->add_port (LITERALS[ST_PROVIDES], node); + return 0; + } + + int + idl3_to_xmi_visitor::visit_uses (AST_Uses *node) + { + this->add_port (LITERALS[ST_USES], node); + return 0; + } + + int + idl3_to_xmi_visitor::visit_publishes (AST_Publishes *node) + { + this->add_port (LITERALS[ST_PUBLISH], node); + return 0; + } + + int + idl3_to_xmi_visitor::visit_emits (AST_Emits *node) + { + this->add_port (LITERALS[ST_EMITS], node); + return 0; + } + + int + idl3_to_xmi_visitor::visit_consumes (AST_Consumes *node) + { + this->add_port (LITERALS[ST_CONSUMES], node); + return 0; + } + + int + idl3_to_xmi_visitor::visit_porttype (AST_PortType *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_extended_port (AST_Extended_Port *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_mirror_port (AST_Mirror_Port *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_connector (AST_Connector *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_instantiated_connector ( + AST_Instantiated_Connector *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_tmpl_port (AST_Tmpl_Port *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *) + { + return 0; + } + + int + idl3_to_xmi_visitor::visit_home (AST_Home *node) + { + XMI_TRACE ("home"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ES_Guard es_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_HOME]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + for (long i = 0; i < node->n_supports (); ++i) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->supports ()[i]->repoID ()))); + } + + if (node->base_home () != 0) + { + XStr xid (this->add_generalization ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->base_home ()->repoID ()))); + } + + if (node->factories ().size () != 0) + { + ES_Guard noe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + for (size_t i = 0; i < node->factories ().size (); ++i) + { + AST_Operation **op = 0; + node->factories ().get (op, i); + this->visit_operation_impl (*op, LITERALS[ST_HFACT]); + } + } + + if (node->finders () .size () != 0) + { + throw Error ("home finders not supported", node); + } + + this->add_managed_component ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + ACE_TEXT_CHAR_TO_TCHAR (node->managed_component ()->repoID ())); + + ES_Guard noe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + // attributes in scope. + this->cached_type_ = node; + this->visit_scope (node); + this->cached_type_ = 0; + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_factory (AST_Factory *node) + { + XMI_TRACE ("factory"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + throw Error ("Factories not supported", node); + + return 0; + } + + void + idl3_to_xmi_visitor::visit_struct_impl (AST_Structure *node) + { + try + { + ES_Guard ns_oe_guard (LITERALS[OWNEDELEMENT_TAG], this); + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + } + + int + idl3_to_xmi_visitor::visit_structure (AST_Structure *node) + { + XMI_TRACE ("structure"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_STRUCT]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + this->visit_struct_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_structure_fwd (AST_StructureFwd *node) + { + XMI_TRACE ("structure_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_STRUCT]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_exception (AST_Exception *node) + { + XMI_TRACE ("exception"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[EXCEPTION_TAG], this); + this->gen_common_elements (node, LITERALS[ST_EX]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + + this->visit_struct_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_expression (AST_Expression *) + { + XMI_TRACE ("expression"); + + // we don't particularly care about expressions. + + return 0; + } + + int + idl3_to_xmi_visitor::visit_enum (AST_Enum *node) + { + XMI_TRACE ("enum"); + + if (this->skip_imported_ && node->imported ()) + { + this->visit_scope (node); + return 0; + } + + try + { + ES_Guard es_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_ENUM]); + + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + ES_Guard oe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + this->visiting_enum_ = true; + this->visit_scope (node); + this->visiting_enum_ = false; + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + idl3_to_xmi_visitor::visit_operation_impl (AST_Operation *op, + const ACE_TCHAR *stereotype) + { + XMI_TRACE ("operation"); + + if (this->skip_imported_ && op->imported ()) + { + this->visit_scope (op); + return; + } + + // This is a mess because the operation has so many special cases.... + try + { + ES_Guard op_guard (LITERALS[OP_TAG], this); + + // name and visiblity + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (op->original_local_name ()->get_string ())); + + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + + this->set_containing_element (LITERALS[OWNER]); + + // If we have a stereotype, set it + if (stereotype != 0) + { + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + stereotype); + } + + // XMI ID + this->create_and_store_xmi_id (op); + + // while not strictly a namespace, the repo id goes on the + // namespace stack as the owner of contained elements. + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (op->repoID ()), this); + + { // we need to generate the tagged value in a custom way here + ES_Guard me_guard (LITERALS[ME_TV_TAG], this); + + { + ES_Guard tv_guard (LITERALS[TV_TAG], this); + this->set_attribute (LITERALS[TAG], LITERALS[TYPEID]); + this->set_attribute (LITERALS[VALUE], + ACE_TEXT_CHAR_TO_TCHAR (op->repoID ())); + } + + UTL_ExceptList *exceptions = op->exceptions (); + + if (exceptions != 0 && exceptions->length () > 0) + { + for (UTL_ExceptlistActiveIterator ei (exceptions); + !ei.is_done (); + ei.next ()) + { + ES_Guard tv_guard (LITERALS[TV_TAG], this); + this->set_attribute (LITERALS[TAG], LITERALS[RAISES]); + this->set_attribute ( + LITERALS[VALUE], + ACE_TEXT_CHAR_TO_TCHAR (ei.item ()->full_name ())); + } + } + } + + ES_Guard bfp_guard (LITERALS[BFP_TAG], this); + + // return value + { + ES_Guard param_guard (LITERALS[PARAM_TAG], this); + + // I don't think anything else can refer to the parameter by + // xid, so I won't store it. + XStr xid = this->gen_xmi_id (op); + + this->set_attribute (LITERALS[XMI_ID], xid); + + this->set_attribute (LITERALS[KIND], LITERALS[RETURN]); + + this->set_containing_element (LITERALS[BFEATURE]); + + xid = this->lookup_type_xid (op->return_type ()); + this->set_attribute (LITERALS[TYPE], + xid); + } + + if (op->argument_count () != 0) + { + // Visit arguments + for (UTL_ScopeActiveIterator si (op, UTL_Scope::IK_decls); + !si.is_done ();) + { + si.item ()->ast_accept (this); + si.next (); + } + } + } + catch (Error &err) + { + err.node (op); + throw; + } + } + + int + idl3_to_xmi_visitor::visit_operation (AST_Operation *op) + { + XMI_TRACE ("operation"); + + this->visit_operation_impl (op, 0); + + return 0; + } + + int + idl3_to_xmi_visitor::visit_field (AST_Field *node) + { + XMI_TRACE ("field"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard attr_guard (LITERALS[ATTR_TAG], this); + + if (node->field_type ()->node_type () == AST_Decl::NT_sequence) + { + AST_Sequence* sequence = + AST_Sequence::narrow_from_decl (node->field_type ()); + sequence->ast_accept (this); + // There is no need to proceed any further. + return 0; + } + else if (node->field_type ()->node_type () == AST_Decl::NT_array) + { + AST_Array* array = + AST_Array::narrow_from_decl (node->field_type ()); + array->ast_accept (this); + // There is no need to proceed any further. + return 0; + } + + // I don't think anything else can refer to the parameter by + // xid, so I won't store it. + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + + switch (node->visibility ()) + { + case AST_Field::vis_NA: + case AST_Field::vis_PUBLIC: + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + break; + case AST_Field::vis_PRIVATE: + this->set_attribute (LITERALS[VISIBIL], LITERALS[_PRIVATE]); + break; + default: + throw Error ("unknown visibility type detected.", node); + } + + // I think this is fixed. + this->set_attribute (LITERALS[MULT], LITERALS[MULT_OTO]); + + this->set_containing_element (LITERALS[OWNER]); + + xid = this->lookup_type_xid (node->field_type ()); + this->set_attribute (LITERALS[TYPE], + xid); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_argument (AST_Argument *node) + { + XMI_TRACE ("argument"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard param_guard (LITERALS[PARAM_TAG], this); + + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + + // I don't think anything else can refer to the parameter by + // xid, so I won't store it. + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + + // kind + switch (node->direction ()) + { + case AST_Argument::dir_IN: + this->set_attribute (LITERALS[KIND], LITERALS[_IN]); + break; + + case AST_Argument::dir_INOUT: + this->set_attribute (LITERALS[KIND], LITERALS[INOUT]); + break; + + case AST_Argument::dir_OUT: + this->set_attribute (LITERALS[KIND], LITERALS[_OUT]); + break; + + default: + throw Error ("Unknown argument direction", node); + } + + this->set_containing_element (LITERALS[BFEATURE]); + + xid = this->lookup_type_xid (node->field_type ()); + this->set_attribute (LITERALS[TYPE], + xid); + + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_attribute (AST_Attribute *node) + { + XMI_TRACE ("attribute"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + if (this->cached_type_ == 0) + { + ACE_ERROR ((LM_ERROR, "Zounds! %d\n", + this->cached_type_)); + throw Error ("Internal error - attribute expected " + "to have a cached type, but didn't"); + } + + try + { + // *** + NS_Guard global_ns (ACE_TEXT ("::"), this); + ES_Guard assoc_group (this->associations_, this); + ES_Guard assoc_g (LITERALS[ASSOC_TAG], this); + + // I don't think anything else can refer to the attribute by + // xid, so I won't store it. + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->set_containing_element (LITERALS[NS]); + + if (node->readonly ()) + { + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + LITERALS[ST_RO]); + } + + ES_Guard assoc_conn (LITERALS[ASSOC_CONN_TAG], this); + + { // Containing type + ES_Guard assoc_end (LITERALS[ASSOC_END_TAG], this); + this->set_attribute (LITERALS[MULT], ACE_TEXT ("1")); + this->find_and_set_xid_as_attr ( + LITERALS[TYPE], + ACE_TEXT_CHAR_TO_TCHAR (this->cached_type_->repoID ())); + } + + { + ES_Guard assoc_end (LITERALS[ASSOC_END_TAG], this); + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + this->set_attribute (LITERALS[MULT], ACE_TEXT ("1")); + xid = this->lookup_type_xid (node->field_type ()); + this->set_attribute (LITERALS[TYPE], xid); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_union (AST_Union *node) + { + XMI_TRACE ("union"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_UNION]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + + ES_Guard class_guard (ec.elem_, this); + NS_Guard ns_guard (ec.ns_.c_str (), this); + ES_Guard oe_guard (LITERALS[OWNEDELEMENT_TAG], this); + + // Set discriminator type + this->union_disc_ = node->disc_type (); + this->visit_scope (node); + this->union_disc_ = 0; + } + catch (Error &err) + { + this->union_disc_ = 0; + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_union_fwd (AST_UnionFwd *node) + { + XMI_TRACE ("union_fwd"); + + try + { + ElementContext ec; + if (this->repo_id_map_.find (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec) != 0) + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + this->gen_common_elements (node, LITERALS[ST_UNION]); + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + + // Save in order not to generate same element later. + this->stack_.top (ec.elem_); + this->namespace_.top (ec.ns_); + this->repo_id_map_.bind (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), ec); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_union_branch (AST_UnionBranch *node) + { + XMI_TRACE ("union_branch"); + + try + { + ES_Guard attr_guard (LITERALS[ATTR_TAG], this); + + // I don't think anything else can refer to the parameter by + // xid, so I won't store it. + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + + // name + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + + // visiblity + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + + this->set_containing_element (LITERALS[OWNER]); + + // I think this is fixed. + this->set_attribute (LITERALS[MULT], LITERALS[MULT_ZTO]); + + xid = this->lookup_type_xid (node->field_type ()); + this->set_attribute (LITERALS[TYPE], + xid); + + { + ES_Guard me_tv_guard (LITERALS[ME_TV_TAG], this); + + { + ES_Guard tv_guard (LITERALS[TV_TAG], this); + this->set_attribute (LITERALS[TAG], LITERALS[IDLORDER]); + + // convert the order value to a string + // need a buffer, with a little safety padding + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer + (this->number_to_string (this->order_)); + + this->set_attribute (LITERALS[VALUE], buffer.get ()); + } + + for (unsigned long i = 0; i < node->label_list_length (); ++i) + { + this->visit_union_label (node->label (i)); + } + + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + ACE_TCHAR * + idl3_to_xmi_visitor::union_label_value (AST_Expression *exp) + { + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer; + + // @@TODO: Yuck, there has got to be a better way.... + AST_Expression::AST_ExprValue *ev = exp->ev (); + + if (exp->ec () != AST_Expression::EC_symbol || + this->union_disc_->node_type () == AST_Decl::NT_typedef || + this->union_disc_->node_type () == AST_Decl::NT_pre_defined) + { + /*AST_Expression::ExprType type; + + if (this->union_disc_->node_type () == AST_Decl::NT_typedef) + { + AST_Typedef *td (AST_Typedef::narrow_from_decl (this->union_disc_)); + type = td->base_type ()->node_type (); + } + else type = ev->et;*/ + + // Decode the type + switch (ev->et) + { + case AST_Expression::EV_long: + buffer.reset (this->number_to_string (ev->u.lval)); + break; + case AST_Expression::EV_ulong: + buffer.reset (this->number_to_string (ev->u.ulval)); + break; + case AST_Expression::EV_short: + buffer.reset (this->number_to_string (ev->u.sval)); + break; + case AST_Expression::EV_ushort: + buffer.reset (this->number_to_string (ev->u.usval)); + break; + case AST_Expression::EV_bool: + buffer.reset (this->number_to_string (ev->u.bval)); + break; + case AST_Expression::EV_char: + buffer.reset (this->number_to_string (ev->u.cval)); + break; + default: + throw Error ("Unknown union union label type"); + } + } + else + { + AST_Enum *desc (0); + + if ((desc = AST_Enum::narrow_from_decl (this->union_disc_)) == 0) + { + throw Error ("Descriminator type is not an enum"); + } + + AST_Decl *ev_decl = + desc->lookup_by_name (exp->n (), 1); + + if (ev_decl == 0) + { + throw Error ("Couldn't look up enum name"); + } + + AST_EnumVal *ev = AST_EnumVal::narrow_from_decl (ev_decl); + + if (ev == 0) + { + throw Error ("Couldn't look up enum name"); + } + + buffer.reset (ACE::strnew (ACE_TEXT_CHAR_TO_TCHAR (ev->full_name ()))); + //const char *name = desc->lookup_by_value (exp)->full_name (); + // const char *name = exp->n (); + //buffer.reset (copy_scoped_name (exp->n ())); + } + + if (buffer.get () == 0) + { + throw Error ("Unable to parse union label"); + } + + return buffer.release (); + } + + int + idl3_to_xmi_visitor::visit_union_label (AST_UnionLabel *node) + { + XMI_TRACE ("union_label"); + + ES_Guard tv_guard (LITERALS[TV_TAG], this); + this->set_attribute (LITERALS[TAG], LITERALS[CASE]); + + if (node->label_kind () == AST_UnionLabel::UL_default) + { + this->set_attribute (LITERALS[VALUE], + LITERALS[DEFAULT_UNION]); + } + else + { + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer ( + this->union_label_value (node->label_val ())); + + this->set_attribute (LITERALS[VALUE], buffer.get ()); + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_constant (AST_Constant *node) + { + XMI_TRACE ("constant"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard attr_guard (LITERALS[ATTR_TAG], this); + + this->set_attribute (LITERALS[OWNER_SCOPE], LITERALS[CLASSIFIER]); + this->set_attribute (LITERALS[CHANGEABLE], LITERALS[FROZEN]); + this->gen_common_elements (node, LITERALS[ST_CONST]); + + // Constant type + const ACE_TCHAR *exprtype (0); + AST_Expression::AST_ExprValue *val + (node->constant_value ()->ev ()); + + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> str_value; + + switch (node->et ()) + { + case AST_Expression::EV_short: + exprtype = LITERALS[ST_SHORT]; + str_value.reset (this->number_to_string (val->u.sval)); + break; + case AST_Expression::EV_ushort: + exprtype = LITERALS[ST_US]; + str_value.reset (this->number_to_string (val->u.usval)); + break; + case AST_Expression::EV_long: + exprtype = LITERALS[ST_LONG]; + str_value.reset (this->number_to_string (val->u.lval)); + break; + case AST_Expression::EV_ulong: + exprtype = LITERALS[ST_UL]; + str_value.reset (this->number_to_string (val->u.ulval)); + break; + case AST_Expression::EV_longlong: + exprtype = LITERALS[ST_LL]; + str_value.reset (this->number_to_string (val->u.llval)); + case AST_Expression::EV_ulonglong: + exprtype = LITERALS[ST_ULL]; + str_value.reset (this->number_to_string (val->u.ullval)); + break; + case AST_Expression::EV_float: + exprtype = LITERALS[ST_FLOAT]; + str_value.reset (this->number_to_string (val->u.fval)); + break; + case AST_Expression::EV_double: + exprtype = LITERALS[ST_DOUBLE]; + str_value.reset (this->number_to_string (val->u.dval)); + break; + case AST_Expression::EV_longdouble: + exprtype = LITERALS[ST_LD]; + str_value.reset (this->number_to_string (val->u.dval)); + break; + case AST_Expression::EV_char: + exprtype = LITERALS[ST_CHAR]; + str_value.reset (this->number_to_string (val->u.cval)); + break; + case AST_Expression::EV_wchar: + exprtype = LITERALS[ST_WCHAR]; + str_value.reset (this->number_to_string (val->u.wcval)); + break; + case AST_Expression::EV_octet: + exprtype = LITERALS[ST_OCTET]; + str_value.reset (this->number_to_string (val->u.dval)); + break; + case AST_Expression::EV_bool: + exprtype = LITERALS[ST_BOOL]; + str_value.reset (this->number_to_string (val->u.bval)); + break; + case AST_Expression::EV_string: + exprtype = LITERALS[ST_STR]; + str_value.reset (ACE::strnew ( + ACE_TEXT_CHAR_TO_TCHAR (val->u.strval->get_string ()))); + break; + case AST_Expression::EV_wstring: + exprtype = LITERALS[ST_WSTR]; + str_value.reset (ACE::strnew ( + ACE_TEXT_CHAR_TO_TCHAR (val->u.wstrval))); + break; + case AST_Expression::EV_enum: + { + UTL_Scope *s = node->defined_in (); + AST_Decl *d = + s->lookup_by_name (node->constant_value ()->n (), 1); + exprtype = ACE_TEXT_CHAR_TO_TCHAR ( + ScopeAsDecl (d->defined_in ())->repoID ()); + str_value.reset (ACE::strnew ( + ACE_TEXT_CHAR_TO_TCHAR (d->full_name ()))); + } + break; + + default: + throw Error ("Unsupported constant type", node); + } + + // type attribute + XStr xid (this->lookup_xid (exprtype)); + this->set_attribute (LITERALS[TYPE], + xid); + + { + ES_Guard me_tv (LITERALS[ME_TV_TAG], this); + { + ES_Guard tv (LITERALS[TV_TAG], this); + this->set_attribute (LITERALS[TAG], LITERALS[INIT_VAL]); + this->set_attribute (LITERALS[VALUE], str_value.get ()); + } + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_enum_val (AST_EnumVal *node) + { + XMI_TRACE ("enum val"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + if (!this->visiting_enum_) + { + // It makes sence only to process enumvals in enum "scope". + return 0; + } + + try + { + ES_Guard att_guard (LITERALS[ATTR_TAG], this); + + this->create_and_store_xmi_id ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), + node); + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + + // I think this is fixed. + this->set_attribute (LITERALS[MULT], LITERALS[MULT_OTO]); + this->set_containing_element (LITERALS[OWNER]); + + ES_Guard me_guard (LITERALS[ME_TV_TAG], this); + ES_Guard tv_guard (LITERALS[TV_TAG], this); + + this->set_attribute (LITERALS[TAG], LITERALS[IDLORDER]); + + // convert the enum value to a string + // need a buffer, with a little safety padding + + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer + (this->number_to_string (node->constant_value ()->ev ()->u.eval)); + + this->set_attribute (LITERALS[VALUE], buffer.get ()); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_array (AST_Array *node) + { + XMI_TRACE ("array val"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + this->gen_common_elements (node, + LITERALS[ST_ARR]); + + this->gen_array_associations (node, node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + idl3_to_xmi_visitor::gen_array_associations (AST_Decl *node, + AST_Array *array) + { + // <UML:Namespace.ownedElement> + NS_Guard global_ns (ACE_TEXT ("::"), this); + + // <UML:Association xmi.id="xmi.1210085542354" + // visibility="public" namespace="xmi.1210085542350"> + ES_Guard assoc_group (this->associations_, this); + ES_Guard assoc_g (LITERALS[ASSOC_TAG], this); + + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->set_containing_element (LITERALS[NS]); + + // <UML:Association.connection> + ES_Guard assoc_conn (LITERALS[ASSOC_CONN_TAG], this); + + { + // <UML:AssociationEnd multiplicity="0..1" type="xmi.1210085542353"> + ES_Guard assocend (LITERALS[ASSOC_END_TAG], this); + + this->set_attribute (LITERALS[MULT], LITERALS[MULT_ZTO]); + + xid = this->lookup_xid (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ())); + this->set_attribute (LITERALS[TYPE], xid); + + // <UML:AssociationEnd.qualifier> + ES_Guard assoc_qual (LITERALS[ASSOC_END_QUAL_TAG], this); + + for (unsigned long i = 0; + array != 0 && i < array->n_dims (); + ++i) + { + // <UML:Attribute xmi.id="xmi.1210085542355" + // name="index0" type='xmi.1210085542329'> + // N.B. that type is long. + ES_Guard attr (LITERALS[ATTR_TAG], this); + + xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + + std::stringstream str; + str << LITERALS[INDEX]; + str << i; + + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + xid = this->lookup_xid (LITERALS[ST_LONG]); + this->set_attribute (LITERALS[TYPE], xid); + + // <UML:ModelElement.constraint> + ES_Guard me_c (LITERALS[ME_CONS_TAG], this); + + // <UML:Constraint xmi.id="xmi.1210085542356"> + ES_Guard cons (LITERALS[CONSTRAINT], this); + + xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + + // <UML:ModelElement.taggedValue> + ES_Guard me_tv (LITERALS[ME_TV_TAG], this); + + // <UML:TaggedValue tag="constraintUpperValue" value="4"/> + ES_Guard tv (LITERALS[TV_TAG], this); + + this->set_attribute (LITERALS[TAG], LITERALS[CONST_UPPER]); + + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer ( + this->number_to_string (array->dims ()[i]->ev ()->u.ulval)); + + this->set_attribute (LITERALS[VALUE], buffer.get ()); + } + } + + // <UML:AssociationEnd multiplicity="1..1" + // type="xmi.1210085542346"/> - type is Char for this IDL + ES_Guard assoc_end (LITERALS[ASSOC_END_TAG], this); + this->set_attribute (LITERALS[MULT], LITERALS[MULT_OTO]); + + XStr arr_type = this->lookup_type_xid (array->base_type ()); + this->set_attribute (LITERALS[TYPE], arr_type); + } + + int + idl3_to_xmi_visitor::visit_sequence (AST_Sequence *node) + { + XMI_TRACE ("sequence val"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + this->gen_common_elements (node, + LITERALS[ST_SEQ]); + + // Generate the bounds and type on the sequence, which is an + // association in the association tree. + this->gen_sequence_associations (node, node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + idl3_to_xmi_visitor::gen_sequence_associations (AST_Decl *node, + AST_Sequence *sequence) + { + // <UML:Namespace.ownedElement> + NS_Guard global_ns (ACE_TEXT ("::"), this); + + // <UML:Association xmi.id="xmi.1210085542354" + // visibility="public" namespace="xmi.1210085542350"> + ES_Guard assoc_group (this->associations_, this); + ES_Guard assoc_g (LITERALS[ASSOC_TAG], this); + + XStr xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->set_containing_element (LITERALS[NS]); + + // <UML:Association.connection> + ES_Guard assoc_conn (LITERALS[ASSOC_CONN_TAG], this); + + { + // <UML:AssociationEnd multiplicity="0..1" type="xmi.1210085542353"> + ES_Guard assocend (LITERALS[ASSOC_END_TAG], this); + + this->set_attribute (LITERALS[MULT], LITERALS[MULT_ZTO]); + + xid = this->lookup_xid (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ())); + this->set_attribute (LITERALS[TYPE], xid); + + // <UML:AssociationEnd.qualifier> + ES_Guard assoc_qual (LITERALS[ASSOC_END_QUAL_TAG], this); + + ES_Guard attr (LITERALS[ATTR_TAG], this); + + xid = this->gen_xmi_id (node); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[NAME], LITERALS[INDEX]); + xid = this->lookup_xid (LITERALS[ST_LONG]); + this->set_attribute (LITERALS[TYPE], xid); + + ES_Guard me_c (LITERALS[ME_CONS_TAG], this); + ES_Guard cons (LITERALS[CONSTRAINT], this); + ES_Guard me_tv (LITERALS[ME_TV_TAG], this); + ES_Guard tv (LITERALS[TV_TAG], this); + + this->set_attribute (LITERALS[TAG], LITERALS[CONST_UPPER]); + + // @@TODO: need to extract bound from node. + if (sequence->unbounded ()) + { + this->set_attribute (LITERALS[VALUE], + LITERALS[UNBOUNDED_SEQ]); + } + else + { // bounded sequence + // convert the array bound to a string + // need a buffer, with a little safety padding + ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> buffer ( + this->number_to_string (sequence->max_size ()->ev ()->u.ulval)); + + this->set_attribute (LITERALS[VALUE], buffer.get ()); + } + } + + // <UML:AssociationEnd multiplicity="1..1" + // type="xmi.1210085542346"/> - type is Char for this IDL + ES_Guard assoc_end (LITERALS[ASSOC_END_TAG], this); + this->set_attribute (LITERALS[MULT], LITERALS[MULT_OTO]); + + XStr seq_type = this->lookup_type_xid (sequence->base_type ()); + this->set_attribute (LITERALS[TYPE], seq_type); + } + + int + idl3_to_xmi_visitor::visit_string (AST_String *) + { + XMI_TRACE ("string"); + return 0; + } + + int + idl3_to_xmi_visitor::visit_typedef (AST_Typedef *node) + { + XMI_TRACE ("typedef"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + + // Anonymous Sequences and arrays appear to be a special case + AST_Decl *base (node->base_type ()); + if (base->node_type () == AST_Decl::NT_sequence) + { + this->gen_common_elements (node, LITERALS[ST_SEQ]); + + AST_Sequence* sequence = + AST_Sequence::narrow_from_decl (base); + this->gen_sequence_associations (node, sequence); + } + else if (base->node_type () == AST_Decl::NT_array) + { + this->gen_common_elements (node, LITERALS[ST_ARR]); + + AST_Array* array = + AST_Array::narrow_from_decl (base); + this->gen_array_associations (node, array); + } + else + { + this->gen_common_elements (node, + LITERALS[ST_TYPEDEF]); + + // Generalization. Assignment required for memory management. + XStr xid = this->add_generalization (node, + node->base_type ()); + ACE_UNUSED_ARG (xid); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + idl3_to_xmi_visitor::visit_root (AST_Root *node) + { + XMI_TRACE ("root"); + try + { + ACE_CString fn; + + if ((fn = be_global->filename ()) == "") + { + fn = idl_global->stripped_filename ()->get_string (); + fn = fn.substr (0, fn.rfind ('.')); + fn += ".xmi"; + } + + const char *path = be_global->output_dir (); + ACE_CString target_name; + + if (path != 0) + { + target_name = path; + target_name += "/"; + } + + target_name += fn; + + CIAO::XML::NoOp_Resolver res_func; + CIAO::XML::XML_Schema_Resolver<> resolver (res_func); + CIAO::XML::XML_Error_Handler handler; + CIAO::XML::XML_Helper<> helper (resolver, handler); + + // Create XML document + std::auto_ptr<DOMDocumentType> doctype ( + helper.create_doctype (ACE_TEXT("XMI"), + 0, + ACE_TEXT_CHAR_TO_TCHAR (be_global->dtd ()))); + + if ((this->dom_ = helper.create_dom (ACE_TEXT("XMI"), + ACE_TEXT(""), + doctype.get ())) == 0) + ACE_ERROR_RETURN ((LM_ERROR, "Unable to create XML document."), -1); + + this->root_ = this->dom_->getDocumentElement (); + + this->stack_.push (this->root_); + + this->set_attribute (LITERALS[VERSION_TAG], + LITERALS[VERSION_VALUE]); + + this->set_attribute (LITERALS[NS_TAG], + LITERALS[NS_VALUE]); + + DOMElement *tmp = 0; + + // Pregenerate stereotypes to cache xmi.ids. + DOMElement *stereotypes = this->generate_stereotypes (); + + // Create XMI header + { + ES_Guard ht_g (LITERALS[HEADER_TAG], this); + ES_Guard d_t (LITERALS[DOC_TAG], this); + ES_Guard e_t (LITERALS[EXPORTER_TAG], this); + this->add_text (LITERALS[EXPORTER_VALUE]); + } + + this->stack_.push (this->create_element (LITERALS[CONTENT_TAG])); + this->stack_.push (this->create_element (LITERALS[MODEL_TAG])); + + // Store the base model xid + this->set_attribute (LITERALS[XMI_ID], this->base_id_); + this->id_map_.bind (ACE_TEXT ("::"), this->base_id_); + + + // Global namespace + this->stack_.push (this->create_element (LITERALS[OWNEDELEMENT_TAG])); + this->namespace_.push (ACE_TEXT ("::")); + + // Create generalizations and associations elements, but don't join + // them to the tree yet + this->associations_ = + this->dom_->createElement (XStr (LITERALS[OWNEDELEMENT_TAG])); + this->generalizations_ = + this->dom_->createElement (XStr (LITERALS[OWNEDELEMENT_TAG])); + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_root - " + "codegen for scope failed\n"), + -1); + } + + this->stack_.pop (tmp); + + this->stack_.top (tmp); + + tmp->appendChild (this->generalizations_); + tmp->appendChild (this->associations_); + tmp->appendChild (stereotypes); + + helper.write_DOM (this->dom_, + ACE_TEXT_CHAR_TO_TCHAR (target_name.c_str ())); + } + catch (const Error &ex) + { + if (ex.node_ != 0) + ACE_ERROR ((LM_ERROR, "%s:%d:error: %s\n", + ex.node_->file_name ().c_str (), + ex.node_->line (), + ex.diag_.c_str ())); + else + ACE_ERROR ((LM_ERROR, "::error:%s\n", + ex.diag_.c_str ())); + + return -1; + } + return 0; + } + + int + idl3_to_xmi_visitor::visit_native (AST_Native *node) + { + XMI_TRACE ("native"); + + if (this->skip_imported_ && node->imported ()) + { + return 0; + } + + try + { + ES_Guard class_guard (LITERALS[CLASS_TAG], this); + + this->gen_common_elements (node, LITERALS[ST_NATIVE]); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + idl3_to_xmi_visitor::set_attribute (const ACE_TCHAR *name, + const ACE_TCHAR *value) + { + DOMElement *ele = 0; + this->stack_.top (ele); + + ele->setAttribute (XStr (name), XStr (value)); + } + + + void + idl3_to_xmi_visitor::set_attribute (const ACE_TCHAR *name, + const XMLCh *value) + { + DOMElement *ele = 0; + this->stack_.top (ele); + + ele->setAttribute (XStr (name), value); + } + + void + idl3_to_xmi_visitor::add_text (const ACE_TCHAR *text) + { + DOMElement *ele = 0; + this->stack_.top (ele); + + DOMText *node = this->dom_->createTextNode (XStr (text)); + ele->appendChild (node); + } + + DOMElement * + idl3_to_xmi_visitor::create_element (const ACE_TCHAR *name) + { + DOMElement *ele = 0; + this->stack_.top (ele); + + DOMElement *node = this->dom_->createElement (XStr (name)); + + ele->appendChild (node); + + return node; + } + + DOMElement * + idl3_to_xmi_visitor::generate_stereotypes (void) + { + DOMElement *retval = + this->dom_->createElement (XStr (LITERALS[OWNEDELEMENT_TAG])); + + // put it on the stack to subsequent create_element calls refer to it. + this->stack_.push (retval); + + this->add_stereotype (ST_CONSUMES, ASSOC); + this->add_stereotype (ST_ANON_SEQ, CLASS); + this->add_stereotype (ST_PRINC, DATATYPE); + this->add_stereotype (ST_UNION, CLASS); + this->add_stereotype (ST_USES, ASSOC); + this->add_stereotype (ST_SEQ, CLASS); + this->add_stereotype (ST_ROE, __NULL); + this->add_stereotype (ST_RO, __NULL); + this->add_stereotype (ST_OBJ, DATATYPE); + this->add_stereotype (ST_STR, DATATYPE); + this->add_stereotype (ST_LD, DATATYPE); + this->add_stereotype (ST_ANON_ARR, CLASS); + this->add_stereotype (ST_ALIAS, CLASS); + this->add_stereotype (ST_NULL, DATATYPE); + this->add_stereotype (ST_VALUE, CLASS); + this->add_stereotype (ST_VOID, DATATYPE); + this->add_stereotype (ST_EX, CLASS); + this->add_stereotype (ST_OCTET, DATATYPE); + this->add_stereotype (ST_MANAGES, ASSOC); + this->add_stereotype (ST_WSTR, DATATYPE); + this->add_stereotype (ST_FLOAT, DATATYPE); + this->add_stereotype (ST_ENUM, CLASS); + this->add_stereotype (ST_VAL_SUP, CLASS); + this->add_stereotype (ST_MODULE, PACKAGE); + this->add_stereotype (ST_HFINDER, CLASS); + this->add_stereotype (ST_DOUBLE, DATATYPE); + this->add_stereotype (ST_LL, DATATYPE); + this->add_stereotype (ST_HFACT, CLASS); + this->add_stereotype (ST_ARR, CLASS); + this->add_stereotype (ST_COMP, CLASS); + this->add_stereotype (ST_SHORT, DATATYPE); + this->add_stereotype (ST_TYPEDEF, CLASS); + this->add_stereotype (ST_ULL, DATATYPE); + this->add_stereotype (ST_LONG, DATATYPE); + this->add_stereotype (ST_TC, DATATYPE); + this->add_stereotype (ST_HOME, CLASS); + this->add_stereotype (ST_STRUCT, CLASS); + this->add_stereotype (ST_FIXED, DATATYPE); + this->add_stereotype (ST_US, DATATYPE); + this->add_stereotype (ST_EMITS, ASSOC); + this->add_stereotype (ST_BOXVALUE, CLASS); + this->add_stereotype (ST_BOOL, DATATYPE); + this->add_stereotype (ST_CONST, ATTR); + this->add_stereotype (ST_PUBLISH, ASSOC); + this->add_stereotype (ST_CONSTANTS, CLASS); + this->add_stereotype (ST_PROVIDES, ASSOC); + this->add_stereotype (ST_WCHAR, DATATYPE); + this->add_stereotype (ST_UL, DATATYPE); + this->add_stereotype (ST_VAL_FACT, CLASS); + this->add_stereotype (ST_EVENT, CLASS); + this->add_stereotype (ST_CHAR, DATATYPE); + this->add_stereotype (ST_INTF, CLASS); + this->add_stereotype (ST_PRI_KEY, CLASS); + this->add_stereotype (ST_ANY, DATATYPE); + this->add_stereotype (ST_NATIVE, CLASS); + + this->stack_.pop (retval); + + return retval; + } + + void + idl3_to_xmi_visitor::add_stereotype (const LITERAL_T name, + const LITERAL_T bc) + { + // Generate our xmi.id + XStr xid (this->gen_xmi_id ()); + + // Bind the id in the map + this->id_map_.bind (LITERALS[name], xid); + + DOMElement *ele = this->create_element (LITERALS[STEREOTYPE_TAG]); + ele->setAttribute (XStr (LITERALS[XMI_ID]), xid); + ele->setAttribute (XStr (LITERALS[NAME]), XStr (LITERALS[name])); + ele->setAttribute (XStr (LITERALS[BASEC]), XStr (LITERALS[bc])); + + return; + } + + XMLCh * + idl3_to_xmi_visitor::gen_xmi_id (const ACE_TCHAR *name, long line) + { + if (current_id_ == 0) + { + ACE_OS::srand (ACE_OS::gettimeofday ().msec ()); + current_id_ = rand (); + } + std::stringstream str; + // Skip all characters that cannot be a first name char in xmi.id. + while (name && *name && !XMLChar1_1::isFirstNameChar(*name)) ++name; + // Since we use a file path as name then let's change all non-name + // chars for '_'. + while (name && *name) + { + if (XMLChar1_1::isNameChar (*name)) + { + str << *name; + } + else + { + str << '_'; + } + ++name; + } + str << ':' << line << '.' << current_id_++; + + XStr retval (ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + return retval.release (); + } + + XMLCh * + idl3_to_xmi_visitor::gen_xmi_id (AST_Decl *node) + { + if (current_id_ == 0) + { + ACE_OS::srand (ACE_OS::gettimeofday ().msec ()); + current_id_ = rand (); + } + + // we want these IDs to be unique, but the CDMW + // code generator sometimes depends + // on the order these things were declared in IDL, + // so for cases like that, + // we generate an ID that will sort to the order it + // was declared in IDL, + // no matter which order we visit the nodes. + if (node != 0) + { + return + gen_xmi_id ( + ACE_TEXT_CHAR_TO_TCHAR (node->file_name ().c_str ()), + node->line ()); + } + + std::stringstream str; + + str << "xmi." << current_id_++; + XStr retval (ACE_TEXT_CHAR_TO_TCHAR (str.str ().c_str ())); + return retval.release (); + } + + void + idl3_to_xmi_visitor::set_containing_element ( + const ACE_TCHAR *cont_name) + { + ACE_TString tmp; + XStr xid; + + this->namespace_.top (tmp); + this->id_map_.find (tmp, xid); + this->set_attribute (cont_name, xid); + } + + void + idl3_to_xmi_visitor::create_and_store_xmi_id (AST_Decl *node) + { + try + { + this->create_and_store_xmi_id ( + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), node); + } + catch (Error &ex) + { + ex.node (node); + throw; + } + } + + void + idl3_to_xmi_visitor::create_and_store_xmi_id ( + const ACE_TCHAR *name, AST_Decl *node) + { + XStr xid = this->gen_xmi_id (node); + + // store xmi_id + if (this->id_map_.trybind (name, xid) == -1) + throw Error ("error binding in the XMI ID map"); + + this->set_attribute (LITERALS[XMI_ID], xid); + } + + XMLCh * + idl3_to_xmi_visitor::lookup_xid (const ACE_TCHAR *name) + { + XStr tmp; + if (this->id_map_.find (name, tmp) == -1) + { + ACE_CString err ("unknown XMI ID requested for "); + err += ACE_TEXT_ALWAYS_CHAR (name); + throw Error (err.c_str ()); + } + + return tmp.release (); + } + + XMLCh * + idl3_to_xmi_visitor::lookup_type_xid (AST_Type *node) + { + AST_PredefinedType *pdt = 0; + + switch (node->node_type ()) + { + case AST_Decl::NT_string: + return this->lookup_xid (LITERALS[ST_STR]); + case AST_Decl::NT_wstring: + return this->lookup_xid (LITERALS[ST_WSTR]); + + case AST_Decl::NT_pre_defined: + pdt = AST_PredefinedType::narrow_from_decl (node); + + switch (pdt->pt ()) + { + case AST_PredefinedType::PT_pseudo: + return this->lookup_xid (ACE_TEXT_CHAR_TO_TCHAR (pdt->repoID ())); + case AST_PredefinedType::PT_object: + return this->lookup_xid (LITERALS[ST_OBJ]); + case AST_PredefinedType::PT_any: + return this->lookup_xid (LITERALS[ST_ANY]); + case AST_PredefinedType::PT_long: + return this->lookup_xid (LITERALS[ST_LONG]); + case AST_PredefinedType::PT_ulong: + return this->lookup_xid (LITERALS[ST_UL]); + case AST_PredefinedType::PT_longlong: + return this->lookup_xid (LITERALS[ST_LL]); + case AST_PredefinedType::PT_ulonglong: + return this->lookup_xid (LITERALS[ST_ULL]); + case AST_PredefinedType::PT_short: + return this->lookup_xid (LITERALS[ST_SHORT]); + case AST_PredefinedType::PT_ushort: + return this->lookup_xid (LITERALS[ST_US]); + case AST_PredefinedType::PT_float: + return this->lookup_xid (LITERALS[ST_FLOAT]); + case AST_PredefinedType::PT_double: + return this->lookup_xid (LITERALS[ST_DOUBLE]); + case AST_PredefinedType::PT_longdouble: + return this->lookup_xid (LITERALS[ST_LD]); + case AST_PredefinedType::PT_char: + return this->lookup_xid (LITERALS[ST_CHAR]); + case AST_PredefinedType::PT_wchar: + return this->lookup_xid (LITERALS[ST_WCHAR]); + case AST_PredefinedType::PT_boolean: + return this->lookup_xid (LITERALS[ST_BOOL]); + case AST_PredefinedType::PT_octet: + return this->lookup_xid (LITERALS[ST_OCTET]); + case AST_PredefinedType::PT_void: + return this->lookup_xid (LITERALS[ST_VOID]); + default: + throw Error ("Unknown or unsupported predefined type", + pdt); + } + default: + return this->lookup_xid (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ())); + } + } + + void + idl3_to_xmi_visitor::find_and_set_xid_as_attr (const ACE_TCHAR *attr_name, + const ACE_TCHAR *xid_name) + { + XStr tmp; + + if (this->id_map_.find (xid_name, tmp) == -1) + { + ACE_CString err ("unknown XMI ID when looking up "); + err += ACE_TEXT_ALWAYS_CHAR (xid_name); + throw Error (err.c_str ()); + } + + this->set_attribute (attr_name, tmp); + } + + void + idl3_to_xmi_visitor::gen_tagged_value (AST_Decl *node) + { + ES_Guard me_guard (LITERALS[ME_TV_TAG], this); + ES_Guard tv_guard (LITERALS[TV_TAG], this); + + this->set_attribute (LITERALS[TAG], LITERALS[TYPEID]); + this->set_attribute (LITERALS[VALUE], + ACE_TEXT_CHAR_TO_TCHAR (node->repoID ())); + } + + XMLCh * + idl3_to_xmi_visitor::add_generalization (const ACE_TCHAR *sub, + const ACE_TCHAR *super) + { + return this->add_generalization (XStr (this->lookup_xid (sub)), + XStr (this->lookup_xid (super))); + } + + XMLCh * + idl3_to_xmi_visitor::add_generalization (AST_Type *sub, AST_Type *super) + { + return this->add_generalization (XStr (this->lookup_type_xid (sub)), + XStr (this->lookup_type_xid (super))); + } + + XMLCh * + idl3_to_xmi_visitor::add_generalization (const XMLCh *sub, + const XMLCh *super) + { + // Generate XMI ID + XStr xid (this->gen_xmi_id ()); + + { // add generalization to the 'generalizations' set + ES_Guard es_guard (this->generalizations_, this); + NS_Guard ns_guard (ACE_TEXT ("::"), this); + + ES_Guard gen_guard (LITERALS[GEN_TAG], this); + + this->set_attribute (LITERALS[XMI_ID], xid); + + this->set_containing_element (LITERALS[NS]); + + { // subtype + ES_Guard st_guard (LITERALS[GEN_SUB_TAG], this); + ES_Guard element_guard (LITERALS[GEN_ELEMENT_TAG], this); + + this->set_attribute (LITERALS[IDREF], sub); + } + + { // subtype + ES_Guard st_guard (LITERALS[GEN_SUPER_TAG], this); + ES_Guard element_guard (LITERALS[GEN_ELEMENT_TAG], this); + + this->set_attribute (LITERALS[IDREF], super); + } + } + + { // Reference generalization in the calling element. + ES_Guard et_g (LITERALS[GEN_ELEMENT_GEN_TAG], this); + ES_Guard g_g (LITERALS[GEN_TAG], this); + this->set_attribute (LITERALS[IDREF], xid); + } + + return xid.release (); + } + + void + idl3_to_xmi_visitor::add_port (const ACE_TCHAR *port_kind, + AST_Field *port_node) + { + if (port_node->node_type () == AST_Decl::NT_uses) + { + AST_Uses *u = AST_Uses::narrow_from_decl (port_node); + + if (u->is_multiple ()) + { + throw Error ("uses multiple not yet supported."); + } + } + + ES_Guard es_guard (this->associations_, this); + NS_Guard ns_guard (ACE_TEXT ("::"), this); + + ES_Guard assoc_guard (LITERALS[ASSOC_TAG], this); + + // Generate XMI ID + XStr xid (this->gen_xmi_id (port_node)); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], port_kind); + this->set_containing_element (LITERALS[NS]); + + ES_Guard conn_guard (LITERALS[ASSOC_CONN_TAG], this); + + { // component end + ES_Guard end_guard (LITERALS[ASSOC_END_TAG], this); + this->set_attribute (LITERALS[MULT], ACE_TEXT ("1")); + this->find_and_set_xid_as_attr ( + LITERALS[TYPE], + ACE_TEXT_CHAR_TO_TCHAR (this->cached_type_->repoID ())); + } + + { // component end + ES_Guard end_guard (LITERALS[ASSOC_END_TAG], this); + + Identifier *id = + IdentifierHelper::original_local_name ( + port_node->local_name ()); + + this->set_attribute (LITERALS[NAME], id->get_string ()); + this->set_attribute (LITERALS[MULT], ACE_TEXT ("1")); + + this->find_and_set_xid_as_attr ( + LITERALS[TYPE], + port_node->field_type ()->repoID ()); + + id->destroy (); + delete id; + id = 0; + } + } + + void + idl3_to_xmi_visitor::add_managed_component (const ACE_TCHAR *home, + const ACE_TCHAR *component) + { + ES_Guard es_guard (this->associations_, this); + NS_Guard ns_guard (ACE_TEXT ("::"), this); + + ES_Guard assoc_guard (LITERALS[ASSOC_TAG], this); + + // Generate XMI ID + XStr xid (this->gen_xmi_id ()); + this->set_attribute (LITERALS[XMI_ID], xid); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + LITERALS[ST_MANAGES]); + this->set_containing_element (LITERALS[NS]); + + ES_Guard conn_guard (LITERALS[ASSOC_CONN_TAG], this); + + { // home end + ES_Guard end_guard (LITERALS[ASSOC_END_TAG], this); + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + LITERALS[ST_HOME]); + this->find_and_set_xid_as_attr (LITERALS[TYPE], home); + } + + { // component end + ES_Guard end_guard (LITERALS[ASSOC_END_TAG], this); + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + LITERALS[ST_COMP]); + this->find_and_set_xid_as_attr (LITERALS[TYPE], component); + } + } + + void + idl3_to_xmi_visitor::gen_common_elements (AST_Decl *node, + const ACE_TCHAR *stereotype) + { + this->create_and_store_xmi_id (node); + this->set_attribute ( + LITERALS[NAME], + ACE_TEXT_CHAR_TO_TCHAR (node->original_local_name ()->get_string ())); + this->set_attribute (LITERALS[VISIBIL], LITERALS[PUBLIC]); + this->set_containing_element (LITERALS[NS]); + this->find_and_set_xid_as_attr (LITERALS[STEREO_ATTR], + stereotype); + + NS_Guard ns_guard (ACE_TEXT_CHAR_TO_TCHAR (node->repoID ()), this); + this->gen_tagged_value (node); + } + + idl3_to_xmi_visitor::ES_Guard::ES_Guard (const ACE_TCHAR *name, + idl3_to_xmi_visitor *vis) + : vis_ (*vis) + { + if (vis_.stack_.push (vis_.create_element (name))) + throw Error ("element stack error"); + } + + idl3_to_xmi_visitor::ES_Guard::ES_Guard (DOMElement *ele, + idl3_to_xmi_visitor *vis) + : vis_ (*vis) + { + if (vis_.stack_.push (ele) != 0) + throw Error ("element stack error"); + } + + idl3_to_xmi_visitor::ES_Guard::~ES_Guard (void) + { + DOMElement *tmp; + if (vis_.stack_.pop (tmp) != 0) + { + vis_.output_dirty_ = true; + ACE_ERROR ((LM_ERROR, "error: element stack underflow.")); + } + } + + idl3_to_xmi_visitor::NS_Guard::NS_Guard (const ACE_TCHAR *name, + idl3_to_xmi_visitor *vis) + : vis_ (*vis) + { + int res = vis_.namespace_.push (name); + + if (res == 0) return; + throw Error ("stack error"); + } + + idl3_to_xmi_visitor::NS_Guard::~NS_Guard (void) + { + ACE_TString tmp; + if (vis_.namespace_.pop (tmp) != 0) + { + vis_.output_dirty_ = true; + ACE_ERROR ((LM_ERROR, "error:namespace stack underflow")); + } + } + } +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.h b/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.h new file mode 100644 index 00000000000..8b88ae6bacb --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/IDL3_to_XMI_visitor.h @@ -0,0 +1,325 @@ +/** + * @file IDL3_to_XMI_visitor.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * $Id$ + * Implements a visitor that generates XMI for the CARDAMOM + * code generation facility. + * + * This IDL->XMI mapping appears to be based on a IDL->UML->XMI + * mapping, and should be valid XMI version 1.1 + */ + +#ifndef CIAO_XMI_VISITOR_H +#define CIAO_XMI_VISITOR_H + +#include "ace/Containers.h" +#include "ace/Hash_Map_Manager.h" +#include "ace/Null_Mutex.h" +#include "ace/SString.h" + +#include "xercesc/util/XercesDefs.hpp" + +#include "ast_visitor.h" +#include "ast_component.h" +#include "ast_concrete_type.h" + +#include "utl_scoped_name.h" +#include "Literals.h" +#include "XML/XercesString.h" +#include "CIAO_IDL3_TO_XMI_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class TAO_OutStream; +class UTL_ExceptList; + +namespace XERCES_CPP_NAMESPACE +{ + class DOMDocument; + class DOMElement; +} + +namespace CIAO +{ + namespace XMI + { + + /** + * @class idl3_to_xmi_visitor + * @brief Visitor that generates XMI for the CARDAMOM code + * generation facilities. + */ + class CIAO_IDL3_TO_XMI_Export idl3_to_xmi_visitor : public ast_visitor + { + public: + idl3_to_xmi_visitor (bool skip_imported); + virtual ~idl3_to_xmi_visitor (void); + + virtual int visit_decl (AST_Decl *d); + virtual int visit_scope (UTL_Scope *node); + virtual int visit_type (AST_Type *node); + virtual int visit_predefined_type (AST_PredefinedType *node); + virtual int visit_module (AST_Module *node); + virtual int visit_interface (AST_Interface *node); + virtual int visit_interface_fwd (AST_InterfaceFwd *node); + virtual int visit_template_interface (AST_Template_Interface *node); + virtual int visit_valuebox (AST_ValueBox *node); + virtual int visit_valuetype (AST_ValueType *node); + virtual int visit_valuetype_fwd (AST_ValueTypeFwd *node); + virtual int visit_eventtype (AST_EventType *node); + virtual int visit_eventtype_fwd (AST_EventTypeFwd *node); + virtual int visit_component (AST_Component *node); + virtual int visit_component_fwd (AST_ComponentFwd *node); + virtual int visit_provides (AST_Provides *node); + virtual int visit_uses (AST_Uses *node); + virtual int visit_publishes (AST_Publishes *node); + virtual int visit_emits (AST_Emits *node); + virtual int visit_consumes (AST_Consumes *node); + virtual int visit_porttype (AST_PortType *node); + virtual int visit_extended_port (AST_Extended_Port *node); + virtual int visit_mirror_port (AST_Mirror_Port *node); + virtual int visit_connector (AST_Connector *node); + virtual int visit_instantiated_connector ( + AST_Instantiated_Connector *node); + virtual int visit_tmpl_port (AST_Tmpl_Port *node); + virtual int visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *node); + virtual int visit_home (AST_Home *node); + virtual int visit_factory (AST_Factory *node); + virtual int visit_structure (AST_Structure *node); + virtual int visit_structure_fwd (AST_StructureFwd *node); + virtual int visit_exception (AST_Exception *node); + virtual int visit_expression (AST_Expression *node); + virtual int visit_enum (AST_Enum *node); + virtual int visit_operation (AST_Operation *node); + virtual int visit_field (AST_Field *node); + virtual int visit_argument (AST_Argument *node); + virtual int visit_attribute (AST_Attribute *node); + virtual int visit_union (AST_Union *node); + virtual int visit_union_fwd (AST_UnionFwd *node); + virtual int visit_union_branch (AST_UnionBranch *node); + virtual int visit_union_label (AST_UnionLabel *node); + virtual int visit_constant (AST_Constant *node); + virtual int visit_enum_val (AST_EnumVal *node); + virtual int visit_array (AST_Array *node); + virtual int visit_sequence (AST_Sequence *node); + virtual int visit_string (AST_String *node); + virtual int visit_typedef (AST_Typedef *node); + virtual int visit_root (AST_Root *node); + virtual int visit_native (AST_Native *node); + + struct Error + { + Error (const ACE_CString &diag, AST_Decl *node = 0) + : diag_ (diag), + node_ (node) + {} + + void node (AST_Decl *node) { if (node_ == 0) node_ = node; } + + const ACE_CString diag_; + AST_Decl *node_; + }; + + private: + /// Generates several elements common to most XMI elements. + /// Generates the following attributes: xmi.id, name, visibility, namespace, stereotype + /// and the tagged value grouping. + /// @param stereotype The stereotype this element should be associated with. + void gen_common_elements (AST_Decl *node, const ACE_TCHAR *stereotype); + + /// Converts a number into a string representation. + /// Caller responsible for memory. + template <typename T> + ACE_TCHAR * number_to_string (T val); + + /// Common elements of operation XMI generation + void visit_operation_impl (AST_Operation *node, const ACE_TCHAR *stereotype); + + /// implementation for elements common to both eventtypes + /// and valuetypes + void visit_valuetype_impl (AST_ValueType *node); + + /// implementation of elements common to exceptions and structures. + void visit_struct_impl (AST_Structure *node); + + /// Generation of common associations of anonymous and typedefed arrays. + void gen_array_associations (AST_Decl *node, AST_Array *array); + + /// Generation of common associations of anonymous and typedefed sequences. + void gen_sequence_associations (AST_Decl *node, AST_Sequence *sequence); + + /// sets an attribute on the element at the top of the stack. + void set_attribute (const ACE_TCHAR *name, + const ACE_TCHAR *value); + + + /// sets an attribute on the element at the top of the stack + void set_attribute (const ACE_TCHAR *name, + const XMLCh *value); + + /// Adds a text child to the element at the top of the stack + void add_text (const ACE_TCHAR *text); + + /// Greates a new element as a child of the current stack element + XERCES_CPP_NAMESPACE::DOMElement * create_element (const ACE_TCHAR *name); + + /// Generate stereotypes for XMI document + XERCES_CPP_NAMESPACE::DOMElement * generate_stereotypes (void); + + /// Helper method which creates new stereotype elements + void add_stereotype (const LITERAL_T name, + const LITERAL_T bc); + + /// Generates an XMI ID. + /// @param node If passed, the file name and line number will be + /// generated as part of the ID. + static XMLCh * gen_xmi_id (AST_Decl * node = 0); + + /// Generates an XMI ID with file_name and line as part of the id. + static XMLCh * gen_xmi_id (const ACE_TCHAR *file_name, long line); + + /// Used to store the next ID for generation + static size_t current_id_; + + /// Generates the tagged value grouping common to most XMI elements + void gen_tagged_value (AST_Decl *); + + /// Sets an attribute with name containment_name whose value is the + /// ID of the top of the namespace stack. + void set_containing_element (const ACE_TCHAR *containment_name); + + /// Looks up the xmi:id assoviated with xid_name and sets it as an + /// attribute + void find_and_set_xid_as_attr (const ACE_TCHAR *attr_name, const ACE_TCHAR *xid_name); + + /// Creates a XMI ID based on node, and sets its value to + /// the xmi.id attribute of the current top of element stack. + void create_and_store_xmi_id (AST_Decl *node); + + /// Creates a XMI ID based on node, and sets its value to + /// the name attribute of the current top of element stack. + void create_and_store_xmi_id (const ACE_TCHAR *name, AST_Decl *node = 0); + + /// Finds and returns the xmi.id associated with name. + XMLCh * lookup_xid (const ACE_TCHAR *name); + + /// Finds and returns the xmi.id associated with the provided type. + XMLCh * lookup_type_xid (AST_Type *); + + /// Used to add generalizations - most commonly used for supports + /// relationships. in component foo supports bar, foo is the sub, + /// bar is the super. + XMLCh * add_generalization (const ACE_TCHAR *sub, const ACE_TCHAR *super); + XMLCh * add_generalization (AST_Type *sub, AST_Type *super); + + XMLCh * add_generalization (const XMLCh *sub, const XMLCh *super); + + /// @param component Repository ID of component + /// @param port_kind text of port stereotype from LITERALS + /// @param port_type Repository ID of port type (ie, interface type for facet) + /// @param name The name of the port + /// @param is_multiple The multiplicity of the port (ie, uses multiple.) + void add_port (const ACE_TCHAR *port_kind, + AST_Field *port_node); + + void add_managed_component (const ACE_TCHAR *home, const ACE_TCHAR *component); + + + ACE_TCHAR * union_label_value (AST_Expression *exp); + + typedef ACE_Hash_Map_Manager_Ex< ACE_TString, + CIAO::XML::XStr, + ACE_Hash <ACE_TString>, + ACE_Equal_To <ACE_TString>, + ACE_Null_Mutex > XMI_ID_MAP; + + /// Stores xmi.ids for elements, indexed by repoId. + XMI_ID_MAP id_map_; + + typedef ACE_Unbounded_Stack<XERCES_CPP_NAMESPACE::DOMElement *> ELEMENT_STACK; + + /// Stores elements we are currently generating XMI. Top of stack is the current + /// element. + ELEMENT_STACK stack_; + + struct ElementContext { + ACE_TString ns_; + XERCES_CPP_NAMESPACE::DOMElement *elem_; + }; + + typedef ACE_Hash_Map_Manager_Ex< ACE_TString, + ElementContext, + ACE_Hash <ACE_TString>, + ACE_Equal_To <ACE_TString>, + ACE_Null_Mutex > REPO_ID_MAP; + + /// Stores elements that were forward declared. Also stores modules that can + /// be reopened. + REPO_ID_MAP repo_id_map_; + + /// Provides a "protected" push that is popped when the current scope + /// is exited. + struct ES_Guard + { + ES_Guard (const ACE_TCHAR *name, idl3_to_xmi_visitor *); + ES_Guard (XERCES_CPP_NAMESPACE::DOMElement *ele, + idl3_to_xmi_visitor *); + ~ES_Guard (void); + + idl3_to_xmi_visitor &vis_; + }; + + friend struct ES_Guard; + + typedef ACE_Unbounded_Stack< ACE_TString > STRING_STACK; + + /// Stores namespaces associated with our current scope. + STRING_STACK namespace_; + + /// Provides a protected push for the namespace stack that + /// pops when the current scope is exited. + struct NS_Guard + { + NS_Guard (const ACE_TCHAR *name, idl3_to_xmi_visitor *); + ~NS_Guard (void); + + idl3_to_xmi_visitor &vis_; + }; + + friend struct NS_Guard; + + XERCES_CPP_NAMESPACE::DOMDocument *dom_; + + XERCES_CPP_NAMESPACE::DOMElement *root_; + + XERCES_CPP_NAMESPACE::DOMElement *generalizations_; + + XERCES_CPP_NAMESPACE::DOMElement *associations_; + + const CIAO::XML::XStr base_id_; + + /// true if for some reason the generated output is bad + /// and shouldn't be written. + bool output_dirty_; + + bool skip_imported_; + + /// true if we are in enum "scope". + bool visiting_enum_; + + /// Used to determine IDL ordering of union labels. + size_t order_; + + /// USed to cache the type of union descriminators + AST_ConcreteType *union_disc_; + + /// Used to cache the type whose scope we are currently in. + AST_Decl *cached_type_; + }; + } +} + +#endif diff --git a/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.cpp b/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.cpp new file mode 100644 index 00000000000..397c825227a --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.cpp @@ -0,0 +1,1175 @@ +// $Id$ + +#include "IR_Simulator_visitor.h" + +#include "be_sunsoft.h" +#include "be_extern.h" + +#include "ast_argument.h" +#include "ast_array.h" +#include "ast_attribute.h" +#include "ast_component_fwd.h" +#include "ast_provides.h" +#include "ast_uses.h" +#include "ast_publishes.h" +#include "ast_emits.h" +#include "ast_consumes.h" +#include "ast_enum.h" +#include "ast_enum_val.h" +#include "ast_eventtype.h" +#include "ast_eventtype_fwd.h" +#include "ast_exception.h" +#include "ast_factory.h" +#include "ast_field.h" +#include "ast_home.h" +#include "ast_operation.h" +#include "ast_root.h" +#include "ast_sequence.h" +#include "ast_string.h" +#include "ast_structure_fwd.h" +#include "ast_union.h" +#include "ast_union_branch.h" +#include "ast_union_fwd.h" +#include "ast_union_label.h" +#include "ast_valuebox.h" +#include "ast_valuetype_fwd.h" +#include "ast_native.h" +#include "utl_exceptlist.h" +#include "utl_identifier.h" +#include "utl_idlist.h" +#include "utl_string.h" +#include "global_extern.h" +#include "nr_extern.h" +#include "ace/OS_NS_stdio.h" + + +#include <iostream> +#include <limits> + +#if 0 +#define XMI_TRACE(X) std::cout << X << std::endl +#else +#define XMI_TRACE(X) +#endif + +namespace CIAO +{ + namespace XMI + { + struct Incr_Guard + { + public: + Incr_Guard (size_t &subject, bool arm = false) + : subject_ (subject), + armed_ (arm) + { + } + + ~Incr_Guard (void) + { + if (this->armed_) + --subject_; + } + void arm (void) + { + this->armed_ = true; + ++subject_; + } + + private: + size_t &subject_; + bool armed_; + }; + + ir_simulator_visitor::ir_simulator_visitor (void) + : associating_ (false) + { + } + + ir_simulator_visitor::~ir_simulator_visitor (void) + { + } + + int + ir_simulator_visitor::visit_decl (AST_Decl *) + { + XMI_TRACE ("got a decl"); + return 0; + } + + int + ir_simulator_visitor::visit_scope (UTL_Scope *node) + { + XMI_TRACE ("got a scope"); + + for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); + !si.is_done (); + si.next ()) + { + AST_Decl *d = si.item (); + + if (d->ast_accept (this) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "ir_simulator_visitor::visit_scope - " + "codegen for scope failed\n"), + -1); + } + } + return 0; + } + + int + ir_simulator_visitor::visit_type (AST_Type *) + { + XMI_TRACE ("got a type"); + return 0; + } + + int + ir_simulator_visitor::visit_predefined_type (AST_PredefinedType *) + { + XMI_TRACE ("predef type"); + return 0; + } + + int + ir_simulator_visitor::visit_module (AST_Module *node) + { + XMI_TRACE ("module"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_module - " + "codegen for scope failed\n"), + -1); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_interface (AST_Interface *node) + { + XMI_TRACE ("interface"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + // Inheritance + for (long i = 0; i < node->n_inherits (); ++i) + { + this->visit_interface (node->inherits ()[i]); + } + + if (this->visit_scope (node) != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "idl3_to_idl2_visitor::visit_interface - " + "codegen for scope failed\n"), + -1); + } + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_interface_fwd (AST_InterfaceFwd *node) + { + XMI_TRACE ("interface_fwd"); + + // won't hurt to import the fwd interface + node->set_imported (false); + + return 0; + } + + int + ir_simulator_visitor::visit_template_interface ( + AST_Template_Interface *) + { + return 0; + } + + int + ir_simulator_visitor::visit_valuebox (AST_ValueBox *node) + { + XMI_TRACE ("valuebox"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) return 0; + // not imported, but not associating, need to set the guard + else guard.arm (); + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + // **** need to visit type we are boxing? + node->boxed_type ()->ast_accept (this); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_valuetype (AST_ValueType *node) + { + XMI_TRACE ("valuetype"); + + try + { + this->visit_valuetype_impl (node); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + void + ir_simulator_visitor::visit_valuetype_impl (AST_ValueType *node) + { + Incr_Guard guard (this->associating_); + + if (!this->do_i_care (node)) + { + return; + } + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + if (node->inherits_concrete () != 0) + { + this->visit_valuetype_impl (node->inherits_concrete ()); + } + + long lim = node->n_supports (); + AST_Interface **sppts = node->supports (); + + for (long i = 0; i < lim; ++i) + { + sppts[i]->ast_accept (this); + } + + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + } + + int + ir_simulator_visitor::visit_valuetype_fwd (AST_ValueTypeFwd *node) + { + XMI_TRACE ("valuetype_fwd"); + + try + { + // no harm from importing a fwd interface + // node->is_imported (false); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_component (AST_Component *node) + { + XMI_TRACE ("component"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + if (node->base_component () != 0) + { + node->base_component ()->ast_accept (this); + } + + long len = node->n_supports (); + AST_Interface **sppts = node->supports (); + + for (long i = 0; i < len; ++i) + { + sppts[i]->ast_accept (this); + } + + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_component_fwd (AST_ComponentFwd *node) + { + XMI_TRACE ("component_fwd"); + + try + { + // no harm from importing a fwd interface + // node->is_imported (false); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_provides (AST_Provides *node) + { + return node->provides_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_uses (AST_Uses *node) + { + return node->uses_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_publishes (AST_Publishes *node) + { + return node->publishes_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_emits (AST_Emits *node) + { + return node->emits_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_consumes (AST_Consumes *node) + { + return node->consumes_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_porttype (AST_PortType *) + { + return 0; + } + + int + ir_simulator_visitor::visit_extended_port (AST_Extended_Port *) + { + return 0; + } + + int + ir_simulator_visitor::visit_mirror_port (AST_Mirror_Port *) + { + return 0; + } + + int + ir_simulator_visitor::visit_connector (AST_Connector *) + { + return 0; + } + + int + ir_simulator_visitor::visit_instantiated_connector ( + AST_Instantiated_Connector *) + { + return 0; + } + + int + ir_simulator_visitor::visit_tmpl_port (AST_Tmpl_Port *) + { + return 0; + } + + int + ir_simulator_visitor::visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *) + { + return 0; + } + + int + ir_simulator_visitor::visit_eventtype (AST_EventType *node) + { + XMI_TRACE ("eventtype"); + + try + { + this->visit_valuetype_impl (node); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_eventtype_fwd (AST_EventTypeFwd *node) + { + XMI_TRACE ("eventtype_fwd"); + + this->visit_valuetype_fwd (node); + + return 0; + } + + int + ir_simulator_visitor::visit_home (AST_Home *node) + { + XMI_TRACE ("home"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + // **** supported interfaces + long len = node->n_supports (); + AST_Interface **sppts = node->supports (); + + for (long i = 0; i < len; ++i) + { + sppts[i]->ast_accept (this); + } + + if (node->base_home ()) + { + node->base_home ()->ast_accept (this); + } + + if (node->managed_component ()) + { + node->managed_component ()->ast_accept (this); + } + + if (node->primary_key ()) + { + node->primary_key ()->ast_accept (this); + } + + for (size_t i = 0; i < node->factories ().size (); ++i) + { + AST_Operation **op = 0; + node->factories ().get (op, i); + (*op)->ast_accept (this); + } + + for (size_t i = 0; i < node->finders ().size (); ++i) + { + AST_Operation **op = 0; + node->finders ().get (op, i); + (*op)->ast_accept (this); + } + + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_factory (AST_Factory *node) + { + XMI_TRACE ("factory"); + + throw Error ("Factories not supported", node); + + return 0; + } + + int + ir_simulator_visitor::visit_structure (AST_Structure *node) + { + XMI_TRACE ("structure"); + + try + { + this->visit_struct_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + void + ir_simulator_visitor::visit_struct_impl (AST_Structure *node) + { + if (!this->do_i_care (node)) + { + return; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + } + + int + ir_simulator_visitor::visit_structure_fwd (AST_StructureFwd *node) + { + XMI_TRACE ("structure_fwd"); + + try + { + node->set_imported (false); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_exception (AST_Exception *node) + { + XMI_TRACE ("exception"); + + + try + { + this->visit_struct_impl (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_expression (AST_Expression *) + { + XMI_TRACE ("expression"); + + /* Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) return; + // not imported, but not associating, need to set the guard + else guard.arm (); + } + // associating, import + else node->set_imported (false); + */ + return 0; + } + + int + ir_simulator_visitor::visit_enum (AST_Enum *node) + { + XMI_TRACE ("enum"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_operation (AST_Operation *node) + { + XMI_TRACE ("operation"); + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + // ACE_DEBUG ((LM_DEBUG, "foo")); + + if (node->return_type ()) + { + // ACE_DEBUG ((LM_DEBUG, "bar")); + node->return_type ()->ast_accept (this); + } + + // **** arguments + // **** exceptions + UTL_ExceptList *exceptions = node->exceptions (); + + if (exceptions != 0 && exceptions->length () > 0) + { + for (UTL_ExceptlistActiveIterator ei (exceptions); + !ei.is_done (); + ei.next ()) + { + ei.item ()->ast_accept (this); + } + } + + this->visit_scope (node); + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_field (AST_Field *node) + { + XMI_TRACE ("field"); + + if (node == 0) + { + ACE_DEBUG ((LM_DEBUG, "null field?\n")); + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + try + { + if (node->field_type ()) + { + node->field_type ()->ast_accept (this); + } + } + catch (Error &err) + { + err.node (node); + } + + return 0; + } + + int + ir_simulator_visitor::visit_argument (AST_Argument *node) + { + XMI_TRACE ("argument"); + + this->visit_field (node); + + return 0; + } + + int + ir_simulator_visitor::visit_attribute (AST_Attribute *node) + { + XMI_TRACE ("attribute"); + + return this->visit_field (node); + } + + int + ir_simulator_visitor::visit_union (AST_Union *node) + { + XMI_TRACE ("union"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + if (node->disc_type ()) + { + this->visit_type (node->disc_type ()); + } + + return this->visit_scope (node); + } + + int + ir_simulator_visitor::visit_union_fwd (AST_UnionFwd *node) + { + XMI_TRACE ("union_fwd"); + node->set_imported (false); + return 0; + } + + int + ir_simulator_visitor::visit_union_branch (AST_UnionBranch *node) + { + XMI_TRACE ("union_branch"); + this->visit_field (node); + return 0; + } + + int + ir_simulator_visitor::visit_union_label (AST_UnionLabel *node) + { + XMI_TRACE ("union_label"); + + if (node->label_val ()) + { + node->label_val ()->ast_accept (this); + } + + return 0; + } + + int + ir_simulator_visitor::visit_constant (AST_Constant *) + { + XMI_TRACE ("constant"); + + // CDMW XMI generator does not generate XMI for constants. + // it, in + return 0; + } + + int + ir_simulator_visitor::visit_enum_val (AST_EnumVal *) + { + XMI_TRACE ("enum val"); + return 0; + } + + int + ir_simulator_visitor::visit_array (AST_Array *node) + { + XMI_TRACE ("array val"); + + if (!this->do_i_care (node)) + { + return 0; + } + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + return node->base_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_sequence (AST_Sequence *node) + { + XMI_TRACE ("sequence val"); + + try + { + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + node->base_type ()->ast_accept (this); + } + catch (Error &err) + { + err.node (node); + throw; + } + + return 0; + } + + int + ir_simulator_visitor::visit_string (AST_String *) + { + XMI_TRACE ("string"); + return 0; + } + + int + ir_simulator_visitor::visit_typedef (AST_Typedef *node) + { + XMI_TRACE ("typedef"); + + Incr_Guard guard (this->associating_); + + if (!this->associating_) + { + // not associating, imported, not my concern + if (node->imported ()) + { + return 0; + } + // not imported, but not associating, need to set the guard + else + { + guard.arm (); + } + } + // associating, import + else + { + node->set_imported (false); + } + + return node->base_type ()->ast_accept (this); + } + + int + ir_simulator_visitor::visit_root (AST_Root *node) + { + XMI_TRACE ("root"); + + try + { + this->visit_scope (node); + } + catch (const Error &ex) + { + if (ex.node_ != 0) + { + ACE_ERROR ((LM_ERROR, "%s:%d:error: %s\n", + ex.node_->file_name ().c_str (), + ex.node_->line (), + ex.diag_.c_str ())); + } + else + { + ACE_ERROR ((LM_ERROR, "::error:%s\n", + ex.diag_.c_str ())); + } + + return -1; + } + + return 0; + } + + int + ir_simulator_visitor::visit_native (AST_Native *) + { + XMI_TRACE ("native"); + return 0; + } + + bool + ir_simulator_visitor::do_i_care (AST_Decl *node) + { + std::string name (node->repoID ()); + + return this->seen_types_.insert (name).second; + } + } +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.h b/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.h new file mode 100644 index 00000000000..2425921041b --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/IR_Simulator_visitor.h @@ -0,0 +1,132 @@ +/** + * @file IR_Simulator_visitor.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * $Id$ + * Implements a visitor that generates XMI for the CARDAMOM + * code generation facility. + * + * This IDL->XMI mapping appears to be based on a IDL->UML->XMI + * mapping, and should be valid XMI version 1.1 + */ + +#ifndef CIAO_IR_SIMULATOR_VISITOR_H +#define CIAO_IR_SIMULATOR_VISITOR_H + +#include "ace/Containers.h" +#include "ace/Hash_Map_Manager.h" +#include "ace/Null_Mutex.h" +#include "ace/SString.h" + +#include "xercesc/util/XercesDefs.hpp" + +#include "ast_visitor.h" +#include "ast_component.h" +#include "utl_scoped_name.h" +#include "Literals.h" +#include "XML/XercesString.h" +#include "CIAO_IDL3_TO_XMI_Export.h" + + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class TAO_OutStream; +class UTL_ExceptList; + +#include <set> +#include <string> + +namespace CIAO +{ + namespace XMI + { + + /** + * @class ir_simulator_visitor + * @brief Visitor that generates XMI for the CARDAMOM code + * generation facilities. + */ + class CIAO_IDL3_TO_XMI_Export ir_simulator_visitor + : public ast_visitor + { + public: + ir_simulator_visitor (void); + virtual ~ir_simulator_visitor (void); + + virtual int visit_decl (AST_Decl *d); + virtual int visit_scope (UTL_Scope *node); + virtual int visit_type (AST_Type *node); + virtual int visit_predefined_type (AST_PredefinedType *node); + virtual int visit_module (AST_Module *node); + virtual int visit_interface (AST_Interface *node); + virtual int visit_interface_fwd (AST_InterfaceFwd *node); + virtual int visit_template_interface (AST_Template_Interface *node); + virtual int visit_valuebox (AST_ValueBox *node); + virtual int visit_valuetype (AST_ValueType *node); + void visit_valuetype_impl (AST_ValueType *); + virtual int visit_valuetype_fwd (AST_ValueTypeFwd *node); + virtual int visit_component (AST_Component *node); + virtual int visit_component_fwd (AST_ComponentFwd *node); + virtual int visit_provides (AST_Provides *node); + virtual int visit_uses (AST_Uses *node); + virtual int visit_publishes (AST_Publishes *node); + virtual int visit_emits (AST_Emits *node); + virtual int visit_consumes (AST_Consumes *node); + virtual int visit_porttype (AST_PortType *node); + virtual int visit_extended_port (AST_Extended_Port *node); + virtual int visit_mirror_port (AST_Mirror_Port *node); + virtual int visit_connector (AST_Connector *node); + virtual int visit_instantiated_connector ( + AST_Instantiated_Connector *node); + virtual int visit_tmpl_port (AST_Tmpl_Port *node); + virtual int visit_tmpl_mirror_port ( + AST_Tmpl_Mirror_Port *node); + virtual int visit_eventtype (AST_EventType *node); + virtual int visit_eventtype_fwd (AST_EventTypeFwd *node); + virtual int visit_home (AST_Home *node); + virtual int visit_factory (AST_Factory *node); + virtual int visit_structure (AST_Structure *node); + void visit_struct_impl (AST_Structure *node); + virtual int visit_structure_fwd (AST_StructureFwd *node); + virtual int visit_exception (AST_Exception *node); + virtual int visit_expression (AST_Expression *node); + virtual int visit_enum (AST_Enum *node); + virtual int visit_operation (AST_Operation *node); + virtual int visit_field (AST_Field *node); + virtual int visit_argument (AST_Argument *node); + virtual int visit_attribute (AST_Attribute *node); + virtual int visit_union (AST_Union *node); + virtual int visit_union_fwd (AST_UnionFwd *node); + virtual int visit_union_branch (AST_UnionBranch *node); + virtual int visit_union_label (AST_UnionLabel *node); + virtual int visit_constant (AST_Constant *node); + virtual int visit_enum_val (AST_EnumVal *node); + virtual int visit_array (AST_Array *node); + virtual int visit_sequence (AST_Sequence *node); + virtual int visit_string (AST_String *node); + virtual int visit_typedef (AST_Typedef *node); + virtual int visit_root (AST_Root *node); + virtual int visit_native (AST_Native *node); + + struct Error + { + Error (const ACE_CString &diag, AST_Decl *node = 0) + : diag_ (diag), + node_ (node) + {} + + void node (AST_Decl *node) { if (node_ == 0) node_ = node; } + + const ACE_CString diag_; + AST_Decl *node_; + }; + + private: + bool do_i_care (AST_Decl *node); + size_t associating_; + std::set <std::string> seen_types_; + }; + } +} +#endif diff --git a/modules/CIAO/tools/IDL3_to_XMI/Literals.cpp b/modules/CIAO/tools/IDL3_to_XMI/Literals.cpp new file mode 100644 index 00000000000..2172bbeb075 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/Literals.cpp @@ -0,0 +1,156 @@ +// $Id$ + +#include "Literals.h" + +namespace CIAO +{ + namespace XMI + { + + const ACE_TCHAR* const LITERALS[MAX_LITERAL] = + { + ACE_TEXT("xmi.version"), // VERSION_TAG + ACE_TEXT("1.1"), // VERSION_VALUE + ACE_TEXT("xmlns:UML"), // NS_TAG + ACE_TEXT("org.omg/UML1.3"), // NS_VALUE + ACE_TEXT("XMI.header"), // HEADER_TAG + ACE_TEXT("XMI.documentation"), // DOC_TAG + ACE_TEXT("XMI.exporter"), // EXPORTER_TAG + ACE_TEXT("DOC Group IDL to XMI converter"), // EXPORTER_VALUE + ACE_TEXT("XMI.content"), // CONTENT_TAG + ACE_TEXT("UML:Model"), // MODEL_TAG + ACE_TEXT("xmi.id"), // XMI_ID + ACE_TEXT("UML:Namespace.ownedElement"), // OWNEDELEMENT_TAG + ACE_TEXT("UML:Package"), // PACKAGE_TAG + ACE_TEXT("UML:ModelElement"), // MODELELEMENT_TAG + ACE_TEXT("UML:ModelElement.taggedValue"), // ME_TV_TAG + ACE_TEXT("UML:ModelElement.constraint"), // ME_CONS_TAG + ACE_TEXT("UML:Constraint"), // CONSTRAINT + ACE_TEXT("UML:TaggedValue"), // TV_TAG + ACE_TEXT("UML:Stereotype"), // STEREOTYPE_TAG + ACE_TEXT("UML:Class"), // CLASS_TAG + ACE_TEXT("UML:Operation"), // OP_TAG + ACE_TEXT("UML:BehavioralFeature.parameter"), // BFP_TAG + ACE_TEXT("UML:Parameter"), // PARAM_TAG + ACE_TEXT("UML:BehavioralFeature.raisedException"), // BF_RE_TAG + ACE_TEXT("UML:Exception"), // EXCEPT_TAG + ACE_TEXT("UML:Attribute"), // ATTR_TAG + ACE_TEXT("UML:Association"), // ASSOC_TAG + ACE_TEXT("UML:Association.connection"), // ASSOC_CONN_TAG + ACE_TEXT("UML:AssociationEnd"), // ASSOC_END_TAG + ACE_TEXT("UML:AssociationEnd.qualifier"), // ASSOC_END_QUAL_TAG + ACE_TEXT("UML:Generalization"), // GEN_TAG + ACE_TEXT("UML:Generalization.subtype"), // GEN_SUB_TAG + ACE_TEXT("UML:Generalization.supertype"), // GEN_SUPER_TAG + ACE_TEXT("UML:GeneralizableElement"), // GEN_ELEMENT_TAG + ACE_TEXT("UML:GeneralizableElement.generalization"),// GEN_ELEMENT_GEN_TAG + ACE_TEXT("UML:Exception"), // EXCEPTION_TAG + + // ******* Attributes + ACE_TEXT("tag"), // TAG + ACE_TEXT("value"), // VALUE + ACE_TEXT("name"), // NAME + ACE_TEXT("baseClass"), // BASEC + ACE_TEXT("visibility"), // VISIBIL + ACE_TEXT("stereotype"), // STEREO_ATTR + ACE_TEXT("namespace"), // NS + ACE_TEXT("owner"), // OWNER + ACE_TEXT("kind"), // KIND + ACE_TEXT("behavioralFeature"), // BFEATURE + ACE_TEXT("type"), // TYPE + ACE_TEXT("isAbstract"), // ABSTRACT + ACE_TEXT("multiplicity"), // MULT + ACE_TEXT("xmi.idref"), // IDREF + ACE_TEXT("ownerScope"), // OWNER_SCOPE + ACE_TEXT("changeable"), // CHANGEABLE + + // ******* Attribute values + ACE_TEXT("Association"), // ASSOC + ACE_TEXT("Class"), // CLASS + ACE_TEXT("DataType"), // DATATYPE + ACE_TEXT("Package"), // PACKAGE + ACE_TEXT("null"), // NULL + ACE_TEXT("Attribute"), // ATTR + ACE_TEXT("public"), // PUBLIC + ACE_TEXT("private"), // _PRIVATE + ACE_TEXT("typeid"), // TYPEID + ACE_TEXT("raises"), // RAISES + ACE_TEXT("return"), // RETURN + ACE_TEXT("in"), // _IN + ACE_TEXT("inout"), // INOUT + ACE_TEXT("out"), // _OUT + ACE_TEXT("true"), // _TRUE + ACE_TEXT("false"), // _FALSE + ACE_TEXT("TRUE"), // CAPS_TRUE + ACE_TEXT("FALSE"), // CAPS_FALSE + ACE_TEXT("1..1"), // MULT_OTO + ACE_TEXT("0..1"), // MULT_ZTO + ACE_TEXT("IDLOrder"), // IDLORDER + ACE_TEXT("index"), // INDEX + ACE_TEXT("constraintUpperValue"), // CONST_UPPER + ACE_TEXT("*"), // UNBOUNDED_SEQ + ACE_TEXT("Case"), // CASE + ACE_TEXT("default"), // DEFAULT_UNION + ACE_TEXT("classifier"), // CLASSIFIER + ACE_TEXT("frozen"), // FROZEN + ACE_TEXT("initialValue"), // INIT_VAL + + //******** Stereotypes + ACE_TEXT("CCMConsumes"), // ST_CONSUMES + ACE_TEXT("CORBAAnonymousSequence"), // ST_ANON_SEQ + ACE_TEXT("CORBAPrincipal"), // ST_PRINC + ACE_TEXT("CORBAUnion"), // ST_UNION + ACE_TEXT("CCMUses"), // ST_USES + ACE_TEXT("CORBASequence"), // ST_SEQ + ACE_TEXT("readonlyEnd"), // ST_ROE + ACE_TEXT("readonly"), // ST_RO + ACE_TEXT("CORBAObject"), // ST_OBJ + ACE_TEXT("CORBAstring"), // ST_STR + ACE_TEXT("CORBAlongdouble"), // ST_LD + ACE_TEXT("CORBAAnonymousArray"), // ST_ANON_ARR + ACE_TEXT("CORBAAlias"), // ST_ALIAS + ACE_TEXT("null"), // ST_NULL + ACE_TEXT("CORBAValue"), // ST_VALUE + ACE_TEXT("void"), // ST_VOID + ACE_TEXT("CORBAException"), // ST_EX + ACE_TEXT("CORBAoctet"), // ST_OCTET + ACE_TEXT("CCMManages"), // ST_MANAGES + ACE_TEXT("CORBAwstring"), // ST_WSTR + ACE_TEXT("CORBAfloat"), // ST_FLOAT + ACE_TEXT("CORBAEnum"), // ST_ENUM + ACE_TEXT("CORBAValueSupports"), // ST_VAL_SUP + ACE_TEXT("CORBAModule"), // ST_MODULE + ACE_TEXT("CCMHomeFinder"), // ST_HFINDER + ACE_TEXT("CORBAdouble"), // ST_DOUBLE + ACE_TEXT("CORBAlonglong"), // ST_LL + ACE_TEXT("CCMHomeFactory"), // ST_HFACT + ACE_TEXT("CORBAArray"), // ST_ARR + ACE_TEXT("CCMComponent"), // ST_COMP + ACE_TEXT("CORBAshort"), // ST_SHORT + ACE_TEXT("CORBATypedef"), // ST_TYPEDEF + ACE_TEXT("CORBAunsignedlonglong"), // ST_ULL + ACE_TEXT("CORBAlong"), // ST_LONG + ACE_TEXT("CORBATypeCode"), // ST_TC + ACE_TEXT("CCMHome"), // ST_HOME + ACE_TEXT("CORBAStruct"), // ST_STRUCT + ACE_TEXT("CORBAFixed"), // ST_FIXED + ACE_TEXT("CORBAunsignedshort"), // ST_US + ACE_TEXT("CCMEmits"), // ST_EMITS + ACE_TEXT("CORBABoxedValue"), // ST_BOXVALUE + ACE_TEXT("CORBAboolean"), // ST_BOOL + ACE_TEXT("CORBAConstant"), // ST_CONST + ACE_TEXT("CCMPublishes"), // ST_PUBLISH + ACE_TEXT("CORBAConstants"), // ST_CONSTANTS + ACE_TEXT("CCMProvides"), // ST_PROVIDES + ACE_TEXT("CORBAwchar"), // ST_WCHAR + ACE_TEXT("CORBAunsignedlong"), // ST_UL + ACE_TEXT("CORBAValueFactory"), // ST_VAL_FACT + ACE_TEXT("CCMEvent"), // ST_EVENT + ACE_TEXT("CORBAchar"), // ST_CHAR + ACE_TEXT("CORBAInterface"), // ST_INTF + ACE_TEXT("CCMPrimaryKey"), // ST_PRI_KEY + ACE_TEXT("CORBAany"), // ST_ANY + ACE_TEXT("CORBAnative") // ST_NATIVE + }; + } +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/Literals.h b/modules/CIAO/tools/IDL3_to_XMI/Literals.h new file mode 100644 index 00000000000..e8c36180b30 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/Literals.h @@ -0,0 +1,170 @@ +/** + * @file Literals.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + * + */ + +#ifndef XMI_LITERALS_H +#define XMI_LITERALS_H + +#include "ace/config-lite.h" + +namespace CIAO +{ + namespace XMI + { + enum LITERAL_T + { + VERSION_TAG, + VERSION_VALUE, + NS_TAG, + NS_VALUE, + HEADER_TAG, + DOC_TAG, + EXPORTER_TAG, + EXPORTER_VALUE, + CONTENT_TAG, + MODEL_TAG, + XMI_ID, + OWNEDELEMENT_TAG, + PACKAGE_TAG, + MODELELEMENT_TAG, + ME_TV_TAG, + ME_CONS_TAG, + CONSTRAINT, + TV_TAG, + STEREOTYPE_TAG, + CLASS_TAG, + OP_TAG, + BFP_TAG, + PARAM_TAG, + BF_RE_TAG, + EXCEPT_TAG, + ATTR_TAG, + ASSOC_TAG, + ASSOC_CONN_TAG, + ASSOC_END_TAG, + ASSOC_END_QUAL_TAG, + GEN_TAG, + GEN_SUB_TAG, + GEN_SUPER_TAG, + GEN_ELEMENT_TAG, + GEN_ELEMENT_GEN_TAG, + EXCEPTION_TAG, + + // Attributes + TAG, + VALUE, + NAME, + BASEC, + VISIBIL, + STEREO_ATTR, + NS, + OWNER, + KIND, + BFEATURE, + TYPE, + ABSTRACT, + MULT, + IDREF, + OWNER_SCOPE, + CHANGEABLE, + + // attribute values + ASSOC, + CLASS, + DATATYPE, + PACKAGE, + __NULL, + ATTR, + PUBLIC, + _PRIVATE, + TYPEID, + RAISES, + RETURN, + _IN, + INOUT, + _OUT, + _TRUE, + _FALSE, + CAPS_TRUE, + CAPS_FALSE, + MULT_OTO, + MULT_ZTO, + IDLORDER, + INDEX, + CONST_UPPER, + UNBOUNDED_SEQ, + CASE, + DEFAULT_UNION, + CLASSIFIER, + FROZEN, + INIT_VAL, + + // Stereotypes + ST_CONSUMES, + ST_ANON_SEQ, + ST_PRINC, + ST_UNION, + ST_USES, + ST_SEQ, + ST_ROE, + ST_RO, + ST_OBJ, + ST_STR, + ST_LD, + ST_ANON_ARR, + ST_ALIAS, + ST_NULL, + ST_VALUE, + ST_VOID, + ST_EX, + ST_OCTET, + ST_MANAGES, + ST_WSTR, + ST_FLOAT, + ST_ENUM, + ST_VAL_SUP, + ST_MODULE, + ST_HFINDER, + ST_DOUBLE, + ST_LL, + ST_HFACT, + ST_ARR, + ST_COMP, + ST_SHORT, + ST_TYPEDEF, + ST_ULL, + ST_LONG, + ST_TC, + ST_HOME, + ST_STRUCT, + ST_FIXED, + ST_US, + ST_EMITS, + ST_BOXVALUE, + ST_BOOL, + ST_CONST, + ST_PUBLISH, + ST_CONSTANTS, + ST_PROVIDES, + ST_WCHAR, + ST_UL, + ST_VAL_FACT, + ST_EVENT, + ST_CHAR, + ST_INTF, + ST_PRI_KEY, + ST_ANY, + ST_NATIVE, + + MAX_LITERAL + }; + + extern const ACE_TCHAR* const LITERALS[MAX_LITERAL]; + } +} + +#endif /* XMI_LITERALS_H */ diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_extern.h b/modules/CIAO/tools/IDL3_to_XMI/be_extern.h new file mode 100644 index 00000000000..532b5ebe64e --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_extern.h @@ -0,0 +1,86 @@ +// This may look like C, but it's really -*- C++ -*- +// $Id$ +/* + +COPYRIGHT + +Copyright 1992, 1993, 1994 Sun Microsystems, Inc. Printed in the United +States of America. All Rights Reserved. + +This product is protected by copyright and distributed under the following +license restricting its use. + +The Interface Definition Language Compiler Front End (CFE) is made +available for your use provided that you include this license and copyright +notice on all media and documentation and the software program in which +this product is incorporated in whole or part. You may copy and extend +functionality (but may not remove functionality) of the Interface +Definition Language CFE without charge, but you are not authorized to +license or distribute it to anyone else except as part of a product or +program developed by you or with the express written consent of Sun +Microsystems, Inc. ("Sun"). + +The names of Sun Microsystems, Inc. and any of its subsidiaries or +affiliates may not be used in advertising or publicity pertaining to +distribution of Interface Definition Language CFE as permitted herein. + +This license is effective until terminated by Sun for failure to comply +with this license. Upon termination, you shall destroy or return all code +and documentation for the Interface Definition Language CFE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF +ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS +FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF +DEALING, USAGE OR TRADE PRACTICE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT +ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES +TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT. + +SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH +RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY +INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF. + +IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR +ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL +DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +Use, duplication, or disclosure by the government is subject to +restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in +Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR +52.227-19. + +Sun, Sun Microsystems and the Sun logo are trademarks or registered +trademarks of Sun Microsystems, Inc. + +SunSoft, Inc. +2550 Garcia Avenue +Mountain View, California 94043 + +NOTE: + +SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are +trademarks or registered trademarks of Sun Microsystems, Inc. + +*/ + +#ifndef TAO_IFR_BE_EXTERN_H +#define TAO_IFR_BE_EXTERN_H + +#include "CIAO_IDL3_TO_XMI_Export.h" +#include "be_global.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +extern CIAO_IDL3_TO_XMI_Export BE_GlobalData *be_global; + +extern CIAO_IDL3_TO_XMI_Export int BE_init (int &, ACE_TCHAR*[]); +extern CIAO_IDL3_TO_XMI_Export void BE_post_init (char *[], long); +extern CIAO_IDL3_TO_XMI_Export void BE_version (void); +extern CIAO_IDL3_TO_XMI_Export void BE_produce (void); +extern CIAO_IDL3_TO_XMI_Export void BE_cleanup (void); +extern CIAO_IDL3_TO_XMI_Export void BE_abort (void); + +#endif /* TAO_IFR_BE_EXTERN_H */ diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_global.cpp b/modules/CIAO/tools/IDL3_to_XMI/be_global.cpp new file mode 100644 index 00000000000..ceeb3f56ed6 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_global.cpp @@ -0,0 +1,222 @@ +// $Id$ + +// ============================================================================ +// +// +// = LIBRARY +// TAO_IDL3_TO_IDL2L_BE_DLL +// +// = FILENAME +// be_global.cpp +// +// = DESCRIPTION +// Stores global data specific to the compiler back end. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#include "be_global.h" +#include "ast_generator.h" +#include "global_extern.h" +#include "idl_defines.h" +#include "ace/OS_NS_stdio.h" + +CIAO_IDL3_TO_XMI_Export BE_GlobalData *be_global = 0; + +BE_GlobalData::BE_GlobalData (void) + : ir_filter_ (false), + filename_ (0), + output_dir_ (0), + dtd_ ("XMI.dtd"), + local_only_(true) +{ +} + +BE_GlobalData::~BE_GlobalData (void) +{ +} + +bool +BE_GlobalData::ir_filter (void) const +{ + return this->ir_filter_; +} + +void +BE_GlobalData::ir_filter (bool flag) +{ + this->ir_filter_ = flag; +} + +const char * +BE_GlobalData::filename (void) const +{ + return this->filename_; +} + +void +BE_GlobalData::filename (char *fname) +{ + this->filename_ = fname; +} + +const char* +BE_GlobalData::output_dir (void) const +{ + return this->output_dir_; +} + +void +BE_GlobalData::output_dir (const char* s) +{ + delete [] this->output_dir_; + this->output_dir_ = ACE::strnew (s); +} + +const char* +BE_GlobalData::dtd (void) const +{ + return this->dtd_.c_str (); +} + +void +BE_GlobalData::dtd (const char* s) +{ + this->dtd_ = s; +} + +bool +BE_GlobalData::local_only (void) const +{ + return this->local_only_; +} + +void +BE_GlobalData::local_only (bool flag) +{ + this->local_only_ = flag; +} + +void +BE_GlobalData::parse_args (long &i, char **av) +{ + switch (av[i][1]) + { + // Directory where the generated file is to + // be kept. Default is the current directory from which + // <tao_idl3_to_idl2> is called. + case 'f': + be_global->ir_filter (true); + break; + + case 'o': + switch (av[i][2]) + { + case 'd': + if (av[i][3] == '\0') + { + be_global->output_dir (av [i + 1]); + i++; + } + else + { + be_global->output_dir (av[i] + 3); + } + break; + + case 'f': + if (av[i][3] == '\0') + { + be_global->filename (av [i + 1]); + i++; + } + else + { + be_global->filename (av[i] + 3); + } + break; + default: + idl_global->set_compile_flags (idl_global->compile_flags () + | IDL_CF_ONLY_USAGE); + } + break; + + case 'x': + if (av[i][3] == '\0') + { + be_global->dtd (av [i + 1]); + ++i; + } + else + { + be_global->dtd (av[i] + 3); + } + break; + + case 'n': + be_global->local_only (false); + break; + + default: + ACE_ERROR (( + LM_ERROR, + ACE_TEXT ("IDL: I don't understand the '%s' option\n"), + av[i])); + + idl_global->set_compile_flags (idl_global->compile_flags () + | IDL_CF_ONLY_USAGE); + break; + } +} + +// Prepare an argument for a BE +void +BE_GlobalData::prep_be_arg (char *) +{ +} + +void +BE_GlobalData::arg_post_proc (void) +{ +} + +void +BE_GlobalData::usage (void) const +{ + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT (" -f\t\t\tsimulates IFR type filtering on included types\n") + )); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT (" -od <dir>\t\toutput directory for the generated file ") + ACE_TEXT ("(default is current directory)\n") + )); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT (" -of <dir>\t\toutput file for the generated XMI ") + ACE_TEXT ("(default for example.idl is example.xmi)\n") + )); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT (" -xd <dtd_file>\t\tfull path to XMI dtd file to include in generated file ") + ACE_TEXT ("(default is XMI.dtd)\n") + )); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT (" -n\t\t\texports XMI for non-local entities\n") + )); +} + +AST_Generator * +BE_GlobalData::generator_init (void) +{ + AST_Generator *gen = 0; + ACE_NEW_RETURN (gen, + AST_Generator, + 0); + return gen; +} + + +void +BE_GlobalData::destroy (void) +{ +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_global.h b/modules/CIAO/tools/IDL3_to_XMI/be_global.h new file mode 100644 index 00000000000..2092587d94a --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_global.h @@ -0,0 +1,103 @@ +/* -*- c++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO_IFR_BE_DLL +// +// = FILENAME +// be_global.h +// +// = DESCRIPTION +// Header file for class containing compiler back end global data. +// +// = AUTHOR +// Jeff Parsons <parsons@cs.wustl.edu> +// +// ============================================================================ + +#ifndef TAO_IFR_BE_GLOBAL_H +#define TAO_IFR_BE_GLOBAL_H + +#include "CIAO_IDL3_TO_XMI_Export.h" +#include "idl_defines.h" + +#include "ace/SString.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class AST_Generator; + +// Defines a class containing all back end global data. + +class CIAO_IDL3_TO_XMI_Export BE_GlobalData +{ +public: + // = TITLE + // BE_GlobalData + // + // = DESCRIPTION + // Storage of global data specific to the compiler back end + // + BE_GlobalData (void); + // Constructor. + + virtual ~BE_GlobalData (void); + // Destructor. + + // Data accessors. + bool ir_filter (void) const; + void ir_filter (bool flag); + + const char *filename (void) const; + void filename (char *fname); + + const char* output_dir (void) const; + void output_dir (const char* s); + + const char * dtd (void) const; + void dtd (const char *s); + + bool local_only (void) const; + void local_only (bool); + + void parse_args (long &i, char **av); + // Parse args that affect the backend. + + void prep_be_arg (char *s); + // Special BE arg call factored out of DRV_args. + + void arg_post_proc (void); + // Checks made after parsing args. + + void usage (void) const; + // Usage message for backend options. + + AST_Generator *generator_init (void); + // Create an AST node generator. + + void destroy (void); + // Cleanup. + +private: + bool ir_filter_; + + char *filename_; + // Name of the IDL file we are processing. + + char *output_dir_; + // Directory where the generated file is to be + // kept. Default value is 0 for this string which means the current + // directory from which the <tao_picml> is called. + + /// full path to dtd to be used. + ACE_CString dtd_; + + /// generate xmi for local entities only + bool local_only_; +}; + +#endif /* TAO_IFR_BE_GLOBAL_H */ diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_helper.cpp b/modules/CIAO/tools/IDL3_to_XMI/be_helper.cpp new file mode 100644 index 00000000000..4a7b28096c6 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_helper.cpp @@ -0,0 +1,438 @@ +// $Id$ + +// ============================================================================ +// +// +// = LIBRARY +// TAO IDL +// +// = FILENAME +// be_helper.cpp +// +// = DESCRIPTION +// Provides helper classes to print generated code to the output +// +// = AUTHOR +// Aniruddha Gokhale +// +// Improvements by Carlos O'Ryan +// +// ============================================================================ + +#include "be_helper.h" +#include "idl_defines.h" +#include "ace/OS_NS_stdio.h" +#include "ace/OS_NS_string.h" +#include "ace/os_include/os_ctype.h" + +ACE_RCSID (be, + be_helper, + "$Id$") + +static const char copyright[] = +" <--\n" +" -*- XML -*-\n" +"\n" +" $I" "d$\n\n" +" **** Code generated by the The ACE ORB (TAO) IDL Compiler ****\n" +" TAO and the TAO IDL Compiler have been developed by:\n" +" Center for Distributed Object Computing\n" +" Washington University\n" +" St. Louis, MO\n" +" USA\n" +" http:www.cs.wustl.edu/~schmidt/doc-center.html\n" +" and\n" +" Distributed Object Computing Laboratory\n" +" University of California at Irvine\n" +" Irvine, CA\n" +" USA\n" +" http:doc.ece.uci.edu/\n" +" and\n" +" Institute for Software Integrated Systems\n" +" Vanderbilt University\n" +" Nashville, TN\n" +" USA\n" +" http:www.isis.vanderbilt.edu/\n" +"\n" +" Information about TAO is available at:\n" +" http:www.cs.wustl.edu/~schmidt/TAO.html\n" +"-->"; + +TAO_NL::TAO_NL (void) +{ +} + +TAO_INDENT::TAO_INDENT (int do_now) + : do_now_ (do_now) +{ +} + +TAO_UNINDENT::TAO_UNINDENT (int do_now) + : do_now_ (do_now) +{ +} + +const TAO_NL be_nl; +const TAO_INDENT be_idt; +const TAO_INDENT be_idt_nl (1); +const TAO_UNINDENT be_uidt; +const TAO_UNINDENT be_uidt_nl (1); + +// Methods of the TAO_OutStream class. + +TAO_OutStream::TAO_OutStream (void) + : fp_ (0), + indent_level_ (0) +{ +} + +TAO_OutStream::~TAO_OutStream (void) +{ + // Close the underlying I/O handle only if it exists. + if (this->fp_ != 0) + { + ACE_OS::fclose (this->fp_); + this->fp_ = 0; + } + + indent_level_ = 0; +} + +int +TAO_OutStream::open (const char *fname) +{ + if (fname != 0) + { + // File name exists, open an I/O file handle. + this->fp_ = ACE_OS::fopen (fname, "w"); + + if (this->fp_ != 0) + { + // Put the copyright notice. + ACE_OS::fprintf (this->fp_, + "%s\n", + copyright); + + ACE_OS::fflush (this->fp_); + + return 0; + } + else + { + return -1; + } + } + else + { + return -1; + } +} + +// Return the underlying lowlevel file pointer. +// indentation. +FILE * +TAO_OutStream::file (void) +{ + return this->fp_; +} + +int +TAO_OutStream::incr_indent (unsigned short flag) +{ + indent_level_++; + + if (flag != 0) + { + return this->indent (); + } + else + { + // Do not indent output. + return 0; + } +} + +// Indentation +int +TAO_OutStream::decr_indent (unsigned short flag) +{ + this->indent_level_--; + // Just in case somebody gets "unindent happy". + if (this->indent_level_ < 0) + { + // ACE_DEBUG ((LM_DEBUG, "negative indentation?\n")); + this->indent_level_ = 0; + } + if (flag != 0) + { + return this->indent (); + } + else + { + // Do not indent output. + return 0; + } +} + +int +TAO_OutStream::reset (void) +{ + this->indent_level_ = 0; + return 0; +} + +// Indented print. +int +TAO_OutStream::indent (void) +{ + // Based on the current indentation level, leave appropriate number of blank + // spaces in the output. + if (this->indent_level_ > 0) + { + for (int i = 0; i < this->indent_level_; i++) + { + ACE_OS::fprintf (this->fp_, " "); + ACE_OS::fflush (this->fp_); + } + } + + return 0; +} + +int +TAO_OutStream::nl (void) +{ + ACE_OS::fprintf (this->fp_, "\n"); + this->indent (); + return 0; +} + +// Printf style variable argument print. +int +TAO_OutStream::print (const char *format, ...) +{ + int result = 0; + va_list ap; + va_start (ap, format); + ACE_OSCALL (::vfprintf (this->fp_, + format, + ap), + int, + -1, + result); + + ACE_OS::fflush (this->fp_); + va_end (ap); + + return result; +} + +void +TAO_OutStream::gen_ifndef_string (const char *fname, + const char *prefix, + const char *suffix) +{ + static char macro_name [NAMEBUFSIZE]; + + ACE_OS::memset (macro_name, + '\0', + NAMEBUFSIZE); + + const char *extension = ACE_OS::strrchr (fname, '.'); + + if (extension == 0) + { + // File seems to have no extension, so let us take the name + // as it is. + extension = fname; + } + + ACE_OS::sprintf (macro_name, prefix); + + size_t offset = ACE_OS::strlen (prefix); + + // Convert letters in fname to upper case. + for (int i = 0; i < (extension - fname); i++) + { + if (isalpha (fname [i])) + { + macro_name[i + offset] = (char) toupper (fname [i]); + } + else if (isdigit (fname [i])) + { + macro_name[i + offset] = fname[i]; + } + else + { + macro_name[i + offset] = '_'; + } + } + + ACE_OS::strcat (macro_name, suffix); + + // Generate the #ifndef ... #define statements. + this->print ("#ifndef %s\n", + macro_name); + this->print ("#define %s", + macro_name); +} + +TAO_OutStream & +TAO_OutStream::operator<< (const char *str) +{ + ACE_OS::fprintf (this->fp_, "%s", str); + ACE_OS::fflush (this->fp_); + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::UShort num) +{ + ACE_OS::fprintf (this->fp_, + "%hu", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::Short num) +{ + ACE_OS::fprintf (this->fp_, + "%hd", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::ULong num) +{ + ACE_OS::fprintf (this->fp_, + "%lu", + (unsigned long) num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::Long num) +{ + ACE_OS::fprintf (this->fp_, + "%ld", + (long) num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +#if defined (ACE_WIN64) +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::ULongLong num) +{ + ACE_OS::fprintf (this->fp_, + ACE_UINT64_FORMAT_SPECIFIER, + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const ACE_CDR::LongLong num) +{ + ACE_OS::fprintf (this->fp_, + ACE_INT64_FORMAT_SPECIFIER, + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} +#endif /* ACE_WIN64 */ + +TAO_OutStream & +TAO_OutStream::operator<< (const unsigned long num) +{ + ACE_OS::fprintf (this->fp_, + "%lu", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const long num) +{ + ACE_OS::fprintf (this->fp_, + "%ld", + num); + + ACE_OS::fflush (this->fp_); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_NL&) +{ + ACE_OS::fprintf (this->fp_ , + "\n"); + this->indent (); + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_INDENT& i) +{ + this->incr_indent (0); + + if (i.do_now_) + { + this->nl (); + } + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (const TAO_UNINDENT& i) +{ + this->decr_indent (0); + + if (i.do_now_) + { + this->nl (); + } + + return *this; +} + +TAO_OutStream & +TAO_OutStream::operator<< (Identifier *id) +{ + return this->print (id); +} + +TAO_OutStream & +TAO_OutStream::operator<< (UTL_IdList *id) +{ + return this->print (id); +} + +TAO_OutStream & +TAO_OutStream::operator<< (AST_Expression *expr) +{ + return this->print (expr); +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_helper.h b/modules/CIAO/tools/IDL3_to_XMI/be_helper.h new file mode 100644 index 00000000000..d8bbb3b1766 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_helper.h @@ -0,0 +1,176 @@ +/* -*- c++ -*- */ +// $Id$ + +/** + * @file be_helper.h + * @author Aniruddha Gokhale + * @author Carlos O'Ryan + * + * Defines the abstract class for outputting the C++ mapping. This is a + * helper class to the singleton TAO_CodeGen class + */ + +#ifndef TAO_BE_OUTSTRM_H +#define TAO_BE_OUTSTRM_H + +#include "ace/CDR_Base.h" + +class Identifier; +class UTL_IdList; +class AST_Expression; + +// a dummy structure to inform TAO_OutStream's << operator to put a newline +// and use the current indentation for the succeeding line +struct TAO_NL +{ +public: + TAO_NL (void); +}; + +struct TAO_INDENT +{ + // = TITLE + // Operates like a manipulator, increasing the indentation level. + // + // = DESCRIPTION + // Increase the indentation level, if the "do_now" parameter is + // not zero then the <indent> method is called on the stream. + // + TAO_INDENT (int do_now = 0); + + const int do_now_; +}; + +struct TAO_UNINDENT +{ + // = TITLE + // Operates like a manipulator, decreasing the indentation level. + // + // = DESCRIPTION + // Decrease the indentation level, if the "do_now" parameter is + // not zero then the <indent> method is called on the stream. + // + TAO_UNINDENT (int do_now = 0); + + const int do_now_; +}; + +extern const TAO_NL be_nl; +extern const TAO_INDENT be_idt; +extern const TAO_INDENT be_idt_nl; +extern const TAO_UNINDENT be_uidt; +extern const TAO_UNINDENT be_uidt_nl; + +class TAO_OutStream +{ + // =TITLE + // TAO_OutStream + // + // =DESCRIPTION + // Defines an interface by which the backend code generator can + // print its output to the underlying I/O handle. This is a + // helper class that will be used by the TAO_CodeGen + // class. However, this is an abstract class and classes that + // understand specific front ends must derive from this class. +public: + TAO_OutStream (void); + // constructor. + + virtual ~TAO_OutStream (void); + // destructor. + + int open (const char *fname); + // open the underlying low-level handle for output. + + + FILE *file (void); + // Return the underlying lowlevel file pointer. + + int incr_indent (unsigned short flag = 1); + // increment the indentation level and by default actually indent the output + // accordingly + + int decr_indent (unsigned short flag = 1); + // decrease the indentation level and by default actually indent the output + // accordingly + + int reset (void); + // reset indentation level to 0 + + int indent (void); + // indent starting next line + + int nl (void); + // put a newline and indent on the next line + + int print (const char *format, ...); + // "printf" style variable argument print + + void gen_ifndef_string (const char *fname, + const char *prefix, + const char *suffix); + + // =overloaded operators + + TAO_OutStream &operator<< (const char *str); + // output the char string and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::UShort num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::Short num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::ULong num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::Long num); + // output the integer and return a reference to ourselves + +#if defined (ACE_WIN64) + TAO_OutStream &operator<< (const ACE_CDR::ULongLong num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const ACE_CDR::LongLong num); + // output the integer and return a reference to ourselves +#endif /* ACE_WIN64 */ + + TAO_OutStream &operator<< (const unsigned long num); + // output the integer and return a reference to ourselves + + TAO_OutStream &operator<< (const long num); + // output the integer and return a reference to ourselves + + // = MANIPULATORS + + TAO_OutStream &operator<< (const TAO_NL& nl); + TAO_OutStream &operator<< (const TAO_INDENT& i); + TAO_OutStream &operator<< (const TAO_UNINDENT& i); + + // The following will be provided by specialized classes + + TAO_OutStream &operator<< (Identifier *id); + // output an Identifier node + + TAO_OutStream &operator<< (UTL_IdList *idl); + // output a scoped name + + TAO_OutStream &operator<< (AST_Expression *expr); + // output an AST_Expression node + + // provided by specialized classes + virtual TAO_OutStream &print (Identifier *id) = 0; + + virtual TAO_OutStream &print (UTL_IdList *idl) = 0; + + virtual TAO_OutStream &print (AST_Expression *idl) = 0; + +protected: + FILE *fp_; + // the underlying low-level I/O handle + + int indent_level_; + // indentation level +}; + +#endif // if !defined diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_init.cpp b/modules/CIAO/tools/IDL3_to_XMI/be_init.cpp new file mode 100644 index 00000000000..7863fcae9d8 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_init.cpp @@ -0,0 +1,31 @@ +// $Id$ + +#include "global_extern.h" +#include "be_extern.h" +#include "../../ciao/Version.h" + +CIAO_IDL3_TO_XMI_Export void +BE_version (void) +{ + ACE_DEBUG ((LM_DEBUG, + "%s %s\n", + ACE_TEXT ("TAO_ID3_TO_IDL2_BE, version"), + ACE_TEXT (CIAO_VERSION))); +} + +CIAO_IDL3_TO_XMI_Export int +BE_init (int & /* argc */, ACE_TCHAR * /* argv */ []) +{ + // Initialize BE global data object. + ACE_NEW_RETURN (be_global, + BE_GlobalData, + -1); + + idl_global->pass_orb_idl (true); + return 0; +} + +CIAO_IDL3_TO_XMI_Export void +BE_post_init (char * /* files */ [], long /* nfiles */) +{ +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_produce.cpp b/modules/CIAO/tools/IDL3_to_XMI/be_produce.cpp new file mode 100644 index 00000000000..7a66096bd32 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_produce.cpp @@ -0,0 +1,139 @@ +// $Id$ + +/* + +COPYRIGHT + +Copyright 1992, 1993, 1994 Sun Microsystems, Inc. Printed in the United +States of America. All Rights Reserved. + +This product is protected by copyright and distributed under the following +license restricting its use. + +The Interface Definition Language Compiler Front End (CFE) is made +available for your use provided that you include this license and copyright +notice on all media and documentation and the software program in which +this product is incorporated in whole or part. You may copy and extend +functionality (but may not remove functionality) of the Interface +Definition Language CFE without charge, but you are not authorized to +license or distribute it to anyone else except as part of a product or +program developed by you or with the express written consent of Sun +Microsystems, Inc. ("Sun"). + +The names of Sun Microsystems, Inc. and any of its subsidiaries or +affiliates may not be used in advertising or publicity pertaining to +distribution of Interface Definition Language CFE as permitted herein. + +This license is effective until terminated by Sun for failure to comply +with this license. Upon termination, you shall destroy or return all code +and documentation for the Interface Definition Language CFE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF +ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS +FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF +DEALING, USAGE OR TRADE PRACTICE. + +INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT +ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES +TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT. + +SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH +RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY +INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF. + +IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR +ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL +DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +Use, duplication, or disclosure by the government is subject to +restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in +Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR +52.227-19. + +Sun, Sun Microsystems and the Sun logo are trademarks or registered +trademarks of Sun Microsystems, Inc. + +SunSoft, Inc. +2550 Garcia Avenue +Mountain View, California 94043 + +NOTE: + +SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are +trademarks or registered trademarks of Sun Microsystems, Inc. + + */ + +#include "CIAO_IDL3_TO_XMI_Export.h" +#include "global_extern.h" +#include "be_extern.h" +#include "fe_extern.h" +#include "ast_root.h" +#include "IDL3_to_XMI_visitor.h" +#include "IR_Simulator_visitor.h" +#include <xercesc/util/PlatformUtils.hpp> + +// Clean up before exit, whether successful or not. +CIAO_IDL3_TO_XMI_Export void +BE_cleanup (void) +{ + idl_global->destroy (); +} + +// Abort this run of the BE. +CIAO_IDL3_TO_XMI_Export void +BE_abort (void) +{ + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Fatal Error - Aborting\n"))); + + // BE_cleanup will be called after the exception is caught. + BE_cleanup (); +} + +// Do the work of this BE. This is the starting point for code generation. +CIAO_IDL3_TO_XMI_Export void +BE_produce (void) +{ + // Get the root node. + AST_Decl *d = idl_global->root (); + AST_Root *ast_root = AST_Root::narrow_from_decl (d); + + if (ast_root == 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce - ") + ACE_TEXT ("No Root\n"))); + BE_abort (); + } + + xercesc::XMLPlatformUtils::Initialize (); + + if (be_global->ir_filter ()) + { + CIAO::XMI::ir_simulator_visitor visitor; + + if (visitor.visit_root (ast_root) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("error: an error occured in the ir_simulator visitor."))); + xercesc::XMLPlatformUtils::Terminate (); + BE_cleanup (); + return; + } + } + + CIAO::XMI::idl3_to_xmi_visitor visitor (be_global->ir_filter ()); + + if (visitor.visit_root (ast_root) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("(%N:%l) BE_produce -") + ACE_TEXT (" failed to accept visitor\n"))); + } + + xercesc::XMLPlatformUtils::Terminate (); + + // Clean up. + BE_cleanup (); +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.cpp b/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.cpp new file mode 100644 index 00000000000..30126f74451 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.cpp @@ -0,0 +1,193 @@ +// $Id$ + +#include "be_sunsoft.h" +#include "ast_expression.h" +#include "utl_identifier.h" +#include "utl_idlist.h" +#include "utl_string.h" +#include "ace/OS_NS_stdio.h" +#include "ace/OS_NS_string.h" +#include "ace/OS_NS_ctype.h" + +ACE_RCSID (be, + be_sunsoft, + "$Id$") + +TAO_SunSoft_OutStream::TAO_SunSoft_OutStream (void) + : TAO_OutStream () +{ +} + +TAO_SunSoft_OutStream::~TAO_SunSoft_OutStream (void) +{ +} + +TAO_OutStream & +TAO_SunSoft_OutStream::print (Identifier *id) +{ + ACE_OS::fprintf (this->fp_, + id->get_string ()); + + return *this; +} + +TAO_OutStream & +TAO_SunSoft_OutStream::print (UTL_IdList *idl) +{ + long first = true; + long second = false; + Identifier *id = 0; + + for (UTL_IdListActiveIterator i (idl); !i.is_done (); i.next ()) + { + if (!first) + { + *this << "::"; + } + else if (second) + { + first = second = false; + } + + // Print the identifier. + id = i.item (); + *this << id; + + if (first) + { + if (ACE_OS::strcmp (id->get_string (), "") != 0) + { + // Does not start with a "". + first = false; + } + else + { + second = true; + } + } + } + + return *this; +} + +TAO_OutStream& +TAO_SunSoft_OutStream::print (AST_Expression *expr) +{ + AST_Expression::AST_ExprValue *ev = expr->ev (); + + if (ev) + { + switch (ev->et) + { + case AST_Expression::EV_short: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII, ev->u.sval); + break; + case AST_Expression::EV_ushort: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.usval, 'U'); + break; + case AST_Expression::EV_long: + this->TAO_OutStream::print (ACE_INT32_FORMAT_SPECIFIER_ASCII, ev->u.lval); + break; + case AST_Expression::EV_ulong: + this->TAO_OutStream::print (ACE_UINT32_FORMAT_SPECIFIER_ASCII "%c", ev->u.ulval, 'U'); + break; + // The ACE_LACKS_LONGLONG_T guards have been removed around + // the next 2 cases since the macros now used should work + // whether native 64-bit integers are defined or not. + case AST_Expression::EV_longlong: + this->TAO_OutStream::print ("ACE_INT64_LITERAL ("); + this->TAO_OutStream::print (ACE_INT64_FORMAT_SPECIFIER_ASCII, + ev->u.llval); + this->TAO_OutStream::print (")"); + break; + case AST_Expression::EV_ulonglong: + this->TAO_OutStream::print ("ACE_UINT64_LITERAL ("); + this->TAO_OutStream::print (ACE_UINT64_FORMAT_SPECIFIER_ASCII, + ev->u.ullval); + this->TAO_OutStream::print (")"); + break; + case AST_Expression::EV_float: + this->TAO_OutStream::print ("%f%c", ev->u.fval, 'F'); + break; + case AST_Expression::EV_double: + this->TAO_OutStream::print ("%24.16G", ev->u.dval); + break; + case AST_Expression::EV_longdouble: + break; + case AST_Expression::EV_char: + // isprint() sees \ and ' as printable characters + // so we have to test for them first. + if (ev->u.cval == '\\') + this->TAO_OutStream::print ("'\\\\'"); + else if (ev->u.cval == '\'') + this->TAO_OutStream::print ("'\\''"); + + // This handles hex and octal escape sequences + // that would print out either as weird characters + // or as an unsigned number too large for a char. + else if ((unsigned char) ev->u.cval > ACE_CHAR_MAX) + this->TAO_OutStream::print ("%hd", ev->u.cval); + else if (ACE_OS::ace_isprint (ev->u.cval)) + this->TAO_OutStream::print ("'%c'", ev->u.cval); + else if (ACE_OS::ace_iscntrl (ev->u.cval)) + switch (ev->u.cval) + { + case '\n': + this->TAO_OutStream::print ("'\\n'"); + break; + case '\t': + this->TAO_OutStream::print ("'\\t'"); + break; + case '\r': + this->TAO_OutStream::print ("'\\r'"); + break; + case '\v': + this->TAO_OutStream::print ("'\\v'"); + break; + case '\f': + this->TAO_OutStream::print ("'\\f'"); + break; + case '\b': + this->TAO_OutStream::print ("'\\b'"); + break; + case '\a': + this->TAO_OutStream::print ("'\\a'"); + break; + case '\?': + this->TAO_OutStream::print ("'?'"); + break; + default: + this->TAO_OutStream::print ("'\\x%x'", ev->u.cval); + } + else + this->TAO_OutStream::print ("'\\x%x'", ev->u.cval); + break; + case AST_Expression::EV_wchar: + this->TAO_OutStream::print ("L'%lc'", ev->u.wcval); + break; + case AST_Expression::EV_octet: + this->TAO_OutStream::print ("%d", ev->u.oval); + break; + case AST_Expression::EV_bool: + this->TAO_OutStream::print ("%s", ev->u.bval ? "true" : "false"); + break; + case AST_Expression::EV_string: + this->TAO_OutStream::print ("\"%s\"", ev->u.strval->get_string ()); + break; + case AST_Expression::EV_wstring: + this->TAO_OutStream::print ("L\"%s\"", ev->u.wstrval); + break; + case AST_Expression::EV_enum: + this->print (expr->n ()); + break; + default: + break; + } + } + else + { + // XXXASG: need to add code here + } + + return *this; +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.h b/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.h new file mode 100644 index 00000000000..5aef8a66d4d --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/be_sunsoft.h @@ -0,0 +1,39 @@ +/* -*- c++ -*- */ +// $Id$ + +/** + * @file be_sunsoft.h + * + * Sunsoft backend output generation. + */ + +#ifndef TAO_BE_HELPER_H +#define TAO_BE_HELPER_H + +#include "be_helper.h" + +class TAO_SunSoft_OutStream : public TAO_OutStream +{ + // =TITLE + // TAO_SunSoft_OutStream + // =DESCRIPTION + // Backend specific to SunSoft AST nodes +public: + TAO_SunSoft_OutStream (void); + // constructor + + ~TAO_SunSoft_OutStream (void); + // destuctor + + virtual TAO_OutStream &print (Identifier *id); + // output the SunSoft IDL Identifier Node + + virtual TAO_OutStream &print (UTL_IdList *idl); + // output the SunSoft IDL UTL_IdList Node which is usually used to maintain a + // scoped name + + virtual TAO_OutStream &print (AST_Expression *expr); + // output the contents of the AST_Expression node +}; + +#endif // if !defined diff --git a/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.cpp b/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.cpp new file mode 100644 index 00000000000..dc540554f18 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.cpp @@ -0,0 +1,115 @@ +/* -*- c++ -*- */ +// $Id$ + +#include "identifier_helper.h" +#include "utl_identifier.h" +#include "utl_string.h" +#include "global_extern.h" + +Identifier * +IdentifierHelper::original_local_name (Identifier * local_name) +{ + Identifier * id = 0; + + // Remove _cxx_ if it is present. + if (ACE_OS::strstr (local_name->get_string (), + "_cxx_") + == local_name->get_string ()) + { + // CString class is good to do this stuff. + ACE_CString name_str (local_name->get_string ()); + + // Remove _cxx_. + name_str = name_str.substr (ACE_OS::strlen ("_cxx_")); + + // Assign to the Identifier variable. + ACE_NEW_RETURN (id, + Identifier (name_str.c_str ()), + 0); + } + else + { + id = local_name->copy (); + } + + return id; +} + + +ACE_CString +IdentifierHelper::orig_sn (UTL_IdList * sn, bool appended_to) +{ + ACE_CString retval; + bool first = true; + bool second = false; + Identifier *id = 0; + + for (UTL_IdListActiveIterator i (sn); !i.is_done ();) + { + if (!first) + { + retval += "::"; + } + else if (second) + { + first = second = false; + } + + id = IdentifierHelper::original_local_name (i.item ()); + i.next (); + + // Append the identifier. + retval += + appended_to && i.is_done () + ? id->get_string () + : IdentifierHelper::try_escape (id).c_str (); + + if (first) + { + if (ACE_OS::strcmp (id->get_string (), "") != 0) + { + // Does not start with a "". + first = false; + } + else + { + second = true; + } + } + + id->destroy (); + delete id; + id = 0; + } + + return retval; +} + +bool +IdentifierHelper::is_idl_keyword (Identifier * local_name) +{ + UTL_String utl_tmp (local_name->get_string ()); + ACE_CString ext_id (utl_tmp.get_canonical_rep (), + 0, + false); + + int status = idl_global->idl_keywords ().find (ext_id); + utl_tmp.destroy (); + + return status == 0; +} + +ACE_CString +IdentifierHelper::try_escape (Identifier * local_name) +{ + ACE_CString s_local_name (local_name->get_string ()); + + if (IdentifierHelper::is_idl_keyword (local_name)) + { + return "_" + s_local_name; + } + else + { + return s_local_name; + } +} diff --git a/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.h b/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.h new file mode 100644 index 00000000000..a414b8fadd5 --- /dev/null +++ b/modules/CIAO/tools/IDL3_to_XMI/identifier_helper.h @@ -0,0 +1,64 @@ +// $Id$ + +/* -*- c++ -*- */ +// ============================================================================ +// +// = LIBRARY +// TAO_IDL3_TO_IDL2_BE_DLL +// +// = FILENAME +// identifier_helper.h +// +// = DESCRIPTION +// Utilities associated with UTL_Identifier. +// +// = AUTHOR +// Jeff Parsons <j.parsons@vanderbilt.edu> +// +// ============================================================================ + +#ifndef IDENTIFIER_HELPER_H +#define IDENTIFIER_HELPER_H + +#include "utl_scoped_name.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "ace/SString.h" + +class Identifier; + +struct IdentifierHelper +{ + // + // = TITLE + // IdentifierHelper. + // + // = DESCRIPTION + // 1) keeps escape (leading underscore character in generated + // identifier in IDL + // 2) removes the '_' escape character when the identifier is + // part of another identifier such as in provides_XXX + // 3) removes any '_cxx_' in generated IDL + + static Identifier * + original_local_name (Identifier * local_name); + + // Removes '_cxx_ from segments of a scoped name, and optionally + // de-escape the last segment, if it's to be appended to. + static ACE_CString + orig_sn (UTL_ScopedName * scoped_name, bool appended_to = false); + + // Detects case-insensitive match with IDL keyword. + static bool + is_idl_keyword (Identifier * local_name); + + // Preserves the 'escape' (leading underscore) in a + // generated identifier if necessary. + static ACE_CString + try_escape (Identifier * local_name); +}; + +#endif /* IDENTIFIER_HELPER_H */ diff --git a/modules/CIAO/tools/XML/CIAO_XML_Utils_Export.h b/modules/CIAO/tools/XML/CIAO_XML_Utils_Export.h new file mode 100644 index 00000000000..f4f3ec3a1cd --- /dev/null +++ b/modules/CIAO/tools/XML/CIAO_XML_Utils_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl CIAO_XML_Utils +// ------------------------------ +#ifndef CIAO_XML_UTILS_EXPORT_H +#define CIAO_XML_UTILS_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (CIAO_XML_UTILS_HAS_DLL) +# define CIAO_XML_UTILS_HAS_DLL 1 +#endif /* ! CIAO_XML_UTILS_HAS_DLL */ + +#if defined (CIAO_XML_UTILS_HAS_DLL) && (CIAO_XML_UTILS_HAS_DLL == 1) +# if defined (CIAO_XML_UTILS_BUILD_DLL) +# define CIAO_XML_Utils_Export ACE_Proper_Export_Flag +# define CIAO_XML_UTILS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CIAO_XML_UTILS_BUILD_DLL */ +# define CIAO_XML_Utils_Export ACE_Proper_Import_Flag +# define CIAO_XML_UTILS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CIAO_XML_UTILS_BUILD_DLL */ +#else /* CIAO_XML_UTILS_HAS_DLL == 1 */ +# define CIAO_XML_Utils_Export +# define CIAO_XML_UTILS_SINGLETON_DECLARATION(T) +# define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CIAO_XML_UTILS_HAS_DLL == 1 */ + +// Set CIAO_XML_UTILS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CIAO_XML_UTILS_NTRACE) +# if (ACE_NTRACE == 1) +# define CIAO_XML_UTILS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CIAO_XML_UTILS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CIAO_XML_UTILS_NTRACE */ + +#if (CIAO_XML_UTILS_NTRACE == 1) +# define CIAO_XML_UTILS_TRACE(X) +#else /* (CIAO_XML_UTILS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CIAO_XML_UTILS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CIAO_XML_UTILS_NTRACE == 1) */ + +#endif /* CIAO_XML_UTILS_EXPORT_H */ + +// End of auto generated file. diff --git a/modules/CIAO/tools/XML/XML.mpc b/modules/CIAO/tools/XML/XML.mpc new file mode 100644 index 00000000000..398f2cfdd55 --- /dev/null +++ b/modules/CIAO/tools/XML/XML.mpc @@ -0,0 +1,13 @@ +// $Id$ + +project (CIAO_XML_Utils) : acelib, xerces, ciao_lib { + sharedname += CIAO_XML_Utils + dynamicflags = CIAO_XML_UTILS_BUILD_DLL + includes += .. + + Source_Files { + XML_Error_Handler.cpp + XercesString.cpp + XML_Schema_Resolver.cpp + } +} diff --git a/modules/CIAO/tools/XML/XML_Error_Handler.cpp b/modules/CIAO/tools/XML/XML_Error_Handler.cpp new file mode 100644 index 00000000000..ba24b817649 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Error_Handler.cpp @@ -0,0 +1,70 @@ +// $Id$ + +#include "XML_Error_Handler.h" +#include "ace/Log_Msg.h" +#include "ace/Auto_Ptr.h" +#include <xercesc/util/XMLString.hpp> +#include <xercesc/dom/DOMLocator.hpp> +#include <xercesc/sax/SAXParseException.hpp> +#include "XercesString.h" +#include <iostream> + +using xercesc::SAXParseException; + +namespace CIAO +{ + namespace XML + { + XML_Error_Handler::XML_Error_Handler (void) + : errors_ (false) + { + } + + XML_Error_Handler::~XML_Error_Handler() + { + } + + void XML_Error_Handler::warning(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Warning: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + } + + void XML_Error_Handler::error(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Error: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + this->errors_ = true; + } + + void XML_Error_Handler::fatalError(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Fatal Error: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + this->errors_ = true; + } + + void XML_Error_Handler::resetErrors() + { + this->errors_ = false; + } + + bool + XML_Error_Handler::getErrors (void) const + { + return this->errors_; + } + } +} diff --git a/modules/CIAO/tools/XML/XML_Error_Handler.h b/modules/CIAO/tools/XML/XML_Error_Handler.h new file mode 100644 index 00000000000..7cc65bf86a1 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Error_Handler.h @@ -0,0 +1,63 @@ +//============================================================== +/** + * @file XML_Error_Handler.h + * + * $Id$ + * + * @brief Error handler for Xerces + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//================================================================ +#ifndef CIAO_XML_ERROR_HANDLER_H +#define CIAO_XML_ERROR_HANDLER_H + +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "XML/CIAO_XML_Utils_Export.h" + +#include <xercesc/sax/ErrorHandler.hpp> + +using xercesc::SAXParseException; + +namespace CIAO +{ + namespace XML + { + /** + * @class XML_Error_Hander + * + * @brief Error handler for XERCES + * + */ + class CIAO_XML_Utils_Export XML_Error_Handler + : public xercesc::ErrorHandler + { + public: + + XML_Error_Handler (void); + + ~XML_Error_Handler (void); + + void warning(const SAXParseException& toCatch); + void error(const SAXParseException& toCatch); + void fatalError(const SAXParseException& toCatch); + void resetErrors(); + bool getErrors (void) const; + private : + // Disallow copying + XML_Error_Handler (const XML_Error_Handler&); + XML_Error_Handler& operator= (const XML_Error_Handler&); + + bool errors_; + }; + } +} + +#include /**/ "ace/post.h" + +#endif /* CIAO_XML_ERROR_HANDLER_H*/ diff --git a/modules/CIAO/tools/XML/XML_Helper.h b/modules/CIAO/tools/XML/XML_Helper.h new file mode 100644 index 00000000000..69f887cbe40 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Helper.h @@ -0,0 +1,100 @@ +// $Id$ +//============================================================ +/** + * @file XML_Helper.h + * + * @brief Some helper functions for XML + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + * @author William R. Otte <wotte@dre.vanderbilt.edu> + */ +//============================================================ +#ifndef CIAO_XML_HELPER_H +#define CIAO_XML_HELPER_H +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ +#include "XML/CIAO_XML_Utils_Export.h" +#include "XML/XML_Error_Handler.h" +#include "XML/XML_Schema_Resolver.h" + +#include "xercesc/util/XercesDefs.hpp" +#include "xercesc/parsers/XercesDOMParser.hpp" + +#include <memory> + +namespace XERCES_CPP_NAMESPACE +{ + class DOMDocument; + class DOMWriter; + class DOMImplementation; + class DOMDocumentType; +} + +namespace CIAO +{ + namespace XML + { + /** + * @class XML_Helper + * + * @brief Helper class for some routine XML stuff. + */ + template <typename Resolver = XML_Schema_Resolver <>, + typename Error_Handler = XML_Error_Handler> + class XML_Helper + { + public: + // XML_Helper (void); + + // Initialize the resolver we should use. + XML_Helper (Resolver &resolver, Error_Handler &eh); + + ~XML_Helper (void); + + /// Create a DOM tree + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *uri) const; + + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns, + XERCES_CPP_NAMESPACE::DOMDocumentType * doctype = 0) const; + + XERCES_CPP_NAMESPACE::DOMDocumentType * + create_doctype (const ACE_TCHAR *qn, + const ACE_TCHAR *pid, + const ACE_TCHAR *sid) const; + + //Writes out a DOMDocument to an XML file + bool write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file) const; + + bool is_initialized (void) const; + + protected: + /// Intialize the parser + void init_parser (void); + + /// Terminate the parser + void terminate_parser (void); + + private: + bool initialized_; + XERCES_CPP_NAMESPACE::DOMImplementation *impl_; + mutable std::auto_ptr<XERCES_CPP_NAMESPACE::XercesDOMParser> parser_; + + Resolver &resolver_; + Error_Handler &e_handler_; + }; + + + } +} + +#include "XML_Helper.tpp" + +#include /**/ "ace/post.h" +#endif/*CIAO_CONFIG_HANDLERS_XML_HELPER_H*/ diff --git a/modules/CIAO/tools/XML/XML_Helper.tpp b/modules/CIAO/tools/XML/XML_Helper.tpp new file mode 100644 index 00000000000..a21ca5db698 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Helper.tpp @@ -0,0 +1,304 @@ +//$Id$ +#include "XML_Helper.h" +#include "ace/Auto_Ptr.h" +#include "ace/Log_Msg.h" +//#include "ciao/Logger/Log_Macros.h" +#include "xercesc/util/XMLUniDefs.hpp" +#include "xercesc/dom/DOM.hpp" +#include "XML_Error_Handler.h" +#include "XML_Schema_Resolver.h" +#include "xercesc/framework/LocalFileFormatTarget.hpp" +#include "xercesc/dom/DOM.hpp" +#include "XercesString.h" + +#if XERCES_VERSION_MAJOR == 3 +#include "xercesc/dom/DOMLSSerializer.hpp" +#endif + +namespace CIAO +{ + namespace XML + { + using xercesc::XMLException; + using xercesc::XMLString; + using xercesc::DOMImplementation; + using xercesc::DOMImplementationRegistry; +// using xercesc::DOMBuilder; + using xercesc::DOMImplementationLS; + using xercesc::XMLUni; + using xercesc::DOMDocument; + using xercesc::DOMException; + using xercesc::DOMDocumentType; + using xercesc::XercesDOMParser; +/* + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::XML_Helper (void) + : initialized_ (false) + { + this->init_parser (); + } +*/ + // TODO this is stub implementation + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::XML_Helper (Resolver &resolver, Error &eh) + : initialized_ (false), + resolver_ (resolver), + e_handler_ (eh) + { + this->init_parser (); + } + + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::~XML_Helper (void) + { + this->terminate_parser (); + } + + template <typename Resolver, typename Error> + bool + XML_Helper<Resolver, Error>::is_initialized (void) const + { + return this->initialized_ == true; + } + + template <typename Resolver, typename Error> + void + XML_Helper<Resolver, Error>::init_parser (void) + { + if (this->initialized_) + return; + + // CIAO_DEBUG ((LM_TRACE, CLINFO + //"XML_Helper<>::is_initialized - Initializing the Xerces runtime \n")); + // Initialize the Xerces run-time + try + { + xercesc::XMLPlatformUtils::Initialize(); + } + catch (const XMLException& e) + { + char* message = + XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + + throw; + } + catch (...) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Some other exception," + " returning\n")); + + return; + } + + // Instantiate the DOM parser. + static const XMLCh gLS[] = { xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull }; + + // Get an implementation of the Load-Store (LS) interface + // and cache it for later use + impl_ = + DOMImplementationRegistry::getDOMImplementation(gLS); + + this->initialized_ = true; + return; + } + + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns, + DOMDocumentType *doctype) const + { + if (root == 0 || ns == 0) + return 0; + + return this->impl_->createDocument (XStr (ns), + XStr (root), + doctype); + } + + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocumentType * + XML_Helper<Resolver, Error>::create_doctype (const ACE_TCHAR *qn, + const ACE_TCHAR *pid, + const ACE_TCHAR *sid) const + { + return this->impl_->createDocumentType (XStr (qn), + XStr (pid), + XStr (sid)); + } + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *url) const + { + + if (url == 0) + return 0; + + try + { + if (this->parser_.get () == 0) + this->parser_.reset ((new xercesc::XercesDOMParser ())); + + // Perform Namespace processing. + this->parser_->setDoNamespaces (true); + + // Discard comment nodes in the document + this->parser_->setCreateCommentNodes (false); + + // Disable datatype normalization. The XML 1.0 attribute value + // normalization always occurs though. + // this->parser_->setFeature (XMLUni::fgDOMDatatypeNormalization, true); + + // Do not create EntityReference nodes in the DOM tree. No + // EntityReference nodes will be created, only the nodes + // corresponding to their fully expanded sustitution text will be + // created. + this->parser_->setCreateEntityReferenceNodes (false); + + // Perform Validation + this->parser_->setValidationScheme (xercesc::AbstractDOMParser::Val_Always); + + // Do not include ignorable whitespace in the DOM tree. + this->parser_->setIncludeIgnorableWhitespace (false); + + // Enable the parser's schema support. + this->parser_->setDoSchema (true); + + // Enable full schema constraint checking, including checking which + // may be time-consuming or memory intensive. Currently, particle + // unique attribution constraint checking and particle derivation + // restriction checking are controlled by this option. + this->parser_->setValidationSchemaFullChecking (true); + + // The parser will treat validation error as fatal and will exit. + this->parser_->setValidationConstraintFatal (true); + + this->parser_->setErrorHandler (&e_handler_); + + this->parser_->setEntityResolver (&resolver_); + + this->parser_->parse (ACE_TEXT_ALWAYS_CHAR (url)); + + if (e_handler_.getErrors ()) + return 0; + + return this->parser_->getDocument (); + } + catch (const DOMException& e) + { + const unsigned int maxChars = 2047; + XMLCh errText[maxChars + 1]; + + if (DOMImplementation::loadDOMExceptionMsg (e.code, + errText, + maxChars)) + { + char* message = + XMLString::transcode (errText); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + } + return 0; + + } + catch (const XMLException& e) + { + char* message = XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + throw 0; + } + catch (...) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Caught an unknown exception \n")); + throw; + } + + return 0; + } + + template <typename Resolver, typename Error> + void + XML_Helper<Resolver, Error>::terminate_parser (void) + { + try + { + xercesc::XMLPlatformUtils::Terminate(); + } + catch (const XMLException& e) + { + char* message = + XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + throw; + } + + this->initialized_ = false; + return; + } + + template <typename Resolver, typename Error> + bool + XML_Helper<Resolver, Error>::write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file) const + { + try + { + bool retn; +#if XERCES_VERSION_MAJOR == 3 + XERCES_CPP_NAMESPACE::DOMLSSerializer *serializer (impl_->createLSSerializer ()); + XERCES_CPP_NAMESPACE::DOMConfiguration *ser_config (serializer->getDomConfig ()); + XERCES_CPP_NAMESPACE::DOMLSOutput *output (impl_->createLSOutput ()); + + if (ser_config->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true)) + ser_config->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true); + + XMLFormatTarget *format_target = new XERCES_CPP_NAMESPACE::LocalFileFormatTarget (ACE_TEXT_ALWAYS_CHAR (file)); + + output->setByteStream (format_target); + + retn = serializer->write (doc, output); + + output->release (); + serializer->release (); + return retn; +#else + std::auto_ptr <XERCES_CPP_NAMESPACE::DOMWriter> writer (impl_->createDOMWriter()); + + if (writer->canSetFeature (XMLUni::fgDOMWRTFormatPrettyPrint, + true)) + writer->setFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true); + + std::auto_ptr <xercesc::XMLFormatTarget> ft (new xercesc::LocalFileFormatTarget(file)); + retn = writer->writeNode(ft.get (), *doc); + + return retn; +#endif + } + catch (const xercesc::XMLException &e) + { + char* message = + XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + + char* name = + XMLString::transcode (e.getType()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_name (name); + + ACE_ERROR ((LM_ERROR, "Caught exception while serializing DOM to file.\n" + "Name: %s\n" + "Message: %s\n" + "SrcFile: %s\n" + "SrcLine: %d\n", + name, + message, + e.getSrcFile (), + e.getSrcLine ())); + return false; + } + } + } +} diff --git a/modules/CIAO/tools/XML/XML_Schema_Resolver.cpp b/modules/CIAO/tools/XML/XML_Schema_Resolver.cpp new file mode 100644 index 00000000000..afa2ef14dc7 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Schema_Resolver.cpp @@ -0,0 +1,78 @@ +// $Id$ +#include "XML/XML_Schema_Resolver.h" + +#include <xercesc/util/PlatformUtils.hpp> +#include <xercesc/util/XercesDefs.hpp> + +#include "XML/XercesString.h" + +#include "ace/Env_Value_T.h" + + +#include <iostream> + +namespace CIAO +{ + namespace XML + { + Basic_Resolver::Basic_Resolver (const ACE_TCHAR *path) + : path_ (path) + { + } + + XMLCh * + Basic_Resolver::operator() (const XMLCh *const, + const XMLCh *const systemId) const + { + XStr path (path_); + path.append (systemId); + return path.release (); + } + + Environment_Resolver::Environment_Resolver (const ACE_TCHAR *variable, + const ACE_TCHAR *relpath) + { + xercesc::XMLPlatformUtils::Initialize(); + this->add_path (variable, relpath); + } + + using xercesc::XMLPlatformUtils; + + void + Environment_Resolver::add_path (const ACE_TCHAR *variable, + const ACE_TCHAR *relpath) + { + ACE_Env_Value <const ACE_TCHAR *> path_env (variable, + ACE_TEXT("")); + + XStr xpath (path_env); + XStr xrelpath (relpath); + + xpath.append (xrelpath); + + paths_.push_back (xpath); + } + + XMLCh * + Environment_Resolver::operator() (const XMLCh *const, + const XMLCh *const systemId) const + { + for (std::vector<XStr>::const_iterator i = this->paths_.begin (); + i != this->paths_.end (); + ++i) + { + XStr path (*i); + path.append(systemId); + + FileHandle file (XMLPlatformUtils::openFile (path)); + + if (file != 0) + { + XMLPlatformUtils::closeFile (file); + return path.release (); + } + } + return 0; + } + } +} diff --git a/modules/CIAO/tools/XML/XML_Schema_Resolver.h b/modules/CIAO/tools/XML/XML_Schema_Resolver.h new file mode 100644 index 00000000000..1826c8c1af6 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Schema_Resolver.h @@ -0,0 +1,109 @@ +/** + * @file XML_Schema_Resolver.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + * + * Resolves schema locations. + */ + +#ifndef CIAO_XML_SCHEMA_RESOLVER_H +#define CIAO_XML_SCHEMA_RESOLVER_H +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "XML/CIAO_XML_Utils_Export.h" +#include "XML/XercesString.h" + +#include <xercesc/sax/EntityResolver.hpp> +#include <vector> +#include <string> + +using namespace xercesc; + +namespace CIAO +{ + namespace XML + { + // forward decl. + struct NoOp_Resolver; + + /** + * @class CIAO_Schema_Resolver + * @brief Resolves schema locations for CIAO. + * + * Template argument Resolver should be a functor with an operation + * const ACE_TCHAR * operator () (...arguments from resolveEntity...) + */ + template <typename Resolver = NoOp_Resolver> + class XML_Schema_Resolver + : public virtual EntityResolver + { + public: + XML_Schema_Resolver (void); + + XML_Schema_Resolver (Resolver &resolver); + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + virtual InputSource * resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId); + + private: + XML_Schema_Resolver (XML_Schema_Resolver<Resolver> &); + + Resolver &resolver_; + }; + + /** + * @class NoOp_Resolver + * @brief Resolver that does nothing. + */ + struct NoOp_Resolver + { + const XMLCh* operator() (const XMLCh *const, + const XMLCh *const systemId) const + { return systemId; }; + }; + + /** + * @class Basic_Resolver + * @brief Resolves a schema location from a fixed path. + */ + struct Basic_Resolver + { + Basic_Resolver (const ACE_TCHAR *path); + + XMLCh* operator() (const XMLCh *const publicId, + const XMLCh *const systemId) const; + XStr path_; + }; + + /** + * @class Environment_Resolver + * @brief Resolves a schema location from a path from an environment variable. + */ + struct CIAO_XML_Utils_Export Environment_Resolver + { + Environment_Resolver (const ACE_TCHAR *variable = ACE_TEXT(""), + const ACE_TCHAR *path = ACE_TEXT("./")); + + void add_path (const ACE_TCHAR *variable, + const ACE_TCHAR *path); + + XMLCh* operator() (const XMLCh *const publicId, + const XMLCh *const systemId) const; + + std::vector<XStr> paths_; + }; + } +} + +#include "XML/XML_Schema_Resolver.tpp" + +#include /**/ "ace/post.h" + +#endif /* CIAO_XML_SCHEMA_RESOLVER_H */ diff --git a/modules/CIAO/tools/XML/XML_Schema_Resolver.tpp b/modules/CIAO/tools/XML/XML_Schema_Resolver.tpp new file mode 100644 index 00000000000..22039e01f14 --- /dev/null +++ b/modules/CIAO/tools/XML/XML_Schema_Resolver.tpp @@ -0,0 +1,48 @@ +// $Id$ +#ifndef XML_SCHEMA_RESOLVER_TPP +#define XML_SCHEMA_RESOLVER_TPP + +#include "XML/XML_Schema_Resolver.h" +#include "XML/XercesString.h" + +#include <xercesc/framework/LocalFileInputSource.hpp> +#include <xercesc/framework/Wrapper4InputSource.hpp> + +using xercesc::Wrapper4InputSource; +using xercesc::LocalFileInputSource; + + +namespace CIAO +{ + namespace XML + { + template<typename Resolver> + XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (void) + : resolver_ () + { + } + + template<typename Resolver> + XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (Resolver &res) + : resolver_ (res) + { + } + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + template<typename Resolver> + InputSource * + XML_Schema_Resolver<Resolver>::resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId) + { + XStr path = resolver_ (publicId, systemId); + if (path.begin () == 0) + return 0; + + // Ownership of these objects is given to other people. + return /*new Wrapper4InputSource*/ (new LocalFileInputSource (path.begin ())); + } + } +} + +#endif /*XML_SCHEMA_RESOLVER_TPP*/ diff --git a/modules/CIAO/tools/XML/XercesString.cpp b/modules/CIAO/tools/XML/XercesString.cpp new file mode 100644 index 00000000000..8e56061948d --- /dev/null +++ b/modules/CIAO/tools/XML/XercesString.cpp @@ -0,0 +1,151 @@ +// $Id$ + +#include <ostream> +#include <algorithm> + +#include "XercesString.h" +using xercesc::XMLString; + +namespace CIAO +{ + namespace XML + { + + XStr::XStr (const ACE_TCHAR* str) + : _wstr(0) + { + _wstr = XMLString::transcode(ACE_TEXT_ALWAYS_CHAR (str)); + } + + XStr::XStr (XMLCh *wstr) + : _wstr(wstr) + { + + } + + XStr::XStr (const XMLCh* wstr) + : _wstr(0) + { + _wstr = XMLString::replicate(wstr); + } + + XStr::XStr (const XStr &right) + : _wstr(0) + { + _wstr = XMLString::replicate(right._wstr); + } + + XStr& XStr::operator= (const XStr& rhs) + { + if (&rhs == this) + return *this; + XStr temp (rhs); + std::swap (this->_wstr, temp._wstr); + return *this; + } + + XStr::~XStr () + { + if (_wstr) + XMLString::release(&_wstr); + } + + const XMLCh* XStr::begin () const + { + return _wstr; + } + + const XMLCh* XStr::end () const + { + return _wstr + size(); + } + + bool XStr::append(const XMLCh *tail) + { + int iTailLen = XMLString::stringLen(tail); + int iWorkLen = XMLString::stringLen(_wstr); + XMLCh *result = new XMLCh[ iWorkLen + iTailLen + 1 ]; + bool bOK = result != 0; + if (bOK) + { + XMLCh *target = result; + XMLString::moveChars(target, _wstr, iWorkLen); + target += iWorkLen; + XMLString::moveChars(target, tail, iTailLen); + target += iTailLen; + *target++ = 0; + XMLString::release(&_wstr); + _wstr = result; + } + return bOK; + } + + bool XStr::erase(const XMLCh *head, const XMLCh *tail) + { + bool bOK = head <= tail && head >= begin() && tail <= end(); + if (bOK) + { + XMLCh *result = new XMLCh[ size() - (tail - head) + 1 ]; + XMLCh *target = result; + bOK = target != 0; + if (bOK) + { + const XMLCh *cursor = begin(); + + while (cursor != head) *target++ = *cursor++; + cursor = tail; + while ( cursor != end() ) *target++ = *cursor++; + *target ++ = 0; + XMLString::release(&_wstr); + _wstr = result; + } + } + return bOK; + } + + int XStr::size () const + { + return XMLString::stringLen(_wstr); + } + + XMLCh XStr::operator [] (const int i) + { + return _wstr[i]; + } + + XMLCh XStr::operator [] (const int i) const + { + return _wstr[i]; + } + + XMLCh * XStr::release (void) + { + XMLCh* tmp = _wstr; + this->_wstr = 0; + return tmp; + } + + bool operator== (const XStr& lhs, const XStr& rhs) + { + return XMLString::compareIString (lhs,rhs) == 0; + } + + bool operator!= (const XStr& lhs, const XStr& rhs) + { + return !operator==(lhs, rhs); + } + + + std::ostream& + operator<< (std::ostream& o, XStr const& str) + { + char* s = XMLString::transcode (str); + + o << s; + + XMLString::release (&s); // idiots? + return o; + } + + } +} diff --git a/modules/CIAO/tools/XML/XercesString.h b/modules/CIAO/tools/XML/XercesString.h new file mode 100644 index 00000000000..b0975462c59 --- /dev/null +++ b/modules/CIAO/tools/XML/XercesString.h @@ -0,0 +1,78 @@ +// $Id$ + +#ifndef _XERCESSTRING_H +#define _XERCESSTRING_H + +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include <iosfwd> + +#ifdef __BORLANDC__ +using std::memcpy; +#endif + +#include <xercesc/util/XMLString.hpp> + +// Utility class that provides a std::string like facade to XMLString. +// Doesn't implement all of the methods of std::string. +#include "XML/CIAO_XML_Utils_Export.h" + +namespace CIAO +{ + namespace XML + { + class CIAO_XML_Utils_Export XStr + { + public: + XStr() : _wstr(0L) { }; + + XStr (const ACE_TCHAR* str); + + XStr (XMLCh* wstr); + + XStr (const XMLCh* wstr); + + XStr (const XStr& copy); + + XStr& operator= (const XStr& rhs); + + ~XStr(); + + const XMLCh* begin() const; + + const XMLCh* end() const; + + bool append(const XMLCh* tail); + + bool erase (const XMLCh* head, const XMLCh* tail); + + int size() const; + + XMLCh operator [] (const int i); + + XMLCh operator [] (const int i) const; + + operator const XMLCh* () const { return _wstr; }; + + XMLCh * release (void); + private: + + XMLCh* _wstr; // Internal representation + + }; + + CIAO_XML_Utils_Export bool operator== (const XStr& lhs, const XStr& rhs); + CIAO_XML_Utils_Export bool operator!= (const XStr& lhs, const XStr& rhs); + + CIAO_XML_Utils_Export std::ostream& + operator<< (std::ostream& o, XStr const& str); + + } +} +#include /**/ "ace/post.h" + +#endif /* _XERCESSTRING_H */ diff --git a/modules/CIAO/tools/tools.mwc b/modules/CIAO/tools/tools.mwc new file mode 100644 index 00000000000..ae28cfcba54 --- /dev/null +++ b/modules/CIAO/tools/tools.mwc @@ -0,0 +1,7 @@ +// -*- MPC -*- +// $Id$ + +workspace { + Config_Handlers + IDL3_to_IDL2 +}
\ No newline at end of file |