diff options
Diffstat (limited to 'CIAO/tools/Config_Handlers')
198 files changed, 80516 insertions, 0 deletions
diff --git a/CIAO/tools/Config_Handlers/ADD_Handler.cpp b/CIAO/tools/Config_Handlers/ADD_Handler.cpp new file mode 100644 index 00000000000..cc1fe6fc020 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ADD_Handler.cpp @@ -0,0 +1,178 @@ +// $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 = src.name ().c_str (); + + + dest.node = 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++] = 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++] = 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_CString 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", + 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< char > name ((src.name)); + XMLSchema::string< char > node ((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< char > curr ((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< char > curr ((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 ()->generateUUID (uuid); + ACE_CString add_id ("_"); + add_id += *uuid.to_string (); + + 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/CIAO/tools/Config_Handlers/ADD_Handler.h b/CIAO/tools/Config_Handlers/ADD_Handler.h new file mode 100644 index 00000000000..0db82b30fb2 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ADD_Handler.h @@ -0,0 +1,73 @@ +//============================================================== +/** +* @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/CIAO/tools/Config_Handlers/Any_Handler.cpp b/CIAO/tools/Config_Handlers/Any_Handler.cpp new file mode 100644 index 00000000000..535d5a88d8a --- /dev/null +++ b/CIAO/tools/Config_Handlers/Any_Handler.cpp @@ -0,0 +1,47 @@ +// $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/CIAO_common.h" +#include "DynAny_Handler/DynAny_Handler.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"); + DynamicAny::DynAny_var dyn = DYNANY_HANDLER->extract_into_dynany (desc.type (), + desc.value ()); + + toconfig = *dyn->to_any (); + + dyn->destroy (); + } + + 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/CIAO/tools/Config_Handlers/Any_Handler.h b/CIAO/tools/Config_Handlers/Any_Handler.h new file mode 100644 index 00000000000..fcd594375ee --- /dev/null +++ b/CIAO/tools/Config_Handlers/Any_Handler.h @@ -0,0 +1,61 @@ +//============================================================== +/** + * @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 "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/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp new file mode 100644 index 00000000000..969cbc06c53 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.cpp @@ -0,0 +1,16440 @@ +/* $Id$ + * This code was generated by the XML Schema Compiler. + * + * Changes made to this code will most likely be overwritten + * when the handlers are recompiled. + * + * If you find errors or feel that there are bugfixes to be made, + * please contact the current XSC maintainer: + * Will Otte <wotte@dre.vanderbilt.edu> + */ + +// Fix for Borland compilers, which seem to have a broken +// <string> include. +#ifdef __BORLANDC__ +# include <string.h> +#endif + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // TCKind + // + + TCKind::Value TCKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::TCKind const& a, ::CIAO::Config_Handlers::TCKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::TCKind const& a, ::CIAO::Config_Handlers::TCKind const& b) + { + return a.v_ != b.v_; + } + + TCKind:: + TCKind (TCKind::Value v) + : v_ (v) + { + } + + // DataType + // + + DataType:: + DataType (::CIAO::Config_Handlers::TCKind const& kind__) + : + ::XSCRT::Type (), + kind_ (new ::CIAO::Config_Handlers::TCKind (kind__)), + regulator__ () + { + kind_->container (this); + } + + DataType:: + DataType (::CIAO::Config_Handlers::DataType const& s) + : + ::XSCRT::Type (), + kind_ (new ::CIAO::Config_Handlers::TCKind (*s.kind_)), + enum__ (s.enum__.get () ? new ::CIAO::Config_Handlers::EnumType (*s.enum__) : 0), + struct__ (s.struct__.get () ? new ::CIAO::Config_Handlers::StructType (*s.struct__) : 0), + value_ (s.value_.get () ? new ::CIAO::Config_Handlers::ValueType (*s.value_) : 0), + sequence_ (s.sequence_.get () ? new ::CIAO::Config_Handlers::SequenceType (*s.sequence_) : 0), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + kind_->container (this); + if (enum__.get ()) enum__->container (this); + if (struct__.get ()) struct__->container (this); + if (value_.get ()) value_->container (this); + if (sequence_.get ()) sequence_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::DataType& DataType:: + operator= (::CIAO::Config_Handlers::DataType const& s) + { + kind (s.kind ()); + + if (s.enum__.get ()) enum_ (*(s.enum__)); + else enum__ = ::std::auto_ptr< ::CIAO::Config_Handlers::EnumType > (0); + + if (s.struct__.get ()) struct_ (*(s.struct__)); + else struct__ = ::std::auto_ptr< ::CIAO::Config_Handlers::StructType > (0); + + if (s.value_.get ()) value (*(s.value_)); + else value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ValueType > (0); + + if (s.sequence_.get ()) sequence (*(s.sequence_)); + else sequence_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SequenceType > (0); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // DataType + // + ::CIAO::Config_Handlers::TCKind const& DataType:: + kind () const + { + return *kind_; + } + + void DataType:: + kind (::CIAO::Config_Handlers::TCKind const& e) + { + *kind_ = e; + } + + // DataType + // + bool DataType:: + enum_p () const + { + return enum__.get () != 0; + } + + ::CIAO::Config_Handlers::EnumType const& DataType:: + enum_ () const + { + return *enum__; + } + + void DataType:: + enum_ (::CIAO::Config_Handlers::EnumType const& e) + { + if (enum__.get ()) + { + *enum__ = e; + } + + else + { + enum__ = ::std::auto_ptr< ::CIAO::Config_Handlers::EnumType > (new ::CIAO::Config_Handlers::EnumType (e)); + enum__->container (this); + } + } + + // DataType + // + bool DataType:: + struct_p () const + { + return struct__.get () != 0; + } + + ::CIAO::Config_Handlers::StructType const& DataType:: + struct_ () const + { + return *struct__; + } + + void DataType:: + struct_ (::CIAO::Config_Handlers::StructType const& e) + { + if (struct__.get ()) + { + *struct__ = e; + } + + else + { + struct__ = ::std::auto_ptr< ::CIAO::Config_Handlers::StructType > (new ::CIAO::Config_Handlers::StructType (e)); + struct__->container (this); + } + } + + // DataType + // + bool DataType:: + value_p () const + { + return value_.get () != 0; + } + + ::CIAO::Config_Handlers::ValueType const& DataType:: + value () const + { + return *value_; + } + + void DataType:: + value (::CIAO::Config_Handlers::ValueType const& e) + { + if (value_.get ()) + { + *value_ = e; + } + + else + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ValueType > (new ::CIAO::Config_Handlers::ValueType (e)); + value_->container (this); + } + } + + // DataType + // + bool DataType:: + sequence_p () const + { + return sequence_.get () != 0; + } + + ::CIAO::Config_Handlers::SequenceType const& DataType:: + sequence () const + { + return *sequence_; + } + + void DataType:: + sequence (::CIAO::Config_Handlers::SequenceType const& e) + { + if (sequence_.get ()) + { + *sequence_ = e; + } + + else + { + sequence_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SequenceType > (new ::CIAO::Config_Handlers::SequenceType (e)); + sequence_->container (this); + } + } + + // DataType + // + bool DataType:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& DataType:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& DataType:: + id () + { + return *id_; + } + + void DataType:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // DataValue + // + + DataValue:: + DataValue () + : + ::XSCRT::Type (), + regulator__ () + { + } + + DataValue:: + DataValue (::CIAO::Config_Handlers::DataValue const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (short_const_iterator i (s.short_.begin ());i != s.short_.end ();++i) add_short (*i); + } + + { + for (long_const_iterator i (s.long_.begin ());i != s.long_.end ();++i) add_long (*i); + } + + { + for (ushort_const_iterator i (s.ushort_.begin ());i != s.ushort_.end ();++i) add_ushort (*i); + } + + { + for (ulong_const_iterator i (s.ulong_.begin ());i != s.ulong_.end ();++i) add_ulong (*i); + } + + { + for (float_const_iterator i (s.float_.begin ());i != s.float_.end ();++i) add_float (*i); + } + + { + for (double_const_iterator i (s.double_.begin ());i != s.double_.end ();++i) add_double (*i); + } + + { + for (boolean_const_iterator i (s.boolean_.begin ());i != s.boolean_.end ();++i) add_boolean (*i); + } + + { + for (octet_const_iterator i (s.octet_.begin ());i != s.octet_.end ();++i) add_octet (*i); + } + + { + for (enum_const_iterator i (s.enum_.begin ());i != s.enum_.end ();++i) add_enum (*i); + } + + { + for (string_const_iterator i (s.string_.begin ());i != s.string_.end ();++i) add_string (*i); + } + + { + for (longlong_const_iterator i (s.longlong_.begin ());i != s.longlong_.end ();++i) add_longlong (*i); + } + + { + for (ulonglong_const_iterator i (s.ulonglong_.begin ());i != s.ulonglong_.end ();++i) add_ulonglong (*i); + } + + { + for (longdouble_const_iterator i (s.longdouble_.begin ());i != s.longdouble_.end ();++i) add_longdouble (*i); + } + + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::DataValue& DataValue:: + operator= (::CIAO::Config_Handlers::DataValue const& s) + { + short_.clear (); + { + for (short_const_iterator i (s.short_.begin ());i != s.short_.end ();++i) add_short (*i); + } + + long_.clear (); + { + for (long_const_iterator i (s.long_.begin ());i != s.long_.end ();++i) add_long (*i); + } + + ushort_.clear (); + { + for (ushort_const_iterator i (s.ushort_.begin ());i != s.ushort_.end ();++i) add_ushort (*i); + } + + ulong_.clear (); + { + for (ulong_const_iterator i (s.ulong_.begin ());i != s.ulong_.end ();++i) add_ulong (*i); + } + + float_.clear (); + { + for (float_const_iterator i (s.float_.begin ());i != s.float_.end ();++i) add_float (*i); + } + + double_.clear (); + { + for (double_const_iterator i (s.double_.begin ());i != s.double_.end ();++i) add_double (*i); + } + + boolean_.clear (); + { + for (boolean_const_iterator i (s.boolean_.begin ());i != s.boolean_.end ();++i) add_boolean (*i); + } + + octet_.clear (); + { + for (octet_const_iterator i (s.octet_.begin ());i != s.octet_.end ();++i) add_octet (*i); + } + + enum_.clear (); + { + for (enum_const_iterator i (s.enum_.begin ());i != s.enum_.end ();++i) add_enum (*i); + } + + string_.clear (); + { + for (string_const_iterator i (s.string_.begin ());i != s.string_.end ();++i) add_string (*i); + } + + longlong_.clear (); + { + for (longlong_const_iterator i (s.longlong_.begin ());i != s.longlong_.end ();++i) add_longlong (*i); + } + + ulonglong_.clear (); + { + for (ulonglong_const_iterator i (s.ulonglong_.begin ());i != s.ulonglong_.end ();++i) add_ulonglong (*i); + } + + longdouble_.clear (); + { + for (longdouble_const_iterator i (s.longdouble_.begin ());i != s.longdouble_.end ();++i) add_longdouble (*i); + } + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // DataValue + // + DataValue::short_iterator DataValue:: + begin_short () + { + return short_.begin (); + } + + DataValue::short_iterator DataValue:: + end_short () + { + return short_.end (); + } + + DataValue::short_const_iterator DataValue:: + begin_short () const + { + return short_.begin (); + } + + DataValue::short_const_iterator DataValue:: + end_short () const + { + return short_.end (); + } + + void DataValue:: + add_short (::XMLSchema::short_ const& e) + { + short_.push_back (e); + } + + size_t DataValue:: + count_short(void) const + { + return short_.size (); + } + + // DataValue + // + DataValue::long_iterator DataValue:: + begin_long () + { + return long_.begin (); + } + + DataValue::long_iterator DataValue:: + end_long () + { + return long_.end (); + } + + DataValue::long_const_iterator DataValue:: + begin_long () const + { + return long_.begin (); + } + + DataValue::long_const_iterator DataValue:: + end_long () const + { + return long_.end (); + } + + void DataValue:: + add_long (::XMLSchema::int_ const& e) + { + long_.push_back (e); + } + + size_t DataValue:: + count_long(void) const + { + return long_.size (); + } + + // DataValue + // + DataValue::ushort_iterator DataValue:: + begin_ushort () + { + return ushort_.begin (); + } + + DataValue::ushort_iterator DataValue:: + end_ushort () + { + return ushort_.end (); + } + + DataValue::ushort_const_iterator DataValue:: + begin_ushort () const + { + return ushort_.begin (); + } + + DataValue::ushort_const_iterator DataValue:: + end_ushort () const + { + return ushort_.end (); + } + + void DataValue:: + add_ushort (::XMLSchema::unsignedShort const& e) + { + ushort_.push_back (e); + } + + size_t DataValue:: + count_ushort(void) const + { + return ushort_.size (); + } + + // DataValue + // + DataValue::ulong_iterator DataValue:: + begin_ulong () + { + return ulong_.begin (); + } + + DataValue::ulong_iterator DataValue:: + end_ulong () + { + return ulong_.end (); + } + + DataValue::ulong_const_iterator DataValue:: + begin_ulong () const + { + return ulong_.begin (); + } + + DataValue::ulong_const_iterator DataValue:: + end_ulong () const + { + return ulong_.end (); + } + + void DataValue:: + add_ulong (::XMLSchema::unsignedInt const& e) + { + ulong_.push_back (e); + } + + size_t DataValue:: + count_ulong(void) const + { + return ulong_.size (); + } + + // DataValue + // + DataValue::float_iterator DataValue:: + begin_float () + { + return float_.begin (); + } + + DataValue::float_iterator DataValue:: + end_float () + { + return float_.end (); + } + + DataValue::float_const_iterator DataValue:: + begin_float () const + { + return float_.begin (); + } + + DataValue::float_const_iterator DataValue:: + end_float () const + { + return float_.end (); + } + + void DataValue:: + add_float (::XMLSchema::float_ const& e) + { + float_.push_back (e); + } + + size_t DataValue:: + count_float(void) const + { + return float_.size (); + } + + // DataValue + // + DataValue::double_iterator DataValue:: + begin_double () + { + return double_.begin (); + } + + DataValue::double_iterator DataValue:: + end_double () + { + return double_.end (); + } + + DataValue::double_const_iterator DataValue:: + begin_double () const + { + return double_.begin (); + } + + DataValue::double_const_iterator DataValue:: + end_double () const + { + return double_.end (); + } + + void DataValue:: + add_double (::XMLSchema::double_ const& e) + { + double_.push_back (e); + } + + size_t DataValue:: + count_double(void) const + { + return double_.size (); + } + + // DataValue + // + DataValue::boolean_iterator DataValue:: + begin_boolean () + { + return boolean_.begin (); + } + + DataValue::boolean_iterator DataValue:: + end_boolean () + { + return boolean_.end (); + } + + DataValue::boolean_const_iterator DataValue:: + begin_boolean () const + { + return boolean_.begin (); + } + + DataValue::boolean_const_iterator DataValue:: + end_boolean () const + { + return boolean_.end (); + } + + void DataValue:: + add_boolean (::XMLSchema::boolean const& e) + { + boolean_.push_back (e); + } + + size_t DataValue:: + count_boolean(void) const + { + return boolean_.size (); + } + + // DataValue + // + DataValue::octet_iterator DataValue:: + begin_octet () + { + return octet_.begin (); + } + + DataValue::octet_iterator DataValue:: + end_octet () + { + return octet_.end (); + } + + DataValue::octet_const_iterator DataValue:: + begin_octet () const + { + return octet_.begin (); + } + + DataValue::octet_const_iterator DataValue:: + end_octet () const + { + return octet_.end (); + } + + void DataValue:: + add_octet (::XMLSchema::unsignedByte const& e) + { + octet_.push_back (e); + } + + size_t DataValue:: + count_octet(void) const + { + return octet_.size (); + } + + // DataValue + // + DataValue::enum_iterator DataValue:: + begin_enum () + { + return enum_.begin (); + } + + DataValue::enum_iterator DataValue:: + end_enum () + { + return enum_.end (); + } + + DataValue::enum_const_iterator DataValue:: + begin_enum () const + { + return enum_.begin (); + } + + DataValue::enum_const_iterator DataValue:: + end_enum () const + { + return enum_.end (); + } + + void DataValue:: + add_enum (::XMLSchema::string< ACE_TCHAR > const& e) + { + enum_.push_back (e); + } + + size_t DataValue:: + count_enum(void) const + { + return enum_.size (); + } + + // DataValue + // + DataValue::string_iterator DataValue:: + begin_string () + { + return string_.begin (); + } + + DataValue::string_iterator DataValue:: + end_string () + { + return string_.end (); + } + + DataValue::string_const_iterator DataValue:: + begin_string () const + { + return string_.begin (); + } + + DataValue::string_const_iterator DataValue:: + end_string () const + { + return string_.end (); + } + + void DataValue:: + add_string (::XMLSchema::string< ACE_TCHAR > const& e) + { + string_.push_back (e); + } + + size_t DataValue:: + count_string(void) const + { + return string_.size (); + } + + // DataValue + // + DataValue::longlong_iterator DataValue:: + begin_longlong () + { + return longlong_.begin (); + } + + DataValue::longlong_iterator DataValue:: + end_longlong () + { + return longlong_.end (); + } + + DataValue::longlong_const_iterator DataValue:: + begin_longlong () const + { + return longlong_.begin (); + } + + DataValue::longlong_const_iterator DataValue:: + end_longlong () const + { + return longlong_.end (); + } + + void DataValue:: + add_longlong (::XMLSchema::long_ const& e) + { + longlong_.push_back (e); + } + + size_t DataValue:: + count_longlong(void) const + { + return longlong_.size (); + } + + // DataValue + // + DataValue::ulonglong_iterator DataValue:: + begin_ulonglong () + { + return ulonglong_.begin (); + } + + DataValue::ulonglong_iterator DataValue:: + end_ulonglong () + { + return ulonglong_.end (); + } + + DataValue::ulonglong_const_iterator DataValue:: + begin_ulonglong () const + { + return ulonglong_.begin (); + } + + DataValue::ulonglong_const_iterator DataValue:: + end_ulonglong () const + { + return ulonglong_.end (); + } + + void DataValue:: + add_ulonglong (::XMLSchema::unsignedLong const& e) + { + ulonglong_.push_back (e); + } + + size_t DataValue:: + count_ulonglong(void) const + { + return ulonglong_.size (); + } + + // DataValue + // + DataValue::longdouble_iterator DataValue:: + begin_longdouble () + { + return longdouble_.begin (); + } + + DataValue::longdouble_iterator DataValue:: + end_longdouble () + { + return longdouble_.end (); + } + + DataValue::longdouble_const_iterator DataValue:: + begin_longdouble () const + { + return longdouble_.begin (); + } + + DataValue::longdouble_const_iterator DataValue:: + end_longdouble () const + { + return longdouble_.end (); + } + + void DataValue:: + add_longdouble (::XMLSchema::double_ const& e) + { + longdouble_.push_back (e); + } + + size_t DataValue:: + count_longdouble(void) const + { + return longdouble_.size (); + } + + // DataValue + // + DataValue::member_iterator DataValue:: + begin_member () + { + return member_.begin (); + } + + DataValue::member_iterator DataValue:: + end_member () + { + return member_.end (); + } + + DataValue::member_const_iterator DataValue:: + begin_member () const + { + return member_.begin (); + } + + DataValue::member_const_iterator DataValue:: + end_member () const + { + return member_.end (); + } + + void DataValue:: + add_member (::CIAO::Config_Handlers::NamedValue const& e) + { + member_.push_back (e); + } + + size_t DataValue:: + count_member(void) const + { + return member_.size (); + } + + + // EnumType + // + + EnumType:: + EnumType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + EnumType:: + EnumType (::CIAO::Config_Handlers::EnumType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::EnumType& EnumType:: + operator= (::CIAO::Config_Handlers::EnumType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // EnumType + // + ::XMLSchema::string< ACE_TCHAR > const& EnumType:: + name () const + { + return *name_; + } + + void EnumType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // EnumType + // + ::XMLSchema::string< ACE_TCHAR > const& EnumType:: + typeId () const + { + return *typeId_; + } + + void EnumType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // EnumType + // + EnumType::member_iterator EnumType:: + begin_member () + { + return member_.begin (); + } + + EnumType::member_iterator EnumType:: + end_member () + { + return member_.end (); + } + + EnumType::member_const_iterator EnumType:: + begin_member () const + { + return member_.begin (); + } + + EnumType::member_const_iterator EnumType:: + end_member () const + { + return member_.end (); + } + + void EnumType:: + add_member (::XMLSchema::string< ACE_TCHAR > const& e) + { + member_.push_back (e); + } + + size_t EnumType:: + count_member(void) const + { + return member_.size (); + } + + + // StructType + // + + StructType:: + StructType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + } + + StructType:: + StructType (::CIAO::Config_Handlers::StructType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::StructType& StructType:: + operator= (::CIAO::Config_Handlers::StructType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // StructType + // + ::XMLSchema::string< ACE_TCHAR > const& StructType:: + name () const + { + return *name_; + } + + void StructType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // StructType + // + ::XMLSchema::string< ACE_TCHAR > const& StructType:: + typeId () const + { + return *typeId_; + } + + void StructType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // StructType + // + StructType::member_iterator StructType:: + begin_member () + { + return member_.begin (); + } + + StructType::member_iterator StructType:: + end_member () + { + return member_.end (); + } + + StructType::member_const_iterator StructType:: + begin_member () const + { + return member_.begin (); + } + + StructType::member_const_iterator StructType:: + end_member () const + { + return member_.end (); + } + + void StructType:: + add_member (::CIAO::Config_Handlers::StructMemberType const& e) + { + member_.push_back (e); + } + + size_t StructType:: + count_member(void) const + { + return member_.size (); + } + + + // StructMemberType + // + + StructMemberType:: + StructMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + StructMemberType:: + StructMemberType (::CIAO::Config_Handlers::StructMemberType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::StructMemberType& StructMemberType:: + operator= (::CIAO::Config_Handlers::StructMemberType const& s) + { + name (s.name ()); + + type (s.type ()); + + return *this; + } + + + // StructMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& StructMemberType:: + name () const + { + return *name_; + } + + void StructMemberType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // StructMemberType + // + ::CIAO::Config_Handlers::DataType const& StructMemberType:: + type () const + { + return *type_; + } + + void StructMemberType:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // ValueType + // + + ValueType:: + ValueType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__, + ::XMLSchema::string< ACE_TCHAR > const& modifier__, + ::CIAO::Config_Handlers::DataType const& baseType__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (typeId__)), + modifier_ (new ::XMLSchema::string< ACE_TCHAR > (modifier__)), + baseType_ (new ::CIAO::Config_Handlers::DataType (baseType__)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + modifier_->container (this); + baseType_->container (this); + } + + ValueType:: + ValueType (::CIAO::Config_Handlers::ValueType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + typeId_ (new ::XMLSchema::string< ACE_TCHAR > (*s.typeId_)), + modifier_ (new ::XMLSchema::string< ACE_TCHAR > (*s.modifier_)), + baseType_ (new ::CIAO::Config_Handlers::DataType (*s.baseType_)), + regulator__ () + { + name_->container (this); + typeId_->container (this); + modifier_->container (this); + baseType_->container (this); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + } + + ::CIAO::Config_Handlers::ValueType& ValueType:: + operator= (::CIAO::Config_Handlers::ValueType const& s) + { + name (s.name ()); + + typeId (s.typeId ()); + + modifier (s.modifier ()); + + baseType (s.baseType ()); + + member_.clear (); + { + for (member_const_iterator i (s.member_.begin ());i != s.member_.end ();++i) add_member (*i); + } + + return *this; + } + + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + name () const + { + return *name_; + } + + void ValueType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + typeId () const + { + return *typeId_; + } + + void ValueType:: + typeId (::XMLSchema::string< ACE_TCHAR > const& e) + { + *typeId_ = e; + } + + // ValueType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueType:: + modifier () const + { + return *modifier_; + } + + void ValueType:: + modifier (::XMLSchema::string< ACE_TCHAR > const& e) + { + *modifier_ = e; + } + + // ValueType + // + ::CIAO::Config_Handlers::DataType const& ValueType:: + baseType () const + { + return *baseType_; + } + + void ValueType:: + baseType (::CIAO::Config_Handlers::DataType const& e) + { + *baseType_ = e; + } + + // ValueType + // + ValueType::member_iterator ValueType:: + begin_member () + { + return member_.begin (); + } + + ValueType::member_iterator ValueType:: + end_member () + { + return member_.end (); + } + + ValueType::member_const_iterator ValueType:: + begin_member () const + { + return member_.begin (); + } + + ValueType::member_const_iterator ValueType:: + end_member () const + { + return member_.end (); + } + + void ValueType:: + add_member (::CIAO::Config_Handlers::ValueMemberType const& e) + { + member_.push_back (e); + } + + size_t ValueType:: + count_member(void) const + { + return member_.size (); + } + + + // ValueMemberType + // + + ValueMemberType:: + ValueMemberType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& visibility__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + visibility_ (new ::XMLSchema::string< ACE_TCHAR > (visibility__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + visibility_->container (this); + type_->container (this); + } + + ValueMemberType:: + ValueMemberType (::CIAO::Config_Handlers::ValueMemberType const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + visibility_ (new ::XMLSchema::string< ACE_TCHAR > (*s.visibility_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + visibility_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::ValueMemberType& ValueMemberType:: + operator= (::CIAO::Config_Handlers::ValueMemberType const& s) + { + name (s.name ()); + + visibility (s.visibility ()); + + type (s.type ()); + + return *this; + } + + + // ValueMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueMemberType:: + name () const + { + return *name_; + } + + void ValueMemberType:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ValueMemberType + // + ::XMLSchema::string< ACE_TCHAR > const& ValueMemberType:: + visibility () const + { + return *visibility_; + } + + void ValueMemberType:: + visibility (::XMLSchema::string< ACE_TCHAR > const& e) + { + *visibility_ = e; + } + + // ValueMemberType + // + ::CIAO::Config_Handlers::DataType const& ValueMemberType:: + type () const + { + return *type_; + } + + void ValueMemberType:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // NamedValue + // + + NamedValue:: + NamedValue (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataValue const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + NamedValue:: + NamedValue (::CIAO::Config_Handlers::NamedValue const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + value_ (new ::CIAO::Config_Handlers::DataValue (*s.value_)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::NamedValue& NamedValue:: + operator= (::CIAO::Config_Handlers::NamedValue const& s) + { + name (s.name ()); + + value (s.value ()); + + return *this; + } + + + // NamedValue + // + ::XMLSchema::string< ACE_TCHAR > const& NamedValue:: + name () const + { + return *name_; + } + + void NamedValue:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // NamedValue + // + ::CIAO::Config_Handlers::DataValue const& NamedValue:: + value () const + { + return *value_; + } + + void NamedValue:: + value (::CIAO::Config_Handlers::DataValue const& e) + { + *value_ = e; + } + + + // SequenceType + // + + SequenceType:: + SequenceType (::CIAO::Config_Handlers::DataType const& elementType__) + : + ::XSCRT::Type (), + elementType_ (new ::CIAO::Config_Handlers::DataType (elementType__)), + regulator__ () + { + elementType_->container (this); + } + + SequenceType:: + SequenceType (::CIAO::Config_Handlers::SequenceType const& s) + : + ::XSCRT::Type (), + bound_ (s.bound_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.bound_) : 0), + elementType_ (new ::CIAO::Config_Handlers::DataType (*s.elementType_)), + regulator__ () + { + if (bound_.get ()) bound_->container (this); + elementType_->container (this); + } + + ::CIAO::Config_Handlers::SequenceType& SequenceType:: + operator= (::CIAO::Config_Handlers::SequenceType const& s) + { + if (s.bound_.get ()) bound (*(s.bound_)); + else bound_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + elementType (s.elementType ()); + + return *this; + } + + + // SequenceType + // + bool SequenceType:: + bound_p () const + { + return bound_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& SequenceType:: + bound () const + { + return *bound_; + } + + void SequenceType:: + bound (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (bound_.get ()) + { + *bound_ = e; + } + + else + { + bound_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + bound_->container (this); + } + } + + // SequenceType + // + ::CIAO::Config_Handlers::DataType const& SequenceType:: + elementType () const + { + return *elementType_; + } + + void SequenceType:: + elementType (::CIAO::Config_Handlers::DataType const& e) + { + *elementType_ = e; + } + + + // Any + // + + Any:: + Any (::CIAO::Config_Handlers::DataType const& type__, + ::CIAO::Config_Handlers::DataValue const& value__) + : + ::XSCRT::Type (), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + value_ (new ::CIAO::Config_Handlers::DataValue (value__)), + regulator__ () + { + type_->container (this); + value_->container (this); + } + + Any:: + Any (::CIAO::Config_Handlers::Any const& s) + : + ::XSCRT::Type (), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + value_ (new ::CIAO::Config_Handlers::DataValue (*s.value_)), + regulator__ () + { + type_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::Any& Any:: + operator= (::CIAO::Config_Handlers::Any const& s) + { + type (s.type ()); + + value (s.value ()); + + return *this; + } + + + // Any + // + ::CIAO::Config_Handlers::DataType const& Any:: + type () const + { + return *type_; + } + + void Any:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + // Any + // + ::CIAO::Config_Handlers::DataValue const& Any:: + value () const + { + return *value_; + } + + void Any:: + value (::CIAO::Config_Handlers::DataValue const& e) + { + *value_ = e; + } + + + // Property + // + + Property:: + Property (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::Any const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + value_ (new ::CIAO::Config_Handlers::Any (value__)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + Property:: + Property (::CIAO::Config_Handlers::Property const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + value_ (new ::CIAO::Config_Handlers::Any (*s.value_)), + regulator__ () + { + name_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::Property& Property:: + operator= (::CIAO::Config_Handlers::Property const& s) + { + name (s.name ()); + + value (s.value ()); + + return *this; + } + + + // Property + // + ::XMLSchema::string< ACE_TCHAR > const& Property:: + name () const + { + return *name_; + } + + void Property:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Property + // + ::CIAO::Config_Handlers::Any const& Property:: + value () const + { + return *value_; + } + + void Property:: + value (::CIAO::Config_Handlers::Any const& e) + { + *value_ = e; + } + + + // SatisfierPropertyKind + // + + SatisfierPropertyKind::Value SatisfierPropertyKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::SatisfierPropertyKind const& a, ::CIAO::Config_Handlers::SatisfierPropertyKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::SatisfierPropertyKind const& a, ::CIAO::Config_Handlers::SatisfierPropertyKind const& b) + { + return a.v_ != b.v_; + } + + SatisfierPropertyKind:: + SatisfierPropertyKind (SatisfierPropertyKind::Value v) + : v_ (v) + { + } + + // SatisfierProperty + // + + SatisfierProperty:: + SatisfierProperty (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::SatisfierPropertyKind const& kind__, + ::XMLSchema::boolean const& dynamic__, + ::CIAO::Config_Handlers::Any const& value__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind (kind__)), + dynamic_ (new ::XMLSchema::boolean (dynamic__)), + value_ (new ::CIAO::Config_Handlers::Any (value__)), + regulator__ () + { + name_->container (this); + kind_->container (this); + dynamic_->container (this); + value_->container (this); + } + + SatisfierProperty:: + SatisfierProperty (::CIAO::Config_Handlers::SatisfierProperty const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind (*s.kind_)), + dynamic_ (new ::XMLSchema::boolean (*s.dynamic_)), + value_ (new ::CIAO::Config_Handlers::Any (*s.value_)), + regulator__ () + { + name_->container (this); + kind_->container (this); + dynamic_->container (this); + value_->container (this); + } + + ::CIAO::Config_Handlers::SatisfierProperty& SatisfierProperty:: + operator= (::CIAO::Config_Handlers::SatisfierProperty const& s) + { + name (s.name ()); + + kind (s.kind ()); + + dynamic (s.dynamic ()); + + value (s.value ()); + + return *this; + } + + + // SatisfierProperty + // + ::XMLSchema::string< ACE_TCHAR > const& SatisfierProperty:: + name () const + { + return *name_; + } + + void SatisfierProperty:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // SatisfierProperty + // + ::CIAO::Config_Handlers::SatisfierPropertyKind const& SatisfierProperty:: + kind () const + { + return *kind_; + } + + void SatisfierProperty:: + kind (::CIAO::Config_Handlers::SatisfierPropertyKind const& e) + { + *kind_ = e; + } + + // SatisfierProperty + // + ::XMLSchema::boolean const& SatisfierProperty:: + dynamic () const + { + return *dynamic_; + } + + void SatisfierProperty:: + dynamic (::XMLSchema::boolean const& e) + { + *dynamic_ = e; + } + + // SatisfierProperty + // + ::CIAO::Config_Handlers::Any const& SatisfierProperty:: + value () const + { + return *value_; + } + + void SatisfierProperty:: + value (::CIAO::Config_Handlers::Any const& e) + { + *value_ = e; + } + + + // Resource + // + + Resource:: + Resource (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Resource:: + Resource (::CIAO::Config_Handlers::Resource const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Resource& Resource:: + operator= (::CIAO::Config_Handlers::Resource const& s) + { + name (s.name ()); + + resourceType_.clear (); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Resource + // + ::XMLSchema::string< ACE_TCHAR > const& Resource:: + name () const + { + return *name_; + } + + void Resource:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Resource + // + Resource::resourceType_iterator Resource:: + begin_resourceType () + { + return resourceType_.begin (); + } + + Resource::resourceType_iterator Resource:: + end_resourceType () + { + return resourceType_.end (); + } + + Resource::resourceType_const_iterator Resource:: + begin_resourceType () const + { + return resourceType_.begin (); + } + + Resource::resourceType_const_iterator Resource:: + end_resourceType () const + { + return resourceType_.end (); + } + + void Resource:: + add_resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + resourceType_.push_back (e); + } + + size_t Resource:: + count_resourceType(void) const + { + return resourceType_.size (); + } + + // Resource + // + Resource::property_iterator Resource:: + begin_property () + { + return property_.begin (); + } + + Resource::property_iterator Resource:: + end_property () + { + return property_.end (); + } + + Resource::property_const_iterator Resource:: + begin_property () const + { + return property_.begin (); + } + + Resource::property_const_iterator Resource:: + end_property () const + { + return property_.end (); + } + + void Resource:: + add_property (::CIAO::Config_Handlers::SatisfierProperty const& e) + { + property_.push_back (e); + } + + size_t Resource:: + count_property(void) const + { + return property_.size (); + } + + + // Requirement + // + + Requirement:: + Requirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + } + + Requirement:: + Requirement (::CIAO::Config_Handlers::Requirement const& s) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Requirement& Requirement:: + operator= (::CIAO::Config_Handlers::Requirement const& s) + { + resourceType (s.resourceType ()); + + name (s.name ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + resourceType () const + { + return *resourceType_; + } + + void Requirement:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = e; + } + + // Requirement + // + ::XMLSchema::string< ACE_TCHAR > const& Requirement:: + name () const + { + return *name_; + } + + void Requirement:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Requirement + // + Requirement::property_iterator Requirement:: + begin_property () + { + return property_.begin (); + } + + Requirement::property_iterator Requirement:: + end_property () + { + return property_.end (); + } + + Requirement::property_const_iterator Requirement:: + begin_property () const + { + return property_.begin (); + } + + Requirement::property_const_iterator Requirement:: + end_property () const + { + return property_.end (); + } + + void Requirement:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t Requirement:: + count_property(void) const + { + return property_.size (); + } + + + // ResourceDeploymentDescription + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + } + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ResourceDeploymentDescription& ResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s) + { + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void ResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // ResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void ResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // ResourceDeploymentDescription + // + ResourceDeploymentDescription::property_iterator ResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + ResourceDeploymentDescription::property_iterator ResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + ResourceDeploymentDescription::property_const_iterator ResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + ResourceDeploymentDescription::property_const_iterator ResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void ResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // ArtifactDeploymentDescription + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + regulator__ () + { + name_->container (this); + node_->container (this); + } + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + node_->container (this); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ArtifactDeploymentDescription& ArtifactDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s) + { + name (s.name ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + node (s.node ()); + + location_.clear (); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + execParameter_.clear (); + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ArtifactDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ArtifactDeploymentDescription:: + name () const + { + return *name_; + } + + void ArtifactDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::source_iterator ArtifactDeploymentDescription:: + begin_source () + { + return source_.begin (); + } + + ArtifactDeploymentDescription::source_iterator ArtifactDeploymentDescription:: + end_source () + { + return source_.end (); + } + + ArtifactDeploymentDescription::source_const_iterator ArtifactDeploymentDescription:: + begin_source () const + { + return source_.begin (); + } + + ArtifactDeploymentDescription::source_const_iterator ArtifactDeploymentDescription:: + end_source () const + { + return source_.end (); + } + + void ArtifactDeploymentDescription:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_source(void) const + { + return source_.size (); + } + + // ArtifactDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ArtifactDeploymentDescription:: + node () const + { + return *node_; + } + + void ArtifactDeploymentDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::location_iterator ArtifactDeploymentDescription:: + begin_location () + { + return location_.begin (); + } + + ArtifactDeploymentDescription::location_iterator ArtifactDeploymentDescription:: + end_location () + { + return location_.end (); + } + + ArtifactDeploymentDescription::location_const_iterator ArtifactDeploymentDescription:: + begin_location () const + { + return location_.begin (); + } + + ArtifactDeploymentDescription::location_const_iterator ArtifactDeploymentDescription:: + end_location () const + { + return location_.end (); + } + + void ArtifactDeploymentDescription:: + add_location (::XMLSchema::string< ACE_TCHAR > const& e) + { + location_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_location(void) const + { + return location_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::execParameter_iterator ArtifactDeploymentDescription:: + begin_execParameter () + { + return execParameter_.begin (); + } + + ArtifactDeploymentDescription::execParameter_iterator ArtifactDeploymentDescription:: + end_execParameter () + { + return execParameter_.end (); + } + + ArtifactDeploymentDescription::execParameter_const_iterator ArtifactDeploymentDescription:: + begin_execParameter () const + { + return execParameter_.begin (); + } + + ArtifactDeploymentDescription::execParameter_const_iterator ArtifactDeploymentDescription:: + end_execParameter () const + { + return execParameter_.end (); + } + + void ArtifactDeploymentDescription:: + add_execParameter (::CIAO::Config_Handlers::Property const& e) + { + execParameter_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_execParameter(void) const + { + return execParameter_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::deployRequirement_iterator ArtifactDeploymentDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + ArtifactDeploymentDescription::deployRequirement_iterator ArtifactDeploymentDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + ArtifactDeploymentDescription::deployRequirement_const_iterator ArtifactDeploymentDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + ArtifactDeploymentDescription::deployRequirement_const_iterator ArtifactDeploymentDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void ArtifactDeploymentDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // ArtifactDeploymentDescription + // + ArtifactDeploymentDescription::deployedResource_iterator ArtifactDeploymentDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + ArtifactDeploymentDescription::deployedResource_iterator ArtifactDeploymentDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + ArtifactDeploymentDescription::deployedResource_const_iterator ArtifactDeploymentDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + ArtifactDeploymentDescription::deployedResource_const_iterator ArtifactDeploymentDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void ArtifactDeploymentDescription:: + add_deployedResource (::CIAO::Config_Handlers::ResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t ArtifactDeploymentDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + // ArtifactDeploymentDescription + // + bool ArtifactDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ArtifactDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ArtifactDeploymentDescription:: + id () + { + return *id_; + } + + void ArtifactDeploymentDescription:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // MonolithicDeploymentDescription + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::MonolithicDeploymentDescription& MonolithicDeploymentDescription:: + operator= (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s) + { + name (s.name ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + artifact_.clear (); + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + execParameter_.clear (); + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // MonolithicDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& MonolithicDeploymentDescription:: + name () const + { + return *name_; + } + + void MonolithicDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::source_iterator MonolithicDeploymentDescription:: + begin_source () + { + return source_.begin (); + } + + MonolithicDeploymentDescription::source_iterator MonolithicDeploymentDescription:: + end_source () + { + return source_.end (); + } + + MonolithicDeploymentDescription::source_const_iterator MonolithicDeploymentDescription:: + begin_source () const + { + return source_.begin (); + } + + MonolithicDeploymentDescription::source_const_iterator MonolithicDeploymentDescription:: + end_source () const + { + return source_.end (); + } + + void MonolithicDeploymentDescription:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_source(void) const + { + return source_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::artifact_iterator MonolithicDeploymentDescription:: + begin_artifact () + { + return artifact_.begin (); + } + + MonolithicDeploymentDescription::artifact_iterator MonolithicDeploymentDescription:: + end_artifact () + { + return artifact_.end (); + } + + MonolithicDeploymentDescription::artifact_const_iterator MonolithicDeploymentDescription:: + begin_artifact () const + { + return artifact_.begin (); + } + + MonolithicDeploymentDescription::artifact_const_iterator MonolithicDeploymentDescription:: + end_artifact () const + { + return artifact_.end (); + } + + void MonolithicDeploymentDescription:: + add_artifact (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + artifact_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_artifact(void) const + { + return artifact_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::execParameter_iterator MonolithicDeploymentDescription:: + begin_execParameter () + { + return execParameter_.begin (); + } + + MonolithicDeploymentDescription::execParameter_iterator MonolithicDeploymentDescription:: + end_execParameter () + { + return execParameter_.end (); + } + + MonolithicDeploymentDescription::execParameter_const_iterator MonolithicDeploymentDescription:: + begin_execParameter () const + { + return execParameter_.begin (); + } + + MonolithicDeploymentDescription::execParameter_const_iterator MonolithicDeploymentDescription:: + end_execParameter () const + { + return execParameter_.end (); + } + + void MonolithicDeploymentDescription:: + add_execParameter (::CIAO::Config_Handlers::Property const& e) + { + execParameter_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_execParameter(void) const + { + return execParameter_.size (); + } + + // MonolithicDeploymentDescription + // + MonolithicDeploymentDescription::deployRequirement_iterator MonolithicDeploymentDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + MonolithicDeploymentDescription::deployRequirement_iterator MonolithicDeploymentDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + MonolithicDeploymentDescription::deployRequirement_const_iterator MonolithicDeploymentDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + MonolithicDeploymentDescription::deployRequirement_const_iterator MonolithicDeploymentDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void MonolithicDeploymentDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t MonolithicDeploymentDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // MonolithicDeploymentDescription + // + bool MonolithicDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& MonolithicDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& MonolithicDeploymentDescription:: + id () + { + return *id_; + } + + void MonolithicDeploymentDescription:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // ResourceUsageKind + // + + ResourceUsageKind::Value ResourceUsageKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::ResourceUsageKind const& a, ::CIAO::Config_Handlers::ResourceUsageKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::ResourceUsageKind const& a, ::CIAO::Config_Handlers::ResourceUsageKind const& b) + { + return a.v_ != b.v_; + } + + ResourceUsageKind:: + ResourceUsageKind (ResourceUsageKind::Value v) + : v_ (v) + { + } + + // InstanceResourceDeploymentDescription + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (resourceUsage__)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + resourceUsage_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + resourceUsage_->container (this); + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& InstanceResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s) + { + resourceUsage (s.resourceUsage ()); + + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // InstanceResourceDeploymentDescription + // + ::CIAO::Config_Handlers::ResourceUsageKind const& InstanceResourceDeploymentDescription:: + resourceUsage () const + { + return *resourceUsage_; + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e) + { + *resourceUsage_ = e; + } + + // InstanceResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void InstanceResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // InstanceResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void InstanceResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // InstanceResourceDeploymentDescription + // + InstanceResourceDeploymentDescription::property_iterator InstanceResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + InstanceResourceDeploymentDescription::property_iterator InstanceResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + InstanceResourceDeploymentDescription::property_const_iterator InstanceResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + InstanceResourceDeploymentDescription::property_const_iterator InstanceResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void InstanceResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t InstanceResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // InstanceDeploymentDescription + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::XMLSchema::string< ACE_TCHAR > const& source__, + ::XMLSchema::IDREF< ACE_TCHAR > const& implementation__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + source_ (new ::XMLSchema::string< ACE_TCHAR > (source__)), + implementation_ (new ::XMLSchema::IDREF< ACE_TCHAR > (implementation__)), + regulator__ () + { + name_->container (this); + node_->container (this); + source_->container (this); + implementation_->container (this); + } + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::CIAO::Config_Handlers::InstanceDeploymentDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + source_ (new ::XMLSchema::string< ACE_TCHAR > (*s.source_)), + implementation_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.implementation_)), + deployedSharedResource_ (s.deployedSharedResource_.get () ? new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (*s.deployedSharedResource_) : 0), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + node_->container (this); + source_->container (this); + implementation_->container (this); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (deployedSharedResource_.get ()) deployedSharedResource_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::InstanceDeploymentDescription& InstanceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::InstanceDeploymentDescription const& s) + { + name (s.name ()); + + node (s.node ()); + + source (s.source ()); + + implementation (s.implementation ()); + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + if (s.deployedSharedResource_.get ()) deployedSharedResource (*(s.deployedSharedResource_)); + else deployedSharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (0); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + name () const + { + return *name_; + } + + void InstanceDeploymentDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + node () const + { + return *node_; + } + + void InstanceDeploymentDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& InstanceDeploymentDescription:: + source () const + { + return *source_; + } + + void InstanceDeploymentDescription:: + source (::XMLSchema::string< ACE_TCHAR > const& e) + { + *source_ = e; + } + + // InstanceDeploymentDescription + // + ::XMLSchema::IDREF< ACE_TCHAR > const& InstanceDeploymentDescription:: + implementation () const + { + return *implementation_; + } + + void InstanceDeploymentDescription:: + implementation (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *implementation_ = e; + } + + // InstanceDeploymentDescription + // + InstanceDeploymentDescription::configProperty_iterator InstanceDeploymentDescription:: + begin_configProperty () + { + return configProperty_.begin (); + } + + InstanceDeploymentDescription::configProperty_iterator InstanceDeploymentDescription:: + end_configProperty () + { + return configProperty_.end (); + } + + InstanceDeploymentDescription::configProperty_const_iterator InstanceDeploymentDescription:: + begin_configProperty () const + { + return configProperty_.begin (); + } + + InstanceDeploymentDescription::configProperty_const_iterator InstanceDeploymentDescription:: + end_configProperty () const + { + return configProperty_.end (); + } + + void InstanceDeploymentDescription:: + add_configProperty (::CIAO::Config_Handlers::Property const& e) + { + configProperty_.push_back (e); + } + + size_t InstanceDeploymentDescription:: + count_configProperty(void) const + { + return configProperty_.size (); + } + + // InstanceDeploymentDescription + // + InstanceDeploymentDescription::deployedResource_iterator InstanceDeploymentDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + InstanceDeploymentDescription::deployedResource_iterator InstanceDeploymentDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + InstanceDeploymentDescription::deployedResource_const_iterator InstanceDeploymentDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + InstanceDeploymentDescription::deployedResource_const_iterator InstanceDeploymentDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void InstanceDeploymentDescription:: + add_deployedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t InstanceDeploymentDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + // InstanceDeploymentDescription + // + bool InstanceDeploymentDescription:: + deployedSharedResource_p () const + { + return deployedSharedResource_.get () != 0; + } + + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& InstanceDeploymentDescription:: + deployedSharedResource () const + { + return *deployedSharedResource_; + } + + void InstanceDeploymentDescription:: + deployedSharedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& e) + { + if (deployedSharedResource_.get ()) + { + *deployedSharedResource_ = e; + } + + else + { + deployedSharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (e)); + deployedSharedResource_->container (this); + } + } + + // InstanceDeploymentDescription + // + bool InstanceDeploymentDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& InstanceDeploymentDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& InstanceDeploymentDescription:: + id () + { + return *id_; + } + + void InstanceDeploymentDescription:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // CCMComponentPortKind + // + + CCMComponentPortKind::Value CCMComponentPortKind:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::CCMComponentPortKind const& a, ::CIAO::Config_Handlers::CCMComponentPortKind const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::CCMComponentPortKind const& a, ::CIAO::Config_Handlers::CCMComponentPortKind const& b) + { + return a.v_ != b.v_; + } + + CCMComponentPortKind:: + CCMComponentPortKind (CCMComponentPortKind::Value v) + : v_ (v) + { + } + + // ComponentPortDescription + // + + ComponentPortDescription:: + ComponentPortDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& provider__, + ::XMLSchema::boolean const& exclusiveProvider__, + ::XMLSchema::boolean const& exclusiveUser__, + ::XMLSchema::boolean const& optional__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + provider_ (new ::XMLSchema::boolean (provider__)), + exclusiveProvider_ (new ::XMLSchema::boolean (exclusiveProvider__)), + exclusiveUser_ (new ::XMLSchema::boolean (exclusiveUser__)), + optional_ (new ::XMLSchema::boolean (optional__)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (kind__)), + regulator__ () + { + name_->container (this); + provider_->container (this); + exclusiveProvider_->container (this); + exclusiveUser_->container (this); + optional_->container (this); + kind_->container (this); + } + + ComponentPortDescription:: + ComponentPortDescription (::CIAO::Config_Handlers::ComponentPortDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + specificType_ (s.specificType_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.specificType_) : 0), + provider_ (new ::XMLSchema::boolean (*s.provider_)), + exclusiveProvider_ (new ::XMLSchema::boolean (*s.exclusiveProvider_)), + exclusiveUser_ (new ::XMLSchema::boolean (*s.exclusiveUser_)), + optional_ (new ::XMLSchema::boolean (*s.optional_)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)), + regulator__ () + { + name_->container (this); + if (specificType_.get ()) specificType_->container (this); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + provider_->container (this); + exclusiveProvider_->container (this); + exclusiveUser_->container (this); + optional_->container (this); + kind_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPortDescription& ComponentPortDescription:: + operator= (::CIAO::Config_Handlers::ComponentPortDescription const& s) + { + name (s.name ()); + + if (s.specificType_.get ()) specificType (*(s.specificType_)); + else specificType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + supportedType_.clear (); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + provider (s.provider ()); + + exclusiveProvider (s.exclusiveProvider ()); + + exclusiveUser (s.exclusiveUser ()); + + optional (s.optional ()); + + kind (s.kind ()); + + return *this; + } + + + // ComponentPortDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPortDescription:: + name () const + { + return *name_; + } + + void ComponentPortDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ComponentPortDescription + // + bool ComponentPortDescription:: + specificType_p () const + { + return specificType_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPortDescription:: + specificType () const + { + return *specificType_; + } + + void ComponentPortDescription:: + specificType (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (specificType_.get ()) + { + *specificType_ = e; + } + + else + { + specificType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + specificType_->container (this); + } + } + + // ComponentPortDescription + // + ComponentPortDescription::supportedType_iterator ComponentPortDescription:: + begin_supportedType () + { + return supportedType_.begin (); + } + + ComponentPortDescription::supportedType_iterator ComponentPortDescription:: + end_supportedType () + { + return supportedType_.end (); + } + + ComponentPortDescription::supportedType_const_iterator ComponentPortDescription:: + begin_supportedType () const + { + return supportedType_.begin (); + } + + ComponentPortDescription::supportedType_const_iterator ComponentPortDescription:: + end_supportedType () const + { + return supportedType_.end (); + } + + void ComponentPortDescription:: + add_supportedType (::XMLSchema::string< ACE_TCHAR > const& e) + { + supportedType_.push_back (e); + } + + size_t ComponentPortDescription:: + count_supportedType(void) const + { + return supportedType_.size (); + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + provider () const + { + return *provider_; + } + + void ComponentPortDescription:: + provider (::XMLSchema::boolean const& e) + { + *provider_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + exclusiveProvider () const + { + return *exclusiveProvider_; + } + + void ComponentPortDescription:: + exclusiveProvider (::XMLSchema::boolean const& e) + { + *exclusiveProvider_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + exclusiveUser () const + { + return *exclusiveUser_; + } + + void ComponentPortDescription:: + exclusiveUser (::XMLSchema::boolean const& e) + { + *exclusiveUser_ = e; + } + + // ComponentPortDescription + // + ::XMLSchema::boolean const& ComponentPortDescription:: + optional () const + { + return *optional_; + } + + void ComponentPortDescription:: + optional (::XMLSchema::boolean const& e) + { + *optional_ = e; + } + + // ComponentPortDescription + // + ::CIAO::Config_Handlers::CCMComponentPortKind const& ComponentPortDescription:: + kind () const + { + return *kind_; + } + + void ComponentPortDescription:: + kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e) + { + *kind_ = e; + } + + + // ComponentPropertyDescription + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::DataType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::DataType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ComponentPropertyDescription:: + ComponentPropertyDescription (::CIAO::Config_Handlers::ComponentPropertyDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::DataType (*s.type_)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPropertyDescription& ComponentPropertyDescription:: + operator= (::CIAO::Config_Handlers::ComponentPropertyDescription const& s) + { + name (s.name ()); + + type (s.type ()); + + return *this; + } + + + // ComponentPropertyDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPropertyDescription:: + name () const + { + return *name_; + } + + void ComponentPropertyDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ComponentPropertyDescription + // + ::CIAO::Config_Handlers::DataType const& ComponentPropertyDescription:: + type () const + { + return *type_; + } + + void ComponentPropertyDescription:: + type (::CIAO::Config_Handlers::DataType const& e) + { + *type_ = e; + } + + + // ComponentExternalPortEndpoint + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + regulator__ () + { + portName_->container (this); + } + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + regulator__ () + { + portName_->container (this); + } + + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint& ComponentExternalPortEndpoint:: + operator= (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& s) + { + portName (s.portName ()); + + return *this; + } + + + // ComponentExternalPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentExternalPortEndpoint:: + portName () const + { + return *portName_; + } + + void ComponentExternalPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + + // PlanSubcomponentPortEndpoint + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__, + ::XMLSchema::IDREF< ACE_TCHAR > const& instance__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (kind__)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (instance__)), + regulator__ () + { + portName_->container (this); + kind_->container (this); + instance_->container (this); + } + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + provider_ (s.provider_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.provider_) : 0), + kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.instance_)), + regulator__ () + { + portName_->container (this); + if (provider_.get ()) provider_->container (this); + kind_->container (this); + instance_->container (this); + } + + ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint& PlanSubcomponentPortEndpoint:: + operator= (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& s) + { + portName (s.portName ()); + + if (s.provider_.get ()) provider (*(s.provider_)); + else provider_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + kind (s.kind ()); + + instance (s.instance ()); + + return *this; + } + + + // PlanSubcomponentPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + portName () const + { + return *portName_; + } + + void PlanSubcomponentPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + // PlanSubcomponentPortEndpoint + // + bool PlanSubcomponentPortEndpoint:: + provider_p () const + { + return provider_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + provider () const + { + return *provider_; + } + + void PlanSubcomponentPortEndpoint:: + provider (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (provider_.get ()) + { + *provider_ = e; + } + + else + { + provider_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + provider_->container (this); + } + } + + // PlanSubcomponentPortEndpoint + // + ::CIAO::Config_Handlers::CCMComponentPortKind const& PlanSubcomponentPortEndpoint:: + kind () const + { + return *kind_; + } + + void PlanSubcomponentPortEndpoint:: + kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e) + { + *kind_ = e; + } + + // PlanSubcomponentPortEndpoint + // + ::XMLSchema::IDREF< ACE_TCHAR > const& PlanSubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void PlanSubcomponentPortEndpoint:: + instance (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *instance_ = e; + } + + + // ExternalReferenceEndpoint + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XMLSchema::string< ACE_TCHAR > const& location__) + : + ::XSCRT::Type (), + location_ (new ::XMLSchema::string< ACE_TCHAR > (location__)), + regulator__ () + { + location_->container (this); + } + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& s) + : + ::XSCRT::Type (), + location_ (new ::XMLSchema::string< ACE_TCHAR > (*s.location_)), + regulator__ () + { + location_->container (this); + } + + ::CIAO::Config_Handlers::ExternalReferenceEndpoint& ExternalReferenceEndpoint:: + operator= (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& s) + { + location (s.location ()); + + return *this; + } + + + // ExternalReferenceEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& ExternalReferenceEndpoint:: + location () const + { + return *location_; + } + + void ExternalReferenceEndpoint:: + location (::XMLSchema::string< ACE_TCHAR > const& e) + { + *location_ = e; + } + + + // ConnectionResourceDeploymentDescription + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XMLSchema::string< ACE_TCHAR > const& targetName__, + ::XMLSchema::string< ACE_TCHAR > const& requirementName__, + ::XMLSchema::string< ACE_TCHAR > const& resourceName__) + : + ::XSCRT::Type (), + targetName_ (new ::XMLSchema::string< ACE_TCHAR > (targetName__)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (requirementName__)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (resourceName__)), + regulator__ () + { + targetName_->container (this); + requirementName_->container (this); + resourceName_->container (this); + } + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s) + : + ::XSCRT::Type (), + targetName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.targetName_)), + requirementName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requirementName_)), + resourceName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceName_)), + regulator__ () + { + targetName_->container (this); + requirementName_->container (this); + resourceName_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription& ConnectionResourceDeploymentDescription:: + operator= (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s) + { + targetName (s.targetName ()); + + requirementName (s.requirementName ()); + + resourceName (s.resourceName ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + targetName () const + { + return *targetName_; + } + + void ConnectionResourceDeploymentDescription:: + targetName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *targetName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + requirementName () const + { + return *requirementName_; + } + + void ConnectionResourceDeploymentDescription:: + requirementName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requirementName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ::XMLSchema::string< ACE_TCHAR > const& ConnectionResourceDeploymentDescription:: + resourceName () const + { + return *resourceName_; + } + + void ConnectionResourceDeploymentDescription:: + resourceName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceName_ = e; + } + + // ConnectionResourceDeploymentDescription + // + ConnectionResourceDeploymentDescription::property_iterator ConnectionResourceDeploymentDescription:: + begin_property () + { + return property_.begin (); + } + + ConnectionResourceDeploymentDescription::property_iterator ConnectionResourceDeploymentDescription:: + end_property () + { + return property_.end (); + } + + ConnectionResourceDeploymentDescription::property_const_iterator ConnectionResourceDeploymentDescription:: + begin_property () const + { + return property_.begin (); + } + + ConnectionResourceDeploymentDescription::property_const_iterator ConnectionResourceDeploymentDescription:: + end_property () const + { + return property_.end (); + } + + void ConnectionResourceDeploymentDescription:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ConnectionResourceDeploymentDescription:: + count_property(void) const + { + return property_.size (); + } + + + // PlanConnectionDescription + // + + PlanConnectionDescription:: + PlanConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + PlanConnectionDescription:: + PlanConnectionDescription (::CIAO::Config_Handlers::PlanConnectionDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + source_ (s.source_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.source_) : 0), + regulator__ () + { + name_->container (this); + if (source_.get ()) source_->container (this); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + } + + ::CIAO::Config_Handlers::PlanConnectionDescription& PlanConnectionDescription:: + operator= (::CIAO::Config_Handlers::PlanConnectionDescription const& s) + { + name (s.name ()); + + if (s.source_.get ()) source (*(s.source_)); + else source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + externalEndpoint_.clear (); + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + internalEndpoint_.clear (); + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + externalReference_.clear (); + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + deployedResource_.clear (); + { + for (deployedResource_const_iterator i (s.deployedResource_.begin ());i != s.deployedResource_.end ();++i) add_deployedResource (*i); + } + + return *this; + } + + + // PlanConnectionDescription + // + ::XMLSchema::string< ACE_TCHAR > const& PlanConnectionDescription:: + name () const + { + return *name_; + } + + void PlanConnectionDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // PlanConnectionDescription + // + bool PlanConnectionDescription:: + source_p () const + { + return source_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& PlanConnectionDescription:: + source () const + { + return *source_; + } + + void PlanConnectionDescription:: + source (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (source_.get ()) + { + *source_ = e; + } + + else + { + source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + source_->container (this); + } + } + + // PlanConnectionDescription + // + PlanConnectionDescription::deployRequirement_iterator PlanConnectionDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + PlanConnectionDescription::deployRequirement_iterator PlanConnectionDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + PlanConnectionDescription::deployRequirement_const_iterator PlanConnectionDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + PlanConnectionDescription::deployRequirement_const_iterator PlanConnectionDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void PlanConnectionDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::externalEndpoint_iterator PlanConnectionDescription:: + begin_externalEndpoint () + { + return externalEndpoint_.begin (); + } + + PlanConnectionDescription::externalEndpoint_iterator PlanConnectionDescription:: + end_externalEndpoint () + { + return externalEndpoint_.end (); + } + + PlanConnectionDescription::externalEndpoint_const_iterator PlanConnectionDescription:: + begin_externalEndpoint () const + { + return externalEndpoint_.begin (); + } + + PlanConnectionDescription::externalEndpoint_const_iterator PlanConnectionDescription:: + end_externalEndpoint () const + { + return externalEndpoint_.end (); + } + + void PlanConnectionDescription:: + add_externalEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& e) + { + externalEndpoint_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_externalEndpoint(void) const + { + return externalEndpoint_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::internalEndpoint_iterator PlanConnectionDescription:: + begin_internalEndpoint () + { + return internalEndpoint_.begin (); + } + + PlanConnectionDescription::internalEndpoint_iterator PlanConnectionDescription:: + end_internalEndpoint () + { + return internalEndpoint_.end (); + } + + PlanConnectionDescription::internalEndpoint_const_iterator PlanConnectionDescription:: + begin_internalEndpoint () const + { + return internalEndpoint_.begin (); + } + + PlanConnectionDescription::internalEndpoint_const_iterator PlanConnectionDescription:: + end_internalEndpoint () const + { + return internalEndpoint_.end (); + } + + void PlanConnectionDescription:: + add_internalEndpoint (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& e) + { + internalEndpoint_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_internalEndpoint(void) const + { + return internalEndpoint_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::externalReference_iterator PlanConnectionDescription:: + begin_externalReference () + { + return externalReference_.begin (); + } + + PlanConnectionDescription::externalReference_iterator PlanConnectionDescription:: + end_externalReference () + { + return externalReference_.end (); + } + + PlanConnectionDescription::externalReference_const_iterator PlanConnectionDescription:: + begin_externalReference () const + { + return externalReference_.begin (); + } + + PlanConnectionDescription::externalReference_const_iterator PlanConnectionDescription:: + end_externalReference () const + { + return externalReference_.end (); + } + + void PlanConnectionDescription:: + add_externalReference (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& e) + { + externalReference_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_externalReference(void) const + { + return externalReference_.size (); + } + + // PlanConnectionDescription + // + PlanConnectionDescription::deployedResource_iterator PlanConnectionDescription:: + begin_deployedResource () + { + return deployedResource_.begin (); + } + + PlanConnectionDescription::deployedResource_iterator PlanConnectionDescription:: + end_deployedResource () + { + return deployedResource_.end (); + } + + PlanConnectionDescription::deployedResource_const_iterator PlanConnectionDescription:: + begin_deployedResource () const + { + return deployedResource_.begin (); + } + + PlanConnectionDescription::deployedResource_const_iterator PlanConnectionDescription:: + end_deployedResource () const + { + return deployedResource_.end (); + } + + void PlanConnectionDescription:: + add_deployedResource (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& e) + { + deployedResource_.push_back (e); + } + + size_t PlanConnectionDescription:: + count_deployedResource(void) const + { + return deployedResource_.size (); + } + + + // ImplementationDependency + // + + ImplementationDependency:: + ImplementationDependency (::XMLSchema::string< ACE_TCHAR > const& requiredType__) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ImplementationDependency:: + ImplementationDependency (::CIAO::Config_Handlers::ImplementationDependency const& s) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requiredType_)), + regulator__ () + { + requiredType_->container (this); + } + + ::CIAO::Config_Handlers::ImplementationDependency& ImplementationDependency:: + operator= (::CIAO::Config_Handlers::ImplementationDependency const& s) + { + requiredType (s.requiredType ()); + + return *this; + } + + + // ImplementationDependency + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationDependency:: + requiredType () const + { + return *requiredType_; + } + + void ImplementationDependency:: + requiredType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requiredType_ = e; + } + + + // Capability + // + + Capability:: + Capability (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Capability:: + Capability (::CIAO::Config_Handlers::Capability const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::Capability& Capability:: + operator= (::CIAO::Config_Handlers::Capability const& s) + { + name (s.name ()); + + resourceType_.clear (); + { + for (resourceType_const_iterator i (s.resourceType_.begin ());i != s.resourceType_.end ();++i) add_resourceType (*i); + } + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // Capability + // + ::XMLSchema::string< ACE_TCHAR > const& Capability:: + name () const + { + return *name_; + } + + void Capability:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Capability + // + Capability::resourceType_iterator Capability:: + begin_resourceType () + { + return resourceType_.begin (); + } + + Capability::resourceType_iterator Capability:: + end_resourceType () + { + return resourceType_.end (); + } + + Capability::resourceType_const_iterator Capability:: + begin_resourceType () const + { + return resourceType_.begin (); + } + + Capability::resourceType_const_iterator Capability:: + end_resourceType () const + { + return resourceType_.end (); + } + + void Capability:: + add_resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + resourceType_.push_back (e); + } + + size_t Capability:: + count_resourceType(void) const + { + return resourceType_.size (); + } + + // Capability + // + Capability::property_iterator Capability:: + begin_property () + { + return property_.begin (); + } + + Capability::property_iterator Capability:: + end_property () + { + return property_.end (); + } + + Capability::property_const_iterator Capability:: + begin_property () const + { + return property_.begin (); + } + + Capability::property_const_iterator Capability:: + end_property () const + { + return property_.end (); + } + + void Capability:: + add_property (::CIAO::Config_Handlers::SatisfierProperty const& e) + { + property_.push_back (e); + } + + size_t Capability:: + count_property(void) const + { + return property_.size (); + } + + + // ImplementationRequirement + // + + ImplementationRequirement:: + ImplementationRequirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (resourceType__)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + resourceType_->container (this); + name_->container (this); + } + + ImplementationRequirement:: + ImplementationRequirement (::CIAO::Config_Handlers::ImplementationRequirement const& s) + : + ::XSCRT::Type (), + resourceUsage_ (s.resourceUsage_.get () ? new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_) : 0), + resourcePort_ (s.resourcePort_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.resourcePort_) : 0), + componentPort_ (s.componentPort_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.componentPort_) : 0), + resourceType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.resourceType_)), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + if (resourceUsage_.get ()) resourceUsage_->container (this); + if (resourcePort_.get ()) resourcePort_->container (this); + if (componentPort_.get ()) componentPort_->container (this); + resourceType_->container (this); + name_->container (this); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + } + + ::CIAO::Config_Handlers::ImplementationRequirement& ImplementationRequirement:: + operator= (::CIAO::Config_Handlers::ImplementationRequirement const& s) + { + if (s.resourceUsage_.get ()) resourceUsage (*(s.resourceUsage_)); + else resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (0); + + if (s.resourcePort_.get ()) resourcePort (*(s.resourcePort_)); + else resourcePort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.componentPort_.get ()) componentPort (*(s.componentPort_)); + else componentPort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + resourceType (s.resourceType ()); + + name (s.name ()); + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + return *this; + } + + + // ImplementationRequirement + // + bool ImplementationRequirement:: + resourceUsage_p () const + { + return resourceUsage_.get () != 0; + } + + ::CIAO::Config_Handlers::ResourceUsageKind const& ImplementationRequirement:: + resourceUsage () const + { + return *resourceUsage_; + } + + void ImplementationRequirement:: + resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e) + { + if (resourceUsage_.get ()) + { + *resourceUsage_ = e; + } + + else + { + resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (new ::CIAO::Config_Handlers::ResourceUsageKind (e)); + resourceUsage_->container (this); + } + } + + // ImplementationRequirement + // + bool ImplementationRequirement:: + resourcePort_p () const + { + return resourcePort_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + resourcePort () const + { + return *resourcePort_; + } + + void ImplementationRequirement:: + resourcePort (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (resourcePort_.get ()) + { + *resourcePort_ = e; + } + + else + { + resourcePort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourcePort_->container (this); + } + } + + // ImplementationRequirement + // + bool ImplementationRequirement:: + componentPort_p () const + { + return componentPort_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + componentPort () const + { + return *componentPort_; + } + + void ImplementationRequirement:: + componentPort (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (componentPort_.get ()) + { + *componentPort_ = e; + } + + else + { + componentPort_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + componentPort_->container (this); + } + } + + // ImplementationRequirement + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + resourceType () const + { + return *resourceType_; + } + + void ImplementationRequirement:: + resourceType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *resourceType_ = e; + } + + // ImplementationRequirement + // + ::XMLSchema::string< ACE_TCHAR > const& ImplementationRequirement:: + name () const + { + return *name_; + } + + void ImplementationRequirement:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // ImplementationRequirement + // + ImplementationRequirement::property_iterator ImplementationRequirement:: + begin_property () + { + return property_.begin (); + } + + ImplementationRequirement::property_iterator ImplementationRequirement:: + end_property () + { + return property_.end (); + } + + ImplementationRequirement::property_const_iterator ImplementationRequirement:: + begin_property () const + { + return property_.begin (); + } + + ImplementationRequirement::property_const_iterator ImplementationRequirement:: + end_property () const + { + return property_.end (); + } + + void ImplementationRequirement:: + add_property (::CIAO::Config_Handlers::Property const& e) + { + property_.push_back (e); + } + + size_t ImplementationRequirement:: + count_property(void) const + { + return property_.size (); + } + + + // ComponentPackageReference + // + + ComponentPackageReference:: + ComponentPackageReference (::XMLSchema::string< ACE_TCHAR > const& requiredType__) + : + ::XSCRT::Type (), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (requiredType__)), + regulator__ () + { + requiredType_->container (this); + } + + ComponentPackageReference:: + ComponentPackageReference (::CIAO::Config_Handlers::ComponentPackageReference const& s) + : + ::XSCRT::Type (), + requiredUUID_ (s.requiredUUID_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.requiredUUID_) : 0), + requiredName_ (s.requiredName_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.requiredName_) : 0), + requiredType_ (new ::XMLSchema::string< ACE_TCHAR > (*s.requiredType_)), + regulator__ () + { + if (requiredUUID_.get ()) requiredUUID_->container (this); + if (requiredName_.get ()) requiredName_->container (this); + requiredType_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPackageReference& ComponentPackageReference:: + operator= (::CIAO::Config_Handlers::ComponentPackageReference const& s) + { + if (s.requiredUUID_.get ()) requiredUUID (*(s.requiredUUID_)); + else requiredUUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.requiredName_.get ()) requiredName (*(s.requiredName_)); + else requiredName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + requiredType (s.requiredType ()); + + return *this; + } + + + // ComponentPackageReference + // + bool ComponentPackageReference:: + requiredUUID_p () const + { + return requiredUUID_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredUUID () const + { + return *requiredUUID_; + } + + void ComponentPackageReference:: + requiredUUID (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (requiredUUID_.get ()) + { + *requiredUUID_ = e; + } + + else + { + requiredUUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredUUID_->container (this); + } + } + + // ComponentPackageReference + // + bool ComponentPackageReference:: + requiredName_p () const + { + return requiredName_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredName () const + { + return *requiredName_; + } + + void ComponentPackageReference:: + requiredName (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (requiredName_.get ()) + { + *requiredName_ = e; + } + + else + { + requiredName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredName_->container (this); + } + } + + // ComponentPackageReference + // + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageReference:: + requiredType () const + { + return *requiredType_; + } + + void ComponentPackageReference:: + requiredType (::XMLSchema::string< ACE_TCHAR > const& e) + { + *requiredType_ = e; + } + + + // SubcomponentPortEndpoint + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::XMLSchema::IDREF< ACE_TCHAR > const& instance__) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (portName__)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (instance__)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& s) + : + ::XSCRT::Type (), + portName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.portName_)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.instance_)), + regulator__ () + { + portName_->container (this); + instance_->container (this); + } + + ::CIAO::Config_Handlers::SubcomponentPortEndpoint& SubcomponentPortEndpoint:: + operator= (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& s) + { + portName (s.portName ()); + + instance (s.instance ()); + + return *this; + } + + + // SubcomponentPortEndpoint + // + ::XMLSchema::string< ACE_TCHAR > const& SubcomponentPortEndpoint:: + portName () const + { + return *portName_; + } + + void SubcomponentPortEndpoint:: + portName (::XMLSchema::string< ACE_TCHAR > const& e) + { + *portName_ = e; + } + + // SubcomponentPortEndpoint + // + ::XMLSchema::IDREF< ACE_TCHAR > const& SubcomponentPortEndpoint:: + instance () const + { + return *instance_; + } + + void SubcomponentPortEndpoint:: + instance (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *instance_ = e; + } + + + // AssemblyConnectionDescription + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::CIAO::Config_Handlers::AssemblyConnectionDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + regulator__ () + { + name_->container (this); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + } + + ::CIAO::Config_Handlers::AssemblyConnectionDescription& AssemblyConnectionDescription:: + operator= (::CIAO::Config_Handlers::AssemblyConnectionDescription const& s) + { + name (s.name ()); + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + internalEndpoint_.clear (); + { + for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());i != s.internalEndpoint_.end ();++i) add_internalEndpoint (*i); + } + + externalEndpoint_.clear (); + { + for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());i != s.externalEndpoint_.end ();++i) add_externalEndpoint (*i); + } + + externalReference_.clear (); + { + for (externalReference_const_iterator i (s.externalReference_.begin ());i != s.externalReference_.end ();++i) add_externalReference (*i); + } + + return *this; + } + + + // AssemblyConnectionDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AssemblyConnectionDescription:: + name () const + { + return *name_; + } + + void AssemblyConnectionDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::deployRequirement_iterator AssemblyConnectionDescription:: + begin_deployRequirement () + { + return deployRequirement_.begin (); + } + + AssemblyConnectionDescription::deployRequirement_iterator AssemblyConnectionDescription:: + end_deployRequirement () + { + return deployRequirement_.end (); + } + + AssemblyConnectionDescription::deployRequirement_const_iterator AssemblyConnectionDescription:: + begin_deployRequirement () const + { + return deployRequirement_.begin (); + } + + AssemblyConnectionDescription::deployRequirement_const_iterator AssemblyConnectionDescription:: + end_deployRequirement () const + { + return deployRequirement_.end (); + } + + void AssemblyConnectionDescription:: + add_deployRequirement (::CIAO::Config_Handlers::Requirement const& e) + { + deployRequirement_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_deployRequirement(void) const + { + return deployRequirement_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::internalEndpoint_iterator AssemblyConnectionDescription:: + begin_internalEndpoint () + { + return internalEndpoint_.begin (); + } + + AssemblyConnectionDescription::internalEndpoint_iterator AssemblyConnectionDescription:: + end_internalEndpoint () + { + return internalEndpoint_.end (); + } + + AssemblyConnectionDescription::internalEndpoint_const_iterator AssemblyConnectionDescription:: + begin_internalEndpoint () const + { + return internalEndpoint_.begin (); + } + + AssemblyConnectionDescription::internalEndpoint_const_iterator AssemblyConnectionDescription:: + end_internalEndpoint () const + { + return internalEndpoint_.end (); + } + + void AssemblyConnectionDescription:: + add_internalEndpoint (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& e) + { + internalEndpoint_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_internalEndpoint(void) const + { + return internalEndpoint_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::externalEndpoint_iterator AssemblyConnectionDescription:: + begin_externalEndpoint () + { + return externalEndpoint_.begin (); + } + + AssemblyConnectionDescription::externalEndpoint_iterator AssemblyConnectionDescription:: + end_externalEndpoint () + { + return externalEndpoint_.end (); + } + + AssemblyConnectionDescription::externalEndpoint_const_iterator AssemblyConnectionDescription:: + begin_externalEndpoint () const + { + return externalEndpoint_.begin (); + } + + AssemblyConnectionDescription::externalEndpoint_const_iterator AssemblyConnectionDescription:: + end_externalEndpoint () const + { + return externalEndpoint_.end (); + } + + void AssemblyConnectionDescription:: + add_externalEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& e) + { + externalEndpoint_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_externalEndpoint(void) const + { + return externalEndpoint_.size (); + } + + // AssemblyConnectionDescription + // + AssemblyConnectionDescription::externalReference_iterator AssemblyConnectionDescription:: + begin_externalReference () + { + return externalReference_.begin (); + } + + AssemblyConnectionDescription::externalReference_iterator AssemblyConnectionDescription:: + end_externalReference () + { + return externalReference_.end (); + } + + AssemblyConnectionDescription::externalReference_const_iterator AssemblyConnectionDescription:: + begin_externalReference () const + { + return externalReference_.begin (); + } + + AssemblyConnectionDescription::externalReference_const_iterator AssemblyConnectionDescription:: + end_externalReference () const + { + return externalReference_.end (); + } + + void AssemblyConnectionDescription:: + add_externalReference (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& e) + { + externalReference_.push_back (e); + } + + size_t AssemblyConnectionDescription:: + count_externalReference(void) const + { + return externalReference_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // TCKind + // + + TCKind:: + TCKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "tk_null") v_ = tk_null_l; + else if (v == "tk_void") v_ = tk_void_l; + else if (v == "tk_short") v_ = tk_short_l; + else if (v == "tk_long") v_ = tk_long_l; + else if (v == "tk_ushort") v_ = tk_ushort_l; + else if (v == "tk_ulong") v_ = tk_ulong_l; + else if (v == "tk_float") v_ = tk_float_l; + else if (v == "tk_double") v_ = tk_double_l; + else if (v == "tk_boolean") v_ = tk_boolean_l; + else if (v == "tk_char") v_ = tk_char_l; + else if (v == "tk_octet") v_ = tk_octet_l; + else if (v == "tk_any") v_ = tk_any_l; + else if (v == "tk_TypeCode") v_ = tk_TypeCode_l; + else if (v == "tk_Principal") v_ = tk_Principal_l; + else if (v == "tk_objref") v_ = tk_objref_l; + else if (v == "tk_struct") v_ = tk_struct_l; + else if (v == "tk_union") v_ = tk_union_l; + else if (v == "tk_enum") v_ = tk_enum_l; + else if (v == "tk_string") v_ = tk_string_l; + else if (v == "tk_sequence") v_ = tk_sequence_l; + else if (v == "tk_array") v_ = tk_array_l; + else if (v == "tk_alias") v_ = tk_alias_l; + else if (v == "tk_except") v_ = tk_except_l; + else if (v == "tk_longlong") v_ = tk_longlong_l; + else if (v == "tk_ulonglong") v_ = tk_ulonglong_l; + else if (v == "tk_longdouble") v_ = tk_longdouble_l; + else if (v == "tk_wchar") v_ = tk_wchar_l; + else if (v == "tk_wstring") v_ = tk_wstring_l; + else if (v == "tk_wfixed") v_ = tk_wfixed_l; + else if (v == "tk_value") v_ = tk_value_l; + else if (v == "tk_value_box") v_ = tk_value_box_l; + else if (v == "tk_native") v_ = tk_native_l; + else if (v == "tk_abstract_interface") v_ = tk_abstract_interface_l; + else if (v == "tk_local_interface") v_ = tk_local_interface_l; + else if (v == "tk_component") v_ = tk_component_l; + else if (v == "tk_home") v_ = tk_home_l; + else if (v == "tk_event") v_ = tk_event_l; + else + { + } + } + + TCKind:: + TCKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "tk_null") v_ = tk_null_l; + else if (v == "tk_void") v_ = tk_void_l; + else if (v == "tk_short") v_ = tk_short_l; + else if (v == "tk_long") v_ = tk_long_l; + else if (v == "tk_ushort") v_ = tk_ushort_l; + else if (v == "tk_ulong") v_ = tk_ulong_l; + else if (v == "tk_float") v_ = tk_float_l; + else if (v == "tk_double") v_ = tk_double_l; + else if (v == "tk_boolean") v_ = tk_boolean_l; + else if (v == "tk_char") v_ = tk_char_l; + else if (v == "tk_octet") v_ = tk_octet_l; + else if (v == "tk_any") v_ = tk_any_l; + else if (v == "tk_TypeCode") v_ = tk_TypeCode_l; + else if (v == "tk_Principal") v_ = tk_Principal_l; + else if (v == "tk_objref") v_ = tk_objref_l; + else if (v == "tk_struct") v_ = tk_struct_l; + else if (v == "tk_union") v_ = tk_union_l; + else if (v == "tk_enum") v_ = tk_enum_l; + else if (v == "tk_string") v_ = tk_string_l; + else if (v == "tk_sequence") v_ = tk_sequence_l; + else if (v == "tk_array") v_ = tk_array_l; + else if (v == "tk_alias") v_ = tk_alias_l; + else if (v == "tk_except") v_ = tk_except_l; + else if (v == "tk_longlong") v_ = tk_longlong_l; + else if (v == "tk_ulonglong") v_ = tk_ulonglong_l; + else if (v == "tk_longdouble") v_ = tk_longdouble_l; + else if (v == "tk_wchar") v_ = tk_wchar_l; + else if (v == "tk_wstring") v_ = tk_wstring_l; + else if (v == "tk_wfixed") v_ = tk_wfixed_l; + else if (v == "tk_value") v_ = tk_value_l; + else if (v == "tk_value_box") v_ = tk_value_box_l; + else if (v == "tk_native") v_ = tk_native_l; + else if (v == "tk_abstract_interface") v_ = tk_abstract_interface_l; + else if (v == "tk_local_interface") v_ = tk_local_interface_l; + else if (v == "tk_component") v_ = tk_component_l; + else if (v == "tk_home") v_ = tk_home_l; + else if (v == "tk_event") v_ = tk_event_l; + else + { + } + } + + TCKind const TCKind::tk_null (TCKind::tk_null_l); + TCKind const TCKind::tk_void (TCKind::tk_void_l); + TCKind const TCKind::tk_short (TCKind::tk_short_l); + TCKind const TCKind::tk_long (TCKind::tk_long_l); + TCKind const TCKind::tk_ushort (TCKind::tk_ushort_l); + TCKind const TCKind::tk_ulong (TCKind::tk_ulong_l); + TCKind const TCKind::tk_float (TCKind::tk_float_l); + TCKind const TCKind::tk_double (TCKind::tk_double_l); + TCKind const TCKind::tk_boolean (TCKind::tk_boolean_l); + TCKind const TCKind::tk_char (TCKind::tk_char_l); + TCKind const TCKind::tk_octet (TCKind::tk_octet_l); + TCKind const TCKind::tk_any (TCKind::tk_any_l); + TCKind const TCKind::tk_TypeCode (TCKind::tk_TypeCode_l); + TCKind const TCKind::tk_Principal (TCKind::tk_Principal_l); + TCKind const TCKind::tk_objref (TCKind::tk_objref_l); + TCKind const TCKind::tk_struct (TCKind::tk_struct_l); + TCKind const TCKind::tk_union (TCKind::tk_union_l); + TCKind const TCKind::tk_enum (TCKind::tk_enum_l); + TCKind const TCKind::tk_string (TCKind::tk_string_l); + TCKind const TCKind::tk_sequence (TCKind::tk_sequence_l); + TCKind const TCKind::tk_array (TCKind::tk_array_l); + TCKind const TCKind::tk_alias (TCKind::tk_alias_l); + TCKind const TCKind::tk_except (TCKind::tk_except_l); + TCKind const TCKind::tk_longlong (TCKind::tk_longlong_l); + TCKind const TCKind::tk_ulonglong (TCKind::tk_ulonglong_l); + TCKind const TCKind::tk_longdouble (TCKind::tk_longdouble_l); + TCKind const TCKind::tk_wchar (TCKind::tk_wchar_l); + TCKind const TCKind::tk_wstring (TCKind::tk_wstring_l); + TCKind const TCKind::tk_wfixed (TCKind::tk_wfixed_l); + TCKind const TCKind::tk_value (TCKind::tk_value_l); + TCKind const TCKind::tk_value_box (TCKind::tk_value_box_l); + TCKind const TCKind::tk_native (TCKind::tk_native_l); + TCKind const TCKind::tk_abstract_interface (TCKind::tk_abstract_interface_l); + TCKind const TCKind::tk_local_interface (TCKind::tk_local_interface_l); + TCKind const TCKind::tk_component (TCKind::tk_component_l); + TCKind const TCKind::tk_home (TCKind::tk_home_l); + TCKind const TCKind::tk_event (TCKind::tk_event_l); + + // DataType + // + + DataType:: + DataType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > (new ::CIAO::Config_Handlers::TCKind (e)); + kind_->container (this); + } + + else if (n == "enum") + { + ::CIAO::Config_Handlers::EnumType t (e); + enum_ (t); + } + + else if (n == "struct") + { + ::CIAO::Config_Handlers::StructType t (e); + struct_ (t); + } + + else if (n == "value") + { + ::CIAO::Config_Handlers::ValueType t (e); + value (t); + } + + else if (n == "sequence") + { + ::CIAO::Config_Handlers::SequenceType t (e); + sequence (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // DataValue + // + + DataValue:: + DataValue (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "short") + { + ::XMLSchema::short_ t (e); + add_short (t); + } + + else if (n == "long") + { + ::XMLSchema::int_ t (e); + add_long (t); + } + + else if (n == "ushort") + { + ::XMLSchema::unsignedShort t (e); + add_ushort (t); + } + + else if (n == "ulong") + { + ::XMLSchema::unsignedInt t (e); + add_ulong (t); + } + + else if (n == "float") + { + ::XMLSchema::float_ t (e); + add_float (t); + } + + else if (n == "double") + { + ::XMLSchema::double_ t (e); + add_double (t); + } + + else if (n == "boolean") + { + ::XMLSchema::boolean t (e); + add_boolean (t); + } + + else if (n == "octet") + { + ::XMLSchema::unsignedByte t (e); + add_octet (t); + } + + else if (n == "enum") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_enum (t); + } + + else if (n == "string") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_string (t); + } + + else if (n == "longlong") + { + ::XMLSchema::long_ t (e); + add_longlong (t); + } + + else if (n == "ulonglong") + { + ::XMLSchema::unsignedLong t (e); + add_ulonglong (t); + } + + else if (n == "longdouble") + { + ::XMLSchema::double_ t (e); + add_longdouble (t); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::NamedValue t (e); + add_member (t); + } + + else + { + } + } + } + + // EnumType + // + + EnumType:: + EnumType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "member") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_member (t); + } + + else + { + } + } + } + + // StructType + // + + StructType:: + StructType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::StructMemberType t (e); + add_member (t); + } + + else + { + } + } + } + + // StructMemberType + // + + StructMemberType:: + StructMemberType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // ValueType + // + + ValueType:: + ValueType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "typeId") + { + typeId_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + typeId_->container (this); + } + + else if (n == "modifier") + { + modifier_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + modifier_->container (this); + } + + else if (n == "baseType") + { + baseType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + baseType_->container (this); + } + + else if (n == "member") + { + ::CIAO::Config_Handlers::ValueMemberType t (e); + add_member (t); + } + + else + { + } + } + } + + // ValueMemberType + // + + ValueMemberType:: + ValueMemberType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "visibility") + { + visibility_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + visibility_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // NamedValue + // + + NamedValue:: + NamedValue (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > (new ::CIAO::Config_Handlers::DataValue (e)); + value_->container (this); + } + + else + { + } + } + } + + // SequenceType + // + + SequenceType:: + SequenceType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "bound") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + bound (t); + } + + else if (n == "elementType") + { + elementType_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + elementType_->container (this); + } + + else + { + } + } + } + + // Any + // + + Any:: + Any (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > (new ::CIAO::Config_Handlers::DataValue (e)); + value_->container (this); + } + + else + { + } + } + } + + // Property + // + + Property:: + Property (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Any > (new ::CIAO::Config_Handlers::Any (e)); + value_->container (this); + } + + else + { + } + } + } + + // SatisfierPropertyKind + // + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "Quantity") v_ = Quantity_l; + else if (v == "Capacity") v_ = Capacity_l; + else if (v == "Minimum") v_ = Minimum_l; + else if (v == "Maximum") v_ = Maximum_l; + else if (v == "Attribute") v_ = Attribute_l; + else if (v == "Selection") v_ = Selection_l; + else + { + } + } + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "Quantity") v_ = Quantity_l; + else if (v == "Capacity") v_ = Capacity_l; + else if (v == "Minimum") v_ = Minimum_l; + else if (v == "Maximum") v_ = Maximum_l; + else if (v == "Attribute") v_ = Attribute_l; + else if (v == "Selection") v_ = Selection_l; + else + { + } + } + + SatisfierPropertyKind const SatisfierPropertyKind::Quantity (SatisfierPropertyKind::Quantity_l); + SatisfierPropertyKind const SatisfierPropertyKind::Capacity (SatisfierPropertyKind::Capacity_l); + SatisfierPropertyKind const SatisfierPropertyKind::Minimum (SatisfierPropertyKind::Minimum_l); + SatisfierPropertyKind const SatisfierPropertyKind::Maximum (SatisfierPropertyKind::Maximum_l); + SatisfierPropertyKind const SatisfierPropertyKind::Attribute (SatisfierPropertyKind::Attribute_l); + SatisfierPropertyKind const SatisfierPropertyKind::Selection (SatisfierPropertyKind::Selection_l); + + // SatisfierProperty + // + + SatisfierProperty:: + SatisfierProperty (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierPropertyKind > (new ::CIAO::Config_Handlers::SatisfierPropertyKind (e)); + kind_->container (this); + } + + else if (n == "dynamic") + { + dynamic_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + dynamic_->container (this); + } + + else if (n == "value") + { + value_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Any > (new ::CIAO::Config_Handlers::Any (e)); + value_->container (this); + } + + else + { + } + } + } + + // Resource + // + + Resource:: + Resource (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "resourceType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_resourceType (t); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::SatisfierProperty t (e); + add_property (t); + } + + else + { + } + } + } + + // Requirement + // + + Requirement:: + Requirement (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "resourceType") + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ResourceDeploymentDescription + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ArtifactDeploymentDescription + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == "location") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_location (t); + } + + else if (n == "execParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_execParameter (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::ResourceDeploymentDescription t (e); + add_deployedResource (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // MonolithicDeploymentDescription + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else if (n == "artifact") + { + ::XMLSchema::IDREF< ACE_TCHAR > t (e); + add_artifact (t); + } + + else if (n == "execParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_execParameter (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // ResourceUsageKind + // + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "None") v_ = None_l; + else if (v == "InstanceUsesResource") v_ = InstanceUsesResource_l; + else if (v == "ResourceUsesInstance") v_ = ResourceUsesInstance_l; + else if (v == "PortUsesResource") v_ = PortUsesResource_l; + else if (v == "ResourceUsesPort") v_ = ResourceUsesPort_l; + else + { + } + } + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "None") v_ = None_l; + else if (v == "InstanceUsesResource") v_ = InstanceUsesResource_l; + else if (v == "ResourceUsesInstance") v_ = ResourceUsesInstance_l; + else if (v == "PortUsesResource") v_ = PortUsesResource_l; + else if (v == "ResourceUsesPort") v_ = ResourceUsesPort_l; + else + { + } + } + + ResourceUsageKind const ResourceUsageKind::None (ResourceUsageKind::None_l); + ResourceUsageKind const ResourceUsageKind::InstanceUsesResource (ResourceUsageKind::InstanceUsesResource_l); + ResourceUsageKind const ResourceUsageKind::ResourceUsesInstance (ResourceUsageKind::ResourceUsesInstance_l); + ResourceUsageKind const ResourceUsageKind::PortUsesResource (ResourceUsageKind::PortUsesResource_l); + ResourceUsageKind const ResourceUsageKind::ResourceUsesPort (ResourceUsageKind::ResourceUsesPort_l); + + // InstanceResourceDeploymentDescription + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "resourceUsage") + { + resourceUsage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > (new ::CIAO::Config_Handlers::ResourceUsageKind (e)); + resourceUsage_->container (this); + } + + else if (n == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // InstanceDeploymentDescription + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == "source") + { + source_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + source_->container (this); + } + + else if (n == "implementation") + { + implementation_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + implementation_->container (this); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e); + add_deployedResource (t); + } + + else if (n == "deployedSharedResource") + { + ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e); + deployedSharedResource (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // CCMComponentPortKind + // + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "Facet") v_ = Facet_l; + else if (v == "SimplexReceptacle") v_ = SimplexReceptacle_l; + else if (v == "MultiplexReceptacle") v_ = MultiplexReceptacle_l; + else if (v == "EventEmitter") v_ = EventEmitter_l; + else if (v == "EventPublisher") v_ = EventPublisher_l; + else if (v == "EventConsumer") v_ = EventConsumer_l; + else + { + } + } + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "Facet") v_ = Facet_l; + else if (v == "SimplexReceptacle") v_ = SimplexReceptacle_l; + else if (v == "MultiplexReceptacle") v_ = MultiplexReceptacle_l; + else if (v == "EventEmitter") v_ = EventEmitter_l; + else if (v == "EventPublisher") v_ = EventPublisher_l; + else if (v == "EventConsumer") v_ = EventConsumer_l; + else + { + } + } + + CCMComponentPortKind const CCMComponentPortKind::Facet (CCMComponentPortKind::Facet_l); + CCMComponentPortKind const CCMComponentPortKind::SimplexReceptacle (CCMComponentPortKind::SimplexReceptacle_l); + CCMComponentPortKind const CCMComponentPortKind::MultiplexReceptacle (CCMComponentPortKind::MultiplexReceptacle_l); + CCMComponentPortKind const CCMComponentPortKind::EventEmitter (CCMComponentPortKind::EventEmitter_l); + CCMComponentPortKind const CCMComponentPortKind::EventPublisher (CCMComponentPortKind::EventPublisher_l); + CCMComponentPortKind const CCMComponentPortKind::EventConsumer (CCMComponentPortKind::EventConsumer_l); + + // ComponentPortDescription + // + + ComponentPortDescription:: + ComponentPortDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "specificType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + specificType (t); + } + + else if (n == "supportedType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_supportedType (t); + } + + else if (n == "provider") + { + provider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + provider_->container (this); + } + + else if (n == "exclusiveProvider") + { + exclusiveProvider_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveProvider_->container (this); + } + + else if (n == "exclusiveUser") + { + exclusiveUser_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + exclusiveUser_->container (this); + } + + else if (n == "optional") + { + optional_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + optional_->container (this); + } + + else if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else + { + } + } + } + + // ComponentPropertyDescription + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e)); + type_->container (this); + } + + else + { + } + } + } + + // ComponentExternalPortEndpoint + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else + { + } + } + } + + // PlanSubcomponentPortEndpoint + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == "provider") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + provider (t); + } + + else if (n == "kind") + { + kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > (new ::CIAO::Config_Handlers::CCMComponentPortKind (e)); + kind_->container (this); + } + + else if (n == "instance") + { + instance_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + instance_->container (this); + } + + else + { + } + } + } + + // ExternalReferenceEndpoint + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "location") + { + location_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + location_->container (this); + } + + else + { + } + } + } + + // ConnectionResourceDeploymentDescription + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "targetName") + { + targetName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + targetName_->container (this); + } + + else if (n == "requirementName") + { + requirementName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requirementName_->container (this); + } + + else if (n == "resourceName") + { + resourceName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceName_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // PlanConnectionDescription + // + + PlanConnectionDescription:: + PlanConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + source (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "externalEndpoint") + { + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint t (e); + add_externalEndpoint (t); + } + + else if (n == "internalEndpoint") + { + ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint t (e); + add_internalEndpoint (t); + } + + else if (n == "externalReference") + { + ::CIAO::Config_Handlers::ExternalReferenceEndpoint t (e); + add_externalReference (t); + } + + else if (n == "deployedResource") + { + ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription t (e); + add_deployedResource (t); + } + + else + { + } + } + } + + // ImplementationDependency + // + + ImplementationDependency:: + ImplementationDependency (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "requiredType") + { + requiredType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredType_->container (this); + } + + else + { + } + } + } + + // Capability + // + + Capability:: + Capability (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "resourceType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_resourceType (t); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::SatisfierProperty t (e); + add_property (t); + } + + else + { + } + } + } + + // ImplementationRequirement + // + + ImplementationRequirement:: + ImplementationRequirement (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "resourceUsage") + { + ::CIAO::Config_Handlers::ResourceUsageKind t (e); + resourceUsage (t); + } + + else if (n == "resourcePort") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + resourcePort (t); + } + + else if (n == "componentPort") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + componentPort (t); + } + + else if (n == "resourceType") + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::Property t (e); + add_property (t); + } + + else + { + } + } + } + + // ComponentPackageReference + // + + ComponentPackageReference:: + ComponentPackageReference (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "requiredUUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredUUID (t); + } + + else if (n == "requiredName") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + requiredName (t); + } + + else if (n == "requiredType") + { + requiredType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + requiredType_->container (this); + } + + else + { + } + } + } + + // SubcomponentPortEndpoint + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "portName") + { + portName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + portName_->container (this); + } + + else if (n == "instance") + { + instance_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (e)); + instance_->container (this); + } + + else + { + } + } + } + + // AssemblyConnectionDescription + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "internalEndpoint") + { + ::CIAO::Config_Handlers::SubcomponentPortEndpoint t (e); + add_internalEndpoint (t); + } + + else if (n == "externalEndpoint") + { + ::CIAO::Config_Handlers::ComponentExternalPortEndpoint t (e); + add_externalEndpoint (t); + } + + else if (n == "externalReference") + { + ::CIAO::Config_Handlers::ExternalReferenceEndpoint t (e); + add_externalReference (t); + } + + else + { + } + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/TypeInfo.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace + { + ::XMLSchema::TypeInfoInitializer < ACE_TCHAR > XMLSchemaTypeInfoInitializer_ (::XSCRT::extended_type_info_map ()); + + struct TCKindTypeInfoInitializer + { + TCKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (TCKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + TCKindTypeInfoInitializer TCKindTypeInfoInitializer_; + + struct DataTypeTypeInfoInitializer + { + DataTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (DataType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + DataTypeTypeInfoInitializer DataTypeTypeInfoInitializer_; + + struct DataValueTypeInfoInitializer + { + DataValueTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (DataValue)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + DataValueTypeInfoInitializer DataValueTypeInfoInitializer_; + + struct EnumTypeTypeInfoInitializer + { + EnumTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (EnumType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + EnumTypeTypeInfoInitializer EnumTypeTypeInfoInitializer_; + + struct StructTypeTypeInfoInitializer + { + StructTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (StructType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + StructTypeTypeInfoInitializer StructTypeTypeInfoInitializer_; + + struct StructMemberTypeTypeInfoInitializer + { + StructMemberTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (StructMemberType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + StructMemberTypeTypeInfoInitializer StructMemberTypeTypeInfoInitializer_; + + struct ValueTypeTypeInfoInitializer + { + ValueTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ValueType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ValueTypeTypeInfoInitializer ValueTypeTypeInfoInitializer_; + + struct ValueMemberTypeTypeInfoInitializer + { + ValueMemberTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ValueMemberType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ValueMemberTypeTypeInfoInitializer ValueMemberTypeTypeInfoInitializer_; + + struct NamedValueTypeInfoInitializer + { + NamedValueTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (NamedValue)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + NamedValueTypeInfoInitializer NamedValueTypeInfoInitializer_; + + struct SequenceTypeTypeInfoInitializer + { + SequenceTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SequenceType)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SequenceTypeTypeInfoInitializer SequenceTypeTypeInfoInitializer_; + + struct AnyTypeInfoInitializer + { + AnyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Any)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + AnyTypeInfoInitializer AnyTypeInfoInitializer_; + + struct PropertyTypeInfoInitializer + { + PropertyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Property)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PropertyTypeInfoInitializer PropertyTypeInfoInitializer_; + + struct SatisfierPropertyKindTypeInfoInitializer + { + SatisfierPropertyKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SatisfierPropertyKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SatisfierPropertyKindTypeInfoInitializer SatisfierPropertyKindTypeInfoInitializer_; + + struct SatisfierPropertyTypeInfoInitializer + { + SatisfierPropertyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SatisfierProperty)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SatisfierPropertyTypeInfoInitializer SatisfierPropertyTypeInfoInitializer_; + + struct ResourceTypeInfoInitializer + { + ResourceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Resource)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceTypeInfoInitializer ResourceTypeInfoInitializer_; + + struct RequirementTypeInfoInitializer + { + RequirementTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Requirement)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + RequirementTypeInfoInitializer RequirementTypeInfoInitializer_; + + struct ResourceDeploymentDescriptionTypeInfoInitializer + { + ResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceDeploymentDescriptionTypeInfoInitializer ResourceDeploymentDescriptionTypeInfoInitializer_; + + struct ArtifactDeploymentDescriptionTypeInfoInitializer + { + ArtifactDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ArtifactDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ArtifactDeploymentDescriptionTypeInfoInitializer ArtifactDeploymentDescriptionTypeInfoInitializer_; + + struct MonolithicDeploymentDescriptionTypeInfoInitializer + { + MonolithicDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (MonolithicDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + MonolithicDeploymentDescriptionTypeInfoInitializer MonolithicDeploymentDescriptionTypeInfoInitializer_; + + struct ResourceUsageKindTypeInfoInitializer + { + ResourceUsageKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ResourceUsageKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ResourceUsageKindTypeInfoInitializer ResourceUsageKindTypeInfoInitializer_; + + struct InstanceResourceDeploymentDescriptionTypeInfoInitializer + { + InstanceResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (InstanceResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + InstanceResourceDeploymentDescriptionTypeInfoInitializer InstanceResourceDeploymentDescriptionTypeInfoInitializer_; + + struct InstanceDeploymentDescriptionTypeInfoInitializer + { + InstanceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (InstanceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + InstanceDeploymentDescriptionTypeInfoInitializer InstanceDeploymentDescriptionTypeInfoInitializer_; + + struct CCMComponentPortKindTypeInfoInitializer + { + CCMComponentPortKindTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (CCMComponentPortKind)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + CCMComponentPortKindTypeInfoInitializer CCMComponentPortKindTypeInfoInitializer_; + + struct ComponentPortDescriptionTypeInfoInitializer + { + ComponentPortDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPortDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPortDescriptionTypeInfoInitializer ComponentPortDescriptionTypeInfoInitializer_; + + struct ComponentPropertyDescriptionTypeInfoInitializer + { + ComponentPropertyDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPropertyDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPropertyDescriptionTypeInfoInitializer ComponentPropertyDescriptionTypeInfoInitializer_; + + struct ComponentExternalPortEndpointTypeInfoInitializer + { + ComponentExternalPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentExternalPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentExternalPortEndpointTypeInfoInitializer ComponentExternalPortEndpointTypeInfoInitializer_; + + struct PlanSubcomponentPortEndpointTypeInfoInitializer + { + PlanSubcomponentPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PlanSubcomponentPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PlanSubcomponentPortEndpointTypeInfoInitializer PlanSubcomponentPortEndpointTypeInfoInitializer_; + + struct ExternalReferenceEndpointTypeInfoInitializer + { + ExternalReferenceEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ExternalReferenceEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ExternalReferenceEndpointTypeInfoInitializer ExternalReferenceEndpointTypeInfoInitializer_; + + struct ConnectionResourceDeploymentDescriptionTypeInfoInitializer + { + ConnectionResourceDeploymentDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ConnectionResourceDeploymentDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ConnectionResourceDeploymentDescriptionTypeInfoInitializer ConnectionResourceDeploymentDescriptionTypeInfoInitializer_; + + struct PlanConnectionDescriptionTypeInfoInitializer + { + PlanConnectionDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PlanConnectionDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + PlanConnectionDescriptionTypeInfoInitializer PlanConnectionDescriptionTypeInfoInitializer_; + + struct ImplementationDependencyTypeInfoInitializer + { + ImplementationDependencyTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ImplementationDependency)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ImplementationDependencyTypeInfoInitializer ImplementationDependencyTypeInfoInitializer_; + + struct CapabilityTypeInfoInitializer + { + CapabilityTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Capability)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + CapabilityTypeInfoInitializer CapabilityTypeInfoInitializer_; + + struct ImplementationRequirementTypeInfoInitializer + { + ImplementationRequirementTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ImplementationRequirement)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ImplementationRequirementTypeInfoInitializer ImplementationRequirementTypeInfoInitializer_; + + struct ComponentPackageReferenceTypeInfoInitializer + { + ComponentPackageReferenceTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ComponentPackageReference)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + ComponentPackageReferenceTypeInfoInitializer ComponentPackageReferenceTypeInfoInitializer_; + + struct SubcomponentPortEndpointTypeInfoInitializer + { + SubcomponentPortEndpointTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (SubcomponentPortEndpoint)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + SubcomponentPortEndpointTypeInfoInitializer SubcomponentPortEndpointTypeInfoInitializer_; + + struct AssemblyConnectionDescriptionTypeInfoInitializer + { + AssemblyConnectionDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (AssemblyConnectionDescription)); + ::XSCRT::ExtendedTypeInfo nf (id); + + nf.add_base (::XSCRT::ExtendedTypeInfo::Access::public_, false, typeid (::XSCRT::Type)); + ::XSCRT::extended_type_info_map ().insert (::std::make_pair (id, nf)); + } + }; + + AssemblyConnectionDescriptionTypeInfoInitializer AssemblyConnectionDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // DataType + // + // + + void DataType:: + traverse (Type& o) + { + pre (o); + kind (o); + if (o.enum_p ()) enum_ (o); + else enum_none (o); + if (o.struct_p ()) struct_ (o); + else struct_none (o); + if (o.value_p ()) value (o); + else value_none (o); + if (o.sequence_p ()) sequence (o); + else sequence_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void DataType:: + traverse (Type const& o) + { + pre (o); + kind (o); + if (o.enum_p ()) enum_ (o); + else enum_none (o); + if (o.struct_p ()) struct_ (o); + else struct_none (o); + if (o.value_p ()) value (o); + else value_none (o); + if (o.sequence_p ()) sequence (o); + else sequence_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void DataType:: + pre (Type&) + { + } + + void DataType:: + pre (Type const&) + { + } + + void DataType:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void DataType:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void DataType:: + enum_ (Type& o) + { + dispatch (o.enum_ ()); + } + + void DataType:: + enum_ (Type const& o) + { + dispatch (o.enum_ ()); + } + + void DataType:: + enum_none (Type&) + { + } + + void DataType:: + enum_none (Type const&) + { + } + + void DataType:: + struct_ (Type& o) + { + dispatch (o.struct_ ()); + } + + void DataType:: + struct_ (Type const& o) + { + dispatch (o.struct_ ()); + } + + void DataType:: + struct_none (Type&) + { + } + + void DataType:: + struct_none (Type const&) + { + } + + void DataType:: + value (Type& o) + { + dispatch (o.value ()); + } + + void DataType:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void DataType:: + value_none (Type&) + { + } + + void DataType:: + value_none (Type const&) + { + } + + void DataType:: + sequence (Type& o) + { + dispatch (o.sequence ()); + } + + void DataType:: + sequence (Type const& o) + { + dispatch (o.sequence ()); + } + + void DataType:: + sequence_none (Type&) + { + } + + void DataType:: + sequence_none (Type const&) + { + } + + void DataType:: + id (Type& o) + { + dispatch (o.id ()); + } + + void DataType:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void DataType:: + id_none (Type&) + { + } + + void DataType:: + id_none (Type const&) + { + } + + void DataType:: + post (Type&) + { + } + + void DataType:: + post (Type const&) + { + } + + // DataValue + // + // + + void DataValue:: + traverse (Type& o) + { + pre (o); + short_ (o); + long_ (o); + ushort (o); + ulong (o); + float_ (o); + double_ (o); + boolean (o); + octet (o); + enum_ (o); + string (o); + longlong (o); + ulonglong (o); + longdouble (o); + member (o); + post (o); + } + + void DataValue:: + traverse (Type const& o) + { + pre (o); + short_ (o); + long_ (o); + ushort (o); + ulong (o); + float_ (o); + double_ (o); + boolean (o); + octet (o); + enum_ (o); + string (o); + longlong (o); + ulonglong (o); + longdouble (o); + member (o); + post (o); + } + + void DataValue:: + pre (Type&) + { + } + + void DataValue:: + pre (Type const&) + { + } + + void DataValue:: + short_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::short_iterator b (o.begin_short()), e (o.end_short()); + + if (b != e) + { + short_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) short_next (o); + } + + short_post (o); + } + + else short_none (o); + } + + void DataValue:: + short_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::short_const_iterator b (o.begin_short()), e (o.end_short()); + + if (b != e) + { + short_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) short_next (o); + } + + short_post (o); + } + + else short_none (o); + } + + void DataValue:: + short_pre (Type&) + { + } + + void DataValue:: + short_pre (Type const&) + { + } + + void DataValue:: + short_next (Type&) + { + } + + void DataValue:: + short_next (Type const&) + { + } + + void DataValue:: + short_post (Type&) + { + } + + void DataValue:: + short_post (Type const&) + { + } + + void DataValue:: + short_none (Type&) + { + } + + void DataValue:: + short_none (Type const&) + { + } + + void DataValue:: + long_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::long_iterator b (o.begin_long()), e (o.end_long()); + + if (b != e) + { + long_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) long_next (o); + } + + long_post (o); + } + + else long_none (o); + } + + void DataValue:: + long_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::long_const_iterator b (o.begin_long()), e (o.end_long()); + + if (b != e) + { + long_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) long_next (o); + } + + long_post (o); + } + + else long_none (o); + } + + void DataValue:: + long_pre (Type&) + { + } + + void DataValue:: + long_pre (Type const&) + { + } + + void DataValue:: + long_next (Type&) + { + } + + void DataValue:: + long_next (Type const&) + { + } + + void DataValue:: + long_post (Type&) + { + } + + void DataValue:: + long_post (Type const&) + { + } + + void DataValue:: + long_none (Type&) + { + } + + void DataValue:: + long_none (Type const&) + { + } + + void DataValue:: + ushort (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ushort_iterator b (o.begin_ushort()), e (o.end_ushort()); + + if (b != e) + { + ushort_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ushort_next (o); + } + + ushort_post (o); + } + + else ushort_none (o); + } + + void DataValue:: + ushort (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ushort_const_iterator b (o.begin_ushort()), e (o.end_ushort()); + + if (b != e) + { + ushort_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ushort_next (o); + } + + ushort_post (o); + } + + else ushort_none (o); + } + + void DataValue:: + ushort_pre (Type&) + { + } + + void DataValue:: + ushort_pre (Type const&) + { + } + + void DataValue:: + ushort_next (Type&) + { + } + + void DataValue:: + ushort_next (Type const&) + { + } + + void DataValue:: + ushort_post (Type&) + { + } + + void DataValue:: + ushort_post (Type const&) + { + } + + void DataValue:: + ushort_none (Type&) + { + } + + void DataValue:: + ushort_none (Type const&) + { + } + + void DataValue:: + ulong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulong_iterator b (o.begin_ulong()), e (o.end_ulong()); + + if (b != e) + { + ulong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulong_next (o); + } + + ulong_post (o); + } + + else ulong_none (o); + } + + void DataValue:: + ulong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulong_const_iterator b (o.begin_ulong()), e (o.end_ulong()); + + if (b != e) + { + ulong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulong_next (o); + } + + ulong_post (o); + } + + else ulong_none (o); + } + + void DataValue:: + ulong_pre (Type&) + { + } + + void DataValue:: + ulong_pre (Type const&) + { + } + + void DataValue:: + ulong_next (Type&) + { + } + + void DataValue:: + ulong_next (Type const&) + { + } + + void DataValue:: + ulong_post (Type&) + { + } + + void DataValue:: + ulong_post (Type const&) + { + } + + void DataValue:: + ulong_none (Type&) + { + } + + void DataValue:: + ulong_none (Type const&) + { + } + + void DataValue:: + float_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::float_iterator b (o.begin_float()), e (o.end_float()); + + if (b != e) + { + float_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) float_next (o); + } + + float_post (o); + } + + else float_none (o); + } + + void DataValue:: + float_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::float_const_iterator b (o.begin_float()), e (o.end_float()); + + if (b != e) + { + float_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) float_next (o); + } + + float_post (o); + } + + else float_none (o); + } + + void DataValue:: + float_pre (Type&) + { + } + + void DataValue:: + float_pre (Type const&) + { + } + + void DataValue:: + float_next (Type&) + { + } + + void DataValue:: + float_next (Type const&) + { + } + + void DataValue:: + float_post (Type&) + { + } + + void DataValue:: + float_post (Type const&) + { + } + + void DataValue:: + float_none (Type&) + { + } + + void DataValue:: + float_none (Type const&) + { + } + + void DataValue:: + double_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::double_iterator b (o.begin_double()), e (o.end_double()); + + if (b != e) + { + double_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) double_next (o); + } + + double_post (o); + } + + else double_none (o); + } + + void DataValue:: + double_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::double_const_iterator b (o.begin_double()), e (o.end_double()); + + if (b != e) + { + double_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) double_next (o); + } + + double_post (o); + } + + else double_none (o); + } + + void DataValue:: + double_pre (Type&) + { + } + + void DataValue:: + double_pre (Type const&) + { + } + + void DataValue:: + double_next (Type&) + { + } + + void DataValue:: + double_next (Type const&) + { + } + + void DataValue:: + double_post (Type&) + { + } + + void DataValue:: + double_post (Type const&) + { + } + + void DataValue:: + double_none (Type&) + { + } + + void DataValue:: + double_none (Type const&) + { + } + + void DataValue:: + boolean (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::boolean_iterator b (o.begin_boolean()), e (o.end_boolean()); + + if (b != e) + { + boolean_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) boolean_next (o); + } + + boolean_post (o); + } + + else boolean_none (o); + } + + void DataValue:: + boolean (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::boolean_const_iterator b (o.begin_boolean()), e (o.end_boolean()); + + if (b != e) + { + boolean_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) boolean_next (o); + } + + boolean_post (o); + } + + else boolean_none (o); + } + + void DataValue:: + boolean_pre (Type&) + { + } + + void DataValue:: + boolean_pre (Type const&) + { + } + + void DataValue:: + boolean_next (Type&) + { + } + + void DataValue:: + boolean_next (Type const&) + { + } + + void DataValue:: + boolean_post (Type&) + { + } + + void DataValue:: + boolean_post (Type const&) + { + } + + void DataValue:: + boolean_none (Type&) + { + } + + void DataValue:: + boolean_none (Type const&) + { + } + + void DataValue:: + octet (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::octet_iterator b (o.begin_octet()), e (o.end_octet()); + + if (b != e) + { + octet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) octet_next (o); + } + + octet_post (o); + } + + else octet_none (o); + } + + void DataValue:: + octet (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::octet_const_iterator b (o.begin_octet()), e (o.end_octet()); + + if (b != e) + { + octet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) octet_next (o); + } + + octet_post (o); + } + + else octet_none (o); + } + + void DataValue:: + octet_pre (Type&) + { + } + + void DataValue:: + octet_pre (Type const&) + { + } + + void DataValue:: + octet_next (Type&) + { + } + + void DataValue:: + octet_next (Type const&) + { + } + + void DataValue:: + octet_post (Type&) + { + } + + void DataValue:: + octet_post (Type const&) + { + } + + void DataValue:: + octet_none (Type&) + { + } + + void DataValue:: + octet_none (Type const&) + { + } + + void DataValue:: + enum_ (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::enum_iterator b (o.begin_enum()), e (o.end_enum()); + + if (b != e) + { + enum_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) enum_next (o); + } + + enum_post (o); + } + + else enum_none (o); + } + + void DataValue:: + enum_ (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::enum_const_iterator b (o.begin_enum()), e (o.end_enum()); + + if (b != e) + { + enum_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) enum_next (o); + } + + enum_post (o); + } + + else enum_none (o); + } + + void DataValue:: + enum_pre (Type&) + { + } + + void DataValue:: + enum_pre (Type const&) + { + } + + void DataValue:: + enum_next (Type&) + { + } + + void DataValue:: + enum_next (Type const&) + { + } + + void DataValue:: + enum_post (Type&) + { + } + + void DataValue:: + enum_post (Type const&) + { + } + + void DataValue:: + enum_none (Type&) + { + } + + void DataValue:: + enum_none (Type const&) + { + } + + void DataValue:: + string (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::string_iterator b (o.begin_string()), e (o.end_string()); + + if (b != e) + { + string_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) string_next (o); + } + + string_post (o); + } + + else string_none (o); + } + + void DataValue:: + string (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::string_const_iterator b (o.begin_string()), e (o.end_string()); + + if (b != e) + { + string_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) string_next (o); + } + + string_post (o); + } + + else string_none (o); + } + + void DataValue:: + string_pre (Type&) + { + } + + void DataValue:: + string_pre (Type const&) + { + } + + void DataValue:: + string_next (Type&) + { + } + + void DataValue:: + string_next (Type const&) + { + } + + void DataValue:: + string_post (Type&) + { + } + + void DataValue:: + string_post (Type const&) + { + } + + void DataValue:: + string_none (Type&) + { + } + + void DataValue:: + string_none (Type const&) + { + } + + void DataValue:: + longlong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longlong_iterator b (o.begin_longlong()), e (o.end_longlong()); + + if (b != e) + { + longlong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longlong_next (o); + } + + longlong_post (o); + } + + else longlong_none (o); + } + + void DataValue:: + longlong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longlong_const_iterator b (o.begin_longlong()), e (o.end_longlong()); + + if (b != e) + { + longlong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longlong_next (o); + } + + longlong_post (o); + } + + else longlong_none (o); + } + + void DataValue:: + longlong_pre (Type&) + { + } + + void DataValue:: + longlong_pre (Type const&) + { + } + + void DataValue:: + longlong_next (Type&) + { + } + + void DataValue:: + longlong_next (Type const&) + { + } + + void DataValue:: + longlong_post (Type&) + { + } + + void DataValue:: + longlong_post (Type const&) + { + } + + void DataValue:: + longlong_none (Type&) + { + } + + void DataValue:: + longlong_none (Type const&) + { + } + + void DataValue:: + ulonglong (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulonglong_iterator b (o.begin_ulonglong()), e (o.end_ulonglong()); + + if (b != e) + { + ulonglong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulonglong_next (o); + } + + ulonglong_post (o); + } + + else ulonglong_none (o); + } + + void DataValue:: + ulonglong (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::ulonglong_const_iterator b (o.begin_ulonglong()), e (o.end_ulonglong()); + + if (b != e) + { + ulonglong_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) ulonglong_next (o); + } + + ulonglong_post (o); + } + + else ulonglong_none (o); + } + + void DataValue:: + ulonglong_pre (Type&) + { + } + + void DataValue:: + ulonglong_pre (Type const&) + { + } + + void DataValue:: + ulonglong_next (Type&) + { + } + + void DataValue:: + ulonglong_next (Type const&) + { + } + + void DataValue:: + ulonglong_post (Type&) + { + } + + void DataValue:: + ulonglong_post (Type const&) + { + } + + void DataValue:: + ulonglong_none (Type&) + { + } + + void DataValue:: + ulonglong_none (Type const&) + { + } + + void DataValue:: + longdouble (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longdouble_iterator b (o.begin_longdouble()), e (o.end_longdouble()); + + if (b != e) + { + longdouble_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longdouble_next (o); + } + + longdouble_post (o); + } + + else longdouble_none (o); + } + + void DataValue:: + longdouble (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::longdouble_const_iterator b (o.begin_longdouble()), e (o.end_longdouble()); + + if (b != e) + { + longdouble_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) longdouble_next (o); + } + + longdouble_post (o); + } + + else longdouble_none (o); + } + + void DataValue:: + longdouble_pre (Type&) + { + } + + void DataValue:: + longdouble_pre (Type const&) + { + } + + void DataValue:: + longdouble_next (Type&) + { + } + + void DataValue:: + longdouble_next (Type const&) + { + } + + void DataValue:: + longdouble_post (Type&) + { + } + + void DataValue:: + longdouble_post (Type const&) + { + } + + void DataValue:: + longdouble_none (Type&) + { + } + + void DataValue:: + longdouble_none (Type const&) + { + } + + void DataValue:: + member (Type& o) + { + // VC6 anathema strikes again + // + DataValue::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void DataValue:: + member (Type const& o) + { + // VC6 anathema strikes again + // + DataValue::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void DataValue:: + member_pre (Type&) + { + } + + void DataValue:: + member_pre (Type const&) + { + } + + void DataValue:: + member_next (Type&) + { + } + + void DataValue:: + member_next (Type const&) + { + } + + void DataValue:: + member_post (Type&) + { + } + + void DataValue:: + member_post (Type const&) + { + } + + void DataValue:: + member_none (Type&) + { + } + + void DataValue:: + member_none (Type const&) + { + } + + void DataValue:: + post (Type&) + { + } + + void DataValue:: + post (Type const&) + { + } + + // EnumType + // + // + + void EnumType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void EnumType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void EnumType:: + pre (Type&) + { + } + + void EnumType:: + pre (Type const&) + { + } + + void EnumType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void EnumType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void EnumType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void EnumType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void EnumType:: + member (Type& o) + { + // VC6 anathema strikes again + // + EnumType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + } + + void EnumType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + EnumType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + } + + void EnumType:: + member_pre (Type&) + { + } + + void EnumType:: + member_pre (Type const&) + { + } + + void EnumType:: + member_next (Type&) + { + } + + void EnumType:: + member_next (Type const&) + { + } + + void EnumType:: + member_post (Type&) + { + } + + void EnumType:: + member_post (Type const&) + { + } + + void EnumType:: + post (Type&) + { + } + + void EnumType:: + post (Type const&) + { + } + + // StructType + // + // + + void StructType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void StructType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + member (o); + post (o); + } + + void StructType:: + pre (Type&) + { + } + + void StructType:: + pre (Type const&) + { + } + + void StructType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void StructType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void StructType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void StructType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void StructType:: + member (Type& o) + { + // VC6 anathema strikes again + // + StructType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void StructType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + StructType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void StructType:: + member_pre (Type&) + { + } + + void StructType:: + member_pre (Type const&) + { + } + + void StructType:: + member_next (Type&) + { + } + + void StructType:: + member_next (Type const&) + { + } + + void StructType:: + member_post (Type&) + { + } + + void StructType:: + member_post (Type const&) + { + } + + void StructType:: + member_none (Type&) + { + } + + void StructType:: + member_none (Type const&) + { + } + + void StructType:: + post (Type&) + { + } + + void StructType:: + post (Type const&) + { + } + + // StructMemberType + // + // + + void StructMemberType:: + traverse (Type& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void StructMemberType:: + traverse (Type const& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void StructMemberType:: + pre (Type&) + { + } + + void StructMemberType:: + pre (Type const&) + { + } + + void StructMemberType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void StructMemberType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void StructMemberType:: + type (Type& o) + { + dispatch (o.type ()); + } + + void StructMemberType:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void StructMemberType:: + post (Type&) + { + } + + void StructMemberType:: + post (Type const&) + { + } + + // ValueType + // + // + + void ValueType:: + traverse (Type& o) + { + pre (o); + name (o); + typeId (o); + modifier (o); + baseType (o); + member (o); + post (o); + } + + void ValueType:: + traverse (Type const& o) + { + pre (o); + name (o); + typeId (o); + modifier (o); + baseType (o); + member (o); + post (o); + } + + void ValueType:: + pre (Type&) + { + } + + void ValueType:: + pre (Type const&) + { + } + + void ValueType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ValueType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ValueType:: + typeId (Type& o) + { + dispatch (o.typeId ()); + } + + void ValueType:: + typeId (Type const& o) + { + dispatch (o.typeId ()); + } + + void ValueType:: + modifier (Type& o) + { + dispatch (o.modifier ()); + } + + void ValueType:: + modifier (Type const& o) + { + dispatch (o.modifier ()); + } + + void ValueType:: + baseType (Type& o) + { + dispatch (o.baseType ()); + } + + void ValueType:: + baseType (Type const& o) + { + dispatch (o.baseType ()); + } + + void ValueType:: + member (Type& o) + { + // VC6 anathema strikes again + // + ValueType::Type::member_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void ValueType:: + member (Type const& o) + { + // VC6 anathema strikes again + // + ValueType::Type::member_const_iterator b (o.begin_member()), e (o.end_member()); + + if (b != e) + { + member_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) member_next (o); + } + + member_post (o); + } + + else member_none (o); + } + + void ValueType:: + member_pre (Type&) + { + } + + void ValueType:: + member_pre (Type const&) + { + } + + void ValueType:: + member_next (Type&) + { + } + + void ValueType:: + member_next (Type const&) + { + } + + void ValueType:: + member_post (Type&) + { + } + + void ValueType:: + member_post (Type const&) + { + } + + void ValueType:: + member_none (Type&) + { + } + + void ValueType:: + member_none (Type const&) + { + } + + void ValueType:: + post (Type&) + { + } + + void ValueType:: + post (Type const&) + { + } + + // ValueMemberType + // + // + + void ValueMemberType:: + traverse (Type& o) + { + pre (o); + name (o); + visibility (o); + type (o); + post (o); + } + + void ValueMemberType:: + traverse (Type const& o) + { + pre (o); + name (o); + visibility (o); + type (o); + post (o); + } + + void ValueMemberType:: + pre (Type&) + { + } + + void ValueMemberType:: + pre (Type const&) + { + } + + void ValueMemberType:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ValueMemberType:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ValueMemberType:: + visibility (Type& o) + { + dispatch (o.visibility ()); + } + + void ValueMemberType:: + visibility (Type const& o) + { + dispatch (o.visibility ()); + } + + void ValueMemberType:: + type (Type& o) + { + dispatch (o.type ()); + } + + void ValueMemberType:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void ValueMemberType:: + post (Type&) + { + } + + void ValueMemberType:: + post (Type const&) + { + } + + // NamedValue + // + // + + void NamedValue:: + traverse (Type& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void NamedValue:: + traverse (Type const& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void NamedValue:: + pre (Type&) + { + } + + void NamedValue:: + pre (Type const&) + { + } + + void NamedValue:: + name (Type& o) + { + dispatch (o.name ()); + } + + void NamedValue:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void NamedValue:: + value (Type& o) + { + dispatch (o.value ()); + } + + void NamedValue:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void NamedValue:: + post (Type&) + { + } + + void NamedValue:: + post (Type const&) + { + } + + // SequenceType + // + // + + void SequenceType:: + traverse (Type& o) + { + pre (o); + if (o.bound_p ()) bound (o); + else bound_none (o); + elementType (o); + post (o); + } + + void SequenceType:: + traverse (Type const& o) + { + pre (o); + if (o.bound_p ()) bound (o); + else bound_none (o); + elementType (o); + post (o); + } + + void SequenceType:: + pre (Type&) + { + } + + void SequenceType:: + pre (Type const&) + { + } + + void SequenceType:: + bound (Type& o) + { + dispatch (o.bound ()); + } + + void SequenceType:: + bound (Type const& o) + { + dispatch (o.bound ()); + } + + void SequenceType:: + bound_none (Type&) + { + } + + void SequenceType:: + bound_none (Type const&) + { + } + + void SequenceType:: + elementType (Type& o) + { + dispatch (o.elementType ()); + } + + void SequenceType:: + elementType (Type const& o) + { + dispatch (o.elementType ()); + } + + void SequenceType:: + post (Type&) + { + } + + void SequenceType:: + post (Type const&) + { + } + + // Any + // + // + + void Any:: + traverse (Type& o) + { + pre (o); + type (o); + value (o); + post (o); + } + + void Any:: + traverse (Type const& o) + { + pre (o); + type (o); + value (o); + post (o); + } + + void Any:: + pre (Type&) + { + } + + void Any:: + pre (Type const&) + { + } + + void Any:: + type (Type& o) + { + dispatch (o.type ()); + } + + void Any:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void Any:: + value (Type& o) + { + dispatch (o.value ()); + } + + void Any:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void Any:: + post (Type&) + { + } + + void Any:: + post (Type const&) + { + } + + // Property + // + // + + void Property:: + traverse (Type& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void Property:: + traverse (Type const& o) + { + pre (o); + name (o); + value (o); + post (o); + } + + void Property:: + pre (Type&) + { + } + + void Property:: + pre (Type const&) + { + } + + void Property:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Property:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Property:: + value (Type& o) + { + dispatch (o.value ()); + } + + void Property:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void Property:: + post (Type&) + { + } + + void Property:: + post (Type const&) + { + } + + // SatisfierProperty + // + // + + void SatisfierProperty:: + traverse (Type& o) + { + pre (o); + name (o); + kind (o); + dynamic (o); + value (o); + post (o); + } + + void SatisfierProperty:: + traverse (Type const& o) + { + pre (o); + name (o); + kind (o); + dynamic (o); + value (o); + post (o); + } + + void SatisfierProperty:: + pre (Type&) + { + } + + void SatisfierProperty:: + pre (Type const&) + { + } + + void SatisfierProperty:: + name (Type& o) + { + dispatch (o.name ()); + } + + void SatisfierProperty:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void SatisfierProperty:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void SatisfierProperty:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void SatisfierProperty:: + dynamic (Type& o) + { + dispatch (o.dynamic ()); + } + + void SatisfierProperty:: + dynamic (Type const& o) + { + dispatch (o.dynamic ()); + } + + void SatisfierProperty:: + value (Type& o) + { + dispatch (o.value ()); + } + + void SatisfierProperty:: + value (Type const& o) + { + dispatch (o.value ()); + } + + void SatisfierProperty:: + post (Type&) + { + } + + void SatisfierProperty:: + post (Type const&) + { + } + + // Resource + // + // + + void Resource:: + traverse (Type& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Resource:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Resource:: + pre (Type&) + { + } + + void Resource:: + pre (Type const&) + { + } + + void Resource:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Resource:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Resource:: + resourceType (Type& o) + { + // VC6 anathema strikes again + // + Resource::Type::resourceType_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Resource:: + resourceType (Type const& o) + { + // VC6 anathema strikes again + // + Resource::Type::resourceType_const_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Resource:: + resourceType_pre (Type&) + { + } + + void Resource:: + resourceType_pre (Type const&) + { + } + + void Resource:: + resourceType_next (Type&) + { + } + + void Resource:: + resourceType_next (Type const&) + { + } + + void Resource:: + resourceType_post (Type&) + { + } + + void Resource:: + resourceType_post (Type const&) + { + } + + void Resource:: + property (Type& o) + { + // VC6 anathema strikes again + // + Resource::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Resource:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Resource::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Resource:: + property_pre (Type&) + { + } + + void Resource:: + property_pre (Type const&) + { + } + + void Resource:: + property_next (Type&) + { + } + + void Resource:: + property_next (Type const&) + { + } + + void Resource:: + property_post (Type&) + { + } + + void Resource:: + property_post (Type const&) + { + } + + void Resource:: + property_none (Type&) + { + } + + void Resource:: + property_none (Type const&) + { + } + + void Resource:: + post (Type&) + { + } + + void Resource:: + post (Type const&) + { + } + + // Requirement + // + // + + void Requirement:: + traverse (Type& o) + { + pre (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void Requirement:: + traverse (Type const& o) + { + pre (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void Requirement:: + pre (Type&) + { + } + + void Requirement:: + pre (Type const&) + { + } + + void Requirement:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void Requirement:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Requirement:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Requirement:: + property (Type& o) + { + // VC6 anathema strikes again + // + Requirement::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Requirement:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Requirement::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Requirement:: + property_pre (Type&) + { + } + + void Requirement:: + property_pre (Type const&) + { + } + + void Requirement:: + property_next (Type&) + { + } + + void Requirement:: + property_next (Type const&) + { + } + + void Requirement:: + property_post (Type&) + { + } + + void Requirement:: + property_post (Type const&) + { + } + + void Requirement:: + property_none (Type&) + { + } + + void Requirement:: + property_none (Type const&) + { + } + + void Requirement:: + post (Type&) + { + } + + void Requirement:: + post (Type const&) + { + } + + // ResourceDeploymentDescription + // + // + + void ResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ResourceDeploymentDescription:: + pre (Type&) + { + } + + void ResourceDeploymentDescription:: + pre (Type const&) + { + } + + void ResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void ResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void ResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void ResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void ResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + ResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void ResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_next (Type&) + { + } + + void ResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_post (Type&) + { + } + + void ResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void ResourceDeploymentDescription:: + property_none (Type&) + { + } + + void ResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void ResourceDeploymentDescription:: + post (Type&) + { + } + + void ResourceDeploymentDescription:: + post (Type const&) + { + } + + // ArtifactDeploymentDescription + // + // + + void ArtifactDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + source (o); + node (o); + location (o); + execParameter (o); + deployRequirement (o); + deployedResource (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ArtifactDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + source (o); + node (o); + location (o); + execParameter (o); + deployRequirement (o); + deployedResource (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ArtifactDeploymentDescription:: + pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ArtifactDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ArtifactDeploymentDescription:: + source (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::source_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void ArtifactDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::source_const_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void ArtifactDeploymentDescription:: + source_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + source_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + source_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + source_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + node (Type& o) + { + dispatch (o.node ()); + } + + void ArtifactDeploymentDescription:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void ArtifactDeploymentDescription:: + location (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::location_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void ArtifactDeploymentDescription:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::location_const_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void ArtifactDeploymentDescription:: + location_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + location_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + location_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + location_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::execParameter_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void ArtifactDeploymentDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::execParameter_const_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + execParameter_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployRequirement_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void ArtifactDeploymentDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + ArtifactDeploymentDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type const&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + deployedResource_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ArtifactDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ArtifactDeploymentDescription:: + id_none (Type&) + { + } + + void ArtifactDeploymentDescription:: + id_none (Type const&) + { + } + + void ArtifactDeploymentDescription:: + post (Type&) + { + } + + void ArtifactDeploymentDescription:: + post (Type const&) + { + } + + // MonolithicDeploymentDescription + // + // + + void MonolithicDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + source (o); + artifact (o); + execParameter (o); + deployRequirement (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void MonolithicDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + source (o); + artifact (o); + execParameter (o); + deployRequirement (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void MonolithicDeploymentDescription:: + pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void MonolithicDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void MonolithicDeploymentDescription:: + source (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::source_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void MonolithicDeploymentDescription:: + source (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::source_const_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void MonolithicDeploymentDescription:: + source_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + source_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + source_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + source_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::artifact_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + } + + void MonolithicDeploymentDescription:: + artifact (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::artifact_const_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + artifact_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + artifact_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::execParameter_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void MonolithicDeploymentDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::execParameter_const_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + execParameter_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicDeploymentDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type const&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + deployRequirement_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void MonolithicDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void MonolithicDeploymentDescription:: + id_none (Type&) + { + } + + void MonolithicDeploymentDescription:: + id_none (Type const&) + { + } + + void MonolithicDeploymentDescription:: + post (Type&) + { + } + + void MonolithicDeploymentDescription:: + post (Type const&) + { + } + + // InstanceResourceDeploymentDescription + // + // + + void InstanceResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + resourceUsage (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void InstanceResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + resourceUsage (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void InstanceResourceDeploymentDescription:: + pre (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + pre (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type& o) + { + dispatch (o.resourceUsage ()); + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type const& o) + { + dispatch (o.resourceUsage ()); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void InstanceResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + InstanceResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void InstanceResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + InstanceResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_next (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_post (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + property_none (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void InstanceResourceDeploymentDescription:: + post (Type&) + { + } + + void InstanceResourceDeploymentDescription:: + post (Type const&) + { + } + + // InstanceDeploymentDescription + // + // + + void InstanceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + name (o); + node (o); + source (o); + implementation (o); + configProperty (o); + deployedResource (o); + if (o.deployedSharedResource_p ()) deployedSharedResource (o); + else deployedSharedResource_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void InstanceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + node (o); + source (o); + implementation (o); + configProperty (o); + deployedResource (o); + if (o.deployedSharedResource_p ()) deployedSharedResource (o); + else deployedSharedResource_none (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void InstanceDeploymentDescription:: + pre (Type&) + { + } + + void InstanceDeploymentDescription:: + pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void InstanceDeploymentDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void InstanceDeploymentDescription:: + node (Type& o) + { + dispatch (o.node ()); + } + + void InstanceDeploymentDescription:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void InstanceDeploymentDescription:: + source (Type& o) + { + dispatch (o.source ()); + } + + void InstanceDeploymentDescription:: + source (Type const& o) + { + dispatch (o.source ()); + } + + void InstanceDeploymentDescription:: + implementation (Type& o) + { + dispatch (o.implementation ()); + } + + void InstanceDeploymentDescription:: + implementation (Type const& o) + { + dispatch (o.implementation ()); + } + + void InstanceDeploymentDescription:: + configProperty (Type& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void InstanceDeploymentDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_next (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_next (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_post (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_post (Type const&) + { + } + + void InstanceDeploymentDescription:: + configProperty_none (Type&) + { + } + + void InstanceDeploymentDescription:: + configProperty_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void InstanceDeploymentDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + InstanceDeploymentDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_none (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedResource_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type& o) + { + dispatch (o.deployedSharedResource ()); + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type const& o) + { + dispatch (o.deployedSharedResource ()); + } + + void InstanceDeploymentDescription:: + deployedSharedResource_none (Type&) + { + } + + void InstanceDeploymentDescription:: + deployedSharedResource_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void InstanceDeploymentDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void InstanceDeploymentDescription:: + id_none (Type&) + { + } + + void InstanceDeploymentDescription:: + id_none (Type const&) + { + } + + void InstanceDeploymentDescription:: + post (Type&) + { + } + + void InstanceDeploymentDescription:: + post (Type const&) + { + } + + // ComponentPortDescription + // + // + + void ComponentPortDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + provider (o); + exclusiveProvider (o); + exclusiveUser (o); + optional (o); + kind (o); + post (o); + } + + void ComponentPortDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.specificType_p ()) specificType (o); + else specificType_none (o); + supportedType (o); + provider (o); + exclusiveProvider (o); + exclusiveUser (o); + optional (o); + kind (o); + post (o); + } + + void ComponentPortDescription:: + pre (Type&) + { + } + + void ComponentPortDescription:: + pre (Type const&) + { + } + + void ComponentPortDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ComponentPortDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ComponentPortDescription:: + specificType (Type& o) + { + dispatch (o.specificType ()); + } + + void ComponentPortDescription:: + specificType (Type const& o) + { + dispatch (o.specificType ()); + } + + void ComponentPortDescription:: + specificType_none (Type&) + { + } + + void ComponentPortDescription:: + specificType_none (Type const&) + { + } + + void ComponentPortDescription:: + supportedType (Type& o) + { + // VC6 anathema strikes again + // + ComponentPortDescription::Type::supportedType_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void ComponentPortDescription:: + supportedType (Type const& o) + { + // VC6 anathema strikes again + // + ComponentPortDescription::Type::supportedType_const_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void ComponentPortDescription:: + supportedType_pre (Type&) + { + } + + void ComponentPortDescription:: + supportedType_pre (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_next (Type&) + { + } + + void ComponentPortDescription:: + supportedType_next (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_post (Type&) + { + } + + void ComponentPortDescription:: + supportedType_post (Type const&) + { + } + + void ComponentPortDescription:: + supportedType_none (Type&) + { + } + + void ComponentPortDescription:: + supportedType_none (Type const&) + { + } + + void ComponentPortDescription:: + provider (Type& o) + { + dispatch (o.provider ()); + } + + void ComponentPortDescription:: + provider (Type const& o) + { + dispatch (o.provider ()); + } + + void ComponentPortDescription:: + exclusiveProvider (Type& o) + { + dispatch (o.exclusiveProvider ()); + } + + void ComponentPortDescription:: + exclusiveProvider (Type const& o) + { + dispatch (o.exclusiveProvider ()); + } + + void ComponentPortDescription:: + exclusiveUser (Type& o) + { + dispatch (o.exclusiveUser ()); + } + + void ComponentPortDescription:: + exclusiveUser (Type const& o) + { + dispatch (o.exclusiveUser ()); + } + + void ComponentPortDescription:: + optional (Type& o) + { + dispatch (o.optional ()); + } + + void ComponentPortDescription:: + optional (Type const& o) + { + dispatch (o.optional ()); + } + + void ComponentPortDescription:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void ComponentPortDescription:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void ComponentPortDescription:: + post (Type&) + { + } + + void ComponentPortDescription:: + post (Type const&) + { + } + + // ComponentPropertyDescription + // + // + + void ComponentPropertyDescription:: + traverse (Type& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void ComponentPropertyDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + type (o); + post (o); + } + + void ComponentPropertyDescription:: + pre (Type&) + { + } + + void ComponentPropertyDescription:: + pre (Type const&) + { + } + + void ComponentPropertyDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ComponentPropertyDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ComponentPropertyDescription:: + type (Type& o) + { + dispatch (o.type ()); + } + + void ComponentPropertyDescription:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void ComponentPropertyDescription:: + post (Type&) + { + } + + void ComponentPropertyDescription:: + post (Type const&) + { + } + + // ComponentExternalPortEndpoint + // + // + + void ComponentExternalPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + post (o); + } + + void ComponentExternalPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + post (o); + } + + void ComponentExternalPortEndpoint:: + pre (Type&) + { + } + + void ComponentExternalPortEndpoint:: + pre (Type const&) + { + } + + void ComponentExternalPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void ComponentExternalPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void ComponentExternalPortEndpoint:: + post (Type&) + { + } + + void ComponentExternalPortEndpoint:: + post (Type const&) + { + } + + // PlanSubcomponentPortEndpoint + // + // + + void PlanSubcomponentPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + if (o.provider_p ()) provider (o); + else provider_none (o); + kind (o); + instance (o); + post (o); + } + + void PlanSubcomponentPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + if (o.provider_p ()) provider (o); + else provider_none (o); + kind (o); + instance (o); + post (o); + } + + void PlanSubcomponentPortEndpoint:: + pre (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + pre (Type const&) + { + } + + void PlanSubcomponentPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void PlanSubcomponentPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type& o) + { + dispatch (o.provider ()); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type const& o) + { + dispatch (o.provider ()); + } + + void PlanSubcomponentPortEndpoint:: + provider_none (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + provider_none (Type const&) + { + } + + void PlanSubcomponentPortEndpoint:: + kind (Type& o) + { + dispatch (o.kind ()); + } + + void PlanSubcomponentPortEndpoint:: + kind (Type const& o) + { + dispatch (o.kind ()); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void PlanSubcomponentPortEndpoint:: + post (Type&) + { + } + + void PlanSubcomponentPortEndpoint:: + post (Type const&) + { + } + + // ExternalReferenceEndpoint + // + // + + void ExternalReferenceEndpoint:: + traverse (Type& o) + { + pre (o); + location (o); + post (o); + } + + void ExternalReferenceEndpoint:: + traverse (Type const& o) + { + pre (o); + location (o); + post (o); + } + + void ExternalReferenceEndpoint:: + pre (Type&) + { + } + + void ExternalReferenceEndpoint:: + pre (Type const&) + { + } + + void ExternalReferenceEndpoint:: + location (Type& o) + { + dispatch (o.location ()); + } + + void ExternalReferenceEndpoint:: + location (Type const& o) + { + dispatch (o.location ()); + } + + void ExternalReferenceEndpoint:: + post (Type&) + { + } + + void ExternalReferenceEndpoint:: + post (Type const&) + { + } + + // ConnectionResourceDeploymentDescription + // + // + + void ConnectionResourceDeploymentDescription:: + traverse (Type& o) + { + pre (o); + targetName (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ConnectionResourceDeploymentDescription:: + traverse (Type const& o) + { + pre (o); + targetName (o); + requirementName (o); + resourceName (o); + property (o); + post (o); + } + + void ConnectionResourceDeploymentDescription:: + pre (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + pre (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type& o) + { + dispatch (o.targetName ()); + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type const& o) + { + dispatch (o.targetName ()); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type& o) + { + dispatch (o.requirementName ()); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type const& o) + { + dispatch (o.requirementName ()); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type& o) + { + dispatch (o.resourceName ()); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type const& o) + { + dispatch (o.resourceName ()); + } + + void ConnectionResourceDeploymentDescription:: + property (Type& o) + { + // VC6 anathema strikes again + // + ConnectionResourceDeploymentDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ConnectionResourceDeploymentDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ConnectionResourceDeploymentDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_none (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + property_none (Type const&) + { + } + + void ConnectionResourceDeploymentDescription:: + post (Type&) + { + } + + void ConnectionResourceDeploymentDescription:: + post (Type const&) + { + } + + // PlanConnectionDescription + // + // + + void PlanConnectionDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.source_p ()) source (o); + else source_none (o); + deployRequirement (o); + externalEndpoint (o); + internalEndpoint (o); + externalReference (o); + deployedResource (o); + post (o); + } + + void PlanConnectionDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.source_p ()) source (o); + else source_none (o); + deployRequirement (o); + externalEndpoint (o); + internalEndpoint (o); + externalReference (o); + deployedResource (o); + post (o); + } + + void PlanConnectionDescription:: + pre (Type&) + { + } + + void PlanConnectionDescription:: + pre (Type const&) + { + } + + void PlanConnectionDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void PlanConnectionDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void PlanConnectionDescription:: + source (Type& o) + { + dispatch (o.source ()); + } + + void PlanConnectionDescription:: + source (Type const& o) + { + dispatch (o.source ()); + } + + void PlanConnectionDescription:: + source_none (Type&) + { + } + + void PlanConnectionDescription:: + source_none (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void PlanConnectionDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_next (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_next (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_post (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_post (Type const&) + { + } + + void PlanConnectionDescription:: + deployRequirement_none (Type&) + { + } + + void PlanConnectionDescription:: + deployRequirement_none (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalEndpoint_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void PlanConnectionDescription:: + externalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalEndpoint_const_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type const&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_none (Type&) + { + } + + void PlanConnectionDescription:: + externalEndpoint_none (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::internalEndpoint_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void PlanConnectionDescription:: + internalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::internalEndpoint_const_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type const&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_none (Type&) + { + } + + void PlanConnectionDescription:: + internalEndpoint_none (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalReference_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void PlanConnectionDescription:: + externalReference (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::externalReference_const_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void PlanConnectionDescription:: + externalReference_pre (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_pre (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_next (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_next (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_post (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_post (Type const&) + { + } + + void PlanConnectionDescription:: + externalReference_none (Type&) + { + } + + void PlanConnectionDescription:: + externalReference_none (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource (Type& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployedResource_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void PlanConnectionDescription:: + deployedResource (Type const& o) + { + // VC6 anathema strikes again + // + PlanConnectionDescription::Type::deployedResource_const_iterator b (o.begin_deployedResource()), e (o.end_deployedResource()); + + if (b != e) + { + deployedResource_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployedResource_next (o); + } + + deployedResource_post (o); + } + + else deployedResource_none (o); + } + + void PlanConnectionDescription:: + deployedResource_pre (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_pre (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_next (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_next (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_post (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_post (Type const&) + { + } + + void PlanConnectionDescription:: + deployedResource_none (Type&) + { + } + + void PlanConnectionDescription:: + deployedResource_none (Type const&) + { + } + + void PlanConnectionDescription:: + post (Type&) + { + } + + void PlanConnectionDescription:: + post (Type const&) + { + } + + // ImplementationDependency + // + // + + void ImplementationDependency:: + traverse (Type& o) + { + pre (o); + requiredType (o); + post (o); + } + + void ImplementationDependency:: + traverse (Type const& o) + { + pre (o); + requiredType (o); + post (o); + } + + void ImplementationDependency:: + pre (Type&) + { + } + + void ImplementationDependency:: + pre (Type const&) + { + } + + void ImplementationDependency:: + requiredType (Type& o) + { + dispatch (o.requiredType ()); + } + + void ImplementationDependency:: + requiredType (Type const& o) + { + dispatch (o.requiredType ()); + } + + void ImplementationDependency:: + post (Type&) + { + } + + void ImplementationDependency:: + post (Type const&) + { + } + + // Capability + // + // + + void Capability:: + traverse (Type& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Capability:: + traverse (Type const& o) + { + pre (o); + name (o); + resourceType (o); + property (o); + post (o); + } + + void Capability:: + pre (Type&) + { + } + + void Capability:: + pre (Type const&) + { + } + + void Capability:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Capability:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Capability:: + resourceType (Type& o) + { + // VC6 anathema strikes again + // + Capability::Type::resourceType_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Capability:: + resourceType (Type const& o) + { + // VC6 anathema strikes again + // + Capability::Type::resourceType_const_iterator b (o.begin_resourceType()), e (o.end_resourceType()); + + if (b != e) + { + resourceType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) resourceType_next (o); + } + + resourceType_post (o); + } + } + + void Capability:: + resourceType_pre (Type&) + { + } + + void Capability:: + resourceType_pre (Type const&) + { + } + + void Capability:: + resourceType_next (Type&) + { + } + + void Capability:: + resourceType_next (Type const&) + { + } + + void Capability:: + resourceType_post (Type&) + { + } + + void Capability:: + resourceType_post (Type const&) + { + } + + void Capability:: + property (Type& o) + { + // VC6 anathema strikes again + // + Capability::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Capability:: + property (Type const& o) + { + // VC6 anathema strikes again + // + Capability::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void Capability:: + property_pre (Type&) + { + } + + void Capability:: + property_pre (Type const&) + { + } + + void Capability:: + property_next (Type&) + { + } + + void Capability:: + property_next (Type const&) + { + } + + void Capability:: + property_post (Type&) + { + } + + void Capability:: + property_post (Type const&) + { + } + + void Capability:: + property_none (Type&) + { + } + + void Capability:: + property_none (Type const&) + { + } + + void Capability:: + post (Type&) + { + } + + void Capability:: + post (Type const&) + { + } + + // ImplementationRequirement + // + // + + void ImplementationRequirement:: + traverse (Type& o) + { + pre (o); + if (o.resourceUsage_p ()) resourceUsage (o); + else resourceUsage_none (o); + if (o.resourcePort_p ()) resourcePort (o); + else resourcePort_none (o); + if (o.componentPort_p ()) componentPort (o); + else componentPort_none (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void ImplementationRequirement:: + traverse (Type const& o) + { + pre (o); + if (o.resourceUsage_p ()) resourceUsage (o); + else resourceUsage_none (o); + if (o.resourcePort_p ()) resourcePort (o); + else resourcePort_none (o); + if (o.componentPort_p ()) componentPort (o); + else componentPort_none (o); + resourceType (o); + name (o); + property (o); + post (o); + } + + void ImplementationRequirement:: + pre (Type&) + { + } + + void ImplementationRequirement:: + pre (Type const&) + { + } + + void ImplementationRequirement:: + resourceUsage (Type& o) + { + dispatch (o.resourceUsage ()); + } + + void ImplementationRequirement:: + resourceUsage (Type const& o) + { + dispatch (o.resourceUsage ()); + } + + void ImplementationRequirement:: + resourceUsage_none (Type&) + { + } + + void ImplementationRequirement:: + resourceUsage_none (Type const&) + { + } + + void ImplementationRequirement:: + resourcePort (Type& o) + { + dispatch (o.resourcePort ()); + } + + void ImplementationRequirement:: + resourcePort (Type const& o) + { + dispatch (o.resourcePort ()); + } + + void ImplementationRequirement:: + resourcePort_none (Type&) + { + } + + void ImplementationRequirement:: + resourcePort_none (Type const&) + { + } + + void ImplementationRequirement:: + componentPort (Type& o) + { + dispatch (o.componentPort ()); + } + + void ImplementationRequirement:: + componentPort (Type const& o) + { + dispatch (o.componentPort ()); + } + + void ImplementationRequirement:: + componentPort_none (Type&) + { + } + + void ImplementationRequirement:: + componentPort_none (Type const&) + { + } + + void ImplementationRequirement:: + resourceType (Type& o) + { + dispatch (o.resourceType ()); + } + + void ImplementationRequirement:: + resourceType (Type const& o) + { + dispatch (o.resourceType ()); + } + + void ImplementationRequirement:: + name (Type& o) + { + dispatch (o.name ()); + } + + void ImplementationRequirement:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void ImplementationRequirement:: + property (Type& o) + { + // VC6 anathema strikes again + // + ImplementationRequirement::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ImplementationRequirement:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ImplementationRequirement::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ImplementationRequirement:: + property_pre (Type&) + { + } + + void ImplementationRequirement:: + property_pre (Type const&) + { + } + + void ImplementationRequirement:: + property_next (Type&) + { + } + + void ImplementationRequirement:: + property_next (Type const&) + { + } + + void ImplementationRequirement:: + property_post (Type&) + { + } + + void ImplementationRequirement:: + property_post (Type const&) + { + } + + void ImplementationRequirement:: + property_none (Type&) + { + } + + void ImplementationRequirement:: + property_none (Type const&) + { + } + + void ImplementationRequirement:: + post (Type&) + { + } + + void ImplementationRequirement:: + post (Type const&) + { + } + + // ComponentPackageReference + // + // + + void ComponentPackageReference:: + traverse (Type& o) + { + pre (o); + if (o.requiredUUID_p ()) requiredUUID (o); + else requiredUUID_none (o); + if (o.requiredName_p ()) requiredName (o); + else requiredName_none (o); + requiredType (o); + post (o); + } + + void ComponentPackageReference:: + traverse (Type const& o) + { + pre (o); + if (o.requiredUUID_p ()) requiredUUID (o); + else requiredUUID_none (o); + if (o.requiredName_p ()) requiredName (o); + else requiredName_none (o); + requiredType (o); + post (o); + } + + void ComponentPackageReference:: + pre (Type&) + { + } + + void ComponentPackageReference:: + pre (Type const&) + { + } + + void ComponentPackageReference:: + requiredUUID (Type& o) + { + dispatch (o.requiredUUID ()); + } + + void ComponentPackageReference:: + requiredUUID (Type const& o) + { + dispatch (o.requiredUUID ()); + } + + void ComponentPackageReference:: + requiredUUID_none (Type&) + { + } + + void ComponentPackageReference:: + requiredUUID_none (Type const&) + { + } + + void ComponentPackageReference:: + requiredName (Type& o) + { + dispatch (o.requiredName ()); + } + + void ComponentPackageReference:: + requiredName (Type const& o) + { + dispatch (o.requiredName ()); + } + + void ComponentPackageReference:: + requiredName_none (Type&) + { + } + + void ComponentPackageReference:: + requiredName_none (Type const&) + { + } + + void ComponentPackageReference:: + requiredType (Type& o) + { + dispatch (o.requiredType ()); + } + + void ComponentPackageReference:: + requiredType (Type const& o) + { + dispatch (o.requiredType ()); + } + + void ComponentPackageReference:: + post (Type&) + { + } + + void ComponentPackageReference:: + post (Type const&) + { + } + + // SubcomponentPortEndpoint + // + // + + void SubcomponentPortEndpoint:: + traverse (Type& o) + { + pre (o); + portName (o); + instance (o); + post (o); + } + + void SubcomponentPortEndpoint:: + traverse (Type const& o) + { + pre (o); + portName (o); + instance (o); + post (o); + } + + void SubcomponentPortEndpoint:: + pre (Type&) + { + } + + void SubcomponentPortEndpoint:: + pre (Type const&) + { + } + + void SubcomponentPortEndpoint:: + portName (Type& o) + { + dispatch (o.portName ()); + } + + void SubcomponentPortEndpoint:: + portName (Type const& o) + { + dispatch (o.portName ()); + } + + void SubcomponentPortEndpoint:: + instance (Type& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPortEndpoint:: + instance (Type const& o) + { + dispatch (o.instance ()); + } + + void SubcomponentPortEndpoint:: + post (Type&) + { + } + + void SubcomponentPortEndpoint:: + post (Type const&) + { + } + + // AssemblyConnectionDescription + // + // + + void AssemblyConnectionDescription:: + traverse (Type& o) + { + pre (o); + name (o); + deployRequirement (o); + internalEndpoint (o); + externalEndpoint (o); + externalReference (o); + post (o); + } + + void AssemblyConnectionDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + deployRequirement (o); + internalEndpoint (o); + externalEndpoint (o); + externalReference (o); + post (o); + } + + void AssemblyConnectionDescription:: + pre (Type&) + { + } + + void AssemblyConnectionDescription:: + pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void AssemblyConnectionDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void AssemblyConnectionDescription:: + deployRequirement (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void AssemblyConnectionDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_none (Type&) + { + } + + void AssemblyConnectionDescription:: + deployRequirement_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::internalEndpoint_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::internalEndpoint_const_iterator b (o.begin_internalEndpoint()), e (o.end_internalEndpoint()); + + if (b != e) + { + internalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) internalEndpoint_next (o); + } + + internalEndpoint_post (o); + } + + else internalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_none (Type&) + { + } + + void AssemblyConnectionDescription:: + internalEndpoint_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalEndpoint_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalEndpoint_const_iterator b (o.begin_externalEndpoint()), e (o.end_externalEndpoint()); + + if (b != e) + { + externalEndpoint_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalEndpoint_next (o); + } + + externalEndpoint_post (o); + } + + else externalEndpoint_none (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_none (Type&) + { + } + + void AssemblyConnectionDescription:: + externalEndpoint_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference (Type& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalReference_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void AssemblyConnectionDescription:: + externalReference (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyConnectionDescription::Type::externalReference_const_iterator b (o.begin_externalReference()), e (o.end_externalReference()); + + if (b != e) + { + externalReference_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) externalReference_next (o); + } + + externalReference_post (o); + } + + else externalReference_none (o); + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_next (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_next (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_post (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_post (Type const&) + { + } + + void AssemblyConnectionDescription:: + externalReference_none (Type&) + { + } + + void AssemblyConnectionDescription:: + externalReference_none (Type const&) + { + } + + void AssemblyConnectionDescription:: + post (Type&) + { + } + + void AssemblyConnectionDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // TCKind + // + // + + TCKind:: + TCKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + TCKind:: + TCKind () + { + } + + void TCKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::TCKind::tk_null) s = "tk_null"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_void) s = "tk_void"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_short) s = "tk_short"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_long) s = "tk_long"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ushort) s = "tk_ushort"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulong) s = "tk_ulong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_float) s = "tk_float"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_double) s = "tk_double"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_boolean) s = "tk_boolean"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_char) s = "tk_char"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_octet) s = "tk_octet"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_any) s = "tk_any"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_TypeCode) s = "tk_TypeCode"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_Principal) s = "tk_Principal"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_objref) s = "tk_objref"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_struct) s = "tk_struct"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_union) s = "tk_union"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_enum) s = "tk_enum"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_string) s = "tk_string"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_sequence) s = "tk_sequence"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_array) s = "tk_array"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_alias) s = "tk_alias"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_except) s = "tk_except"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longlong) s = "tk_longlong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_ulonglong) s = "tk_ulonglong"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_longdouble) s = "tk_longdouble"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wchar) s = "tk_wchar"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wstring) s = "tk_wstring"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_wfixed) s = "tk_wfixed"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value) s = "tk_value"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_value_box) s = "tk_value_box"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_native) s = "tk_native"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_abstract_interface) s = "tk_abstract_interface"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_local_interface) s = "tk_local_interface"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_component) s = "tk_component"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_home) s = "tk_home"; + else if (o == ::CIAO::Config_Handlers::TCKind::tk_event) s = "tk_event"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // DataType + // + // + + DataType:: + DataType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + DataType:: + DataType () + { + } + + void DataType:: + traverse (Type const& o) + { + Traversal::DataType::traverse (o); + } + + void DataType:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::DataType::kind (o); + pop_ (); + } + + void DataType:: + enum_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("enum", top_ ())); + Traversal::DataType::enum_ (o); + pop_ (); + } + + void DataType:: + struct_ (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("struct", top_ ())); + Traversal::DataType::struct_ (o); + pop_ (); + } + + void DataType:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::DataType::value (o); + pop_ (); + } + + void DataType:: + sequence (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("sequence", top_ ())); + Traversal::DataType::sequence (o); + pop_ (); + } + + void DataType:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::DataType::id (o); + attr_ (0); + } + + // DataValue + // + // + + DataValue:: + DataValue (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + DataValue:: + DataValue () + { + } + + void DataValue:: + traverse (Type const& o) + { + Traversal::DataValue::traverse (o); + } + + void DataValue:: + short_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("short", top_ ())); + } + + void DataValue:: + short_next (Type const& o) + { + short_post (o); + short_pre (o); + } + + void DataValue:: + short_post (Type const&) + { + pop_ (); + } + + void DataValue:: + long_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("long", top_ ())); + } + + void DataValue:: + long_next (Type const& o) + { + long_post (o); + long_pre (o); + } + + void DataValue:: + long_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ushort_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ushort", top_ ())); + } + + void DataValue:: + ushort_next (Type const& o) + { + ushort_post (o); + ushort_pre (o); + } + + void DataValue:: + ushort_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ulong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ulong", top_ ())); + } + + void DataValue:: + ulong_next (Type const& o) + { + ulong_post (o); + ulong_pre (o); + } + + void DataValue:: + ulong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + float_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("float", top_ ())); + } + + void DataValue:: + float_next (Type const& o) + { + float_post (o); + float_pre (o); + } + + void DataValue:: + float_post (Type const&) + { + pop_ (); + } + + void DataValue:: + double_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("double", top_ ())); + } + + void DataValue:: + double_next (Type const& o) + { + double_post (o); + double_pre (o); + } + + void DataValue:: + double_post (Type const&) + { + pop_ (); + } + + void DataValue:: + boolean_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("boolean", top_ ())); + } + + void DataValue:: + boolean_next (Type const& o) + { + boolean_post (o); + boolean_pre (o); + } + + void DataValue:: + boolean_post (Type const&) + { + pop_ (); + } + + void DataValue:: + octet_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("octet", top_ ())); + } + + void DataValue:: + octet_next (Type const& o) + { + octet_post (o); + octet_pre (o); + } + + void DataValue:: + octet_post (Type const&) + { + pop_ (); + } + + void DataValue:: + enum_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("enum", top_ ())); + } + + void DataValue:: + enum_next (Type const& o) + { + enum_post (o); + enum_pre (o); + } + + void DataValue:: + enum_post (Type const&) + { + pop_ (); + } + + void DataValue:: + string_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("string", top_ ())); + } + + void DataValue:: + string_next (Type const& o) + { + string_post (o); + string_pre (o); + } + + void DataValue:: + string_post (Type const&) + { + pop_ (); + } + + void DataValue:: + longlong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("longlong", top_ ())); + } + + void DataValue:: + longlong_next (Type const& o) + { + longlong_post (o); + longlong_pre (o); + } + + void DataValue:: + longlong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + ulonglong_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("ulonglong", top_ ())); + } + + void DataValue:: + ulonglong_next (Type const& o) + { + ulonglong_post (o); + ulonglong_pre (o); + } + + void DataValue:: + ulonglong_post (Type const&) + { + pop_ (); + } + + void DataValue:: + longdouble_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("longdouble", top_ ())); + } + + void DataValue:: + longdouble_next (Type const& o) + { + longdouble_post (o); + longdouble_pre (o); + } + + void DataValue:: + longdouble_post (Type const&) + { + pop_ (); + } + + void DataValue:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void DataValue:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void DataValue:: + member_post (Type const&) + { + pop_ (); + } + + // EnumType + // + // + + EnumType:: + EnumType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + EnumType:: + EnumType () + { + } + + void EnumType:: + traverse (Type const& o) + { + Traversal::EnumType::traverse (o); + } + + void EnumType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::EnumType::name (o); + pop_ (); + } + + void EnumType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::EnumType::typeId (o); + pop_ (); + } + + void EnumType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void EnumType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void EnumType:: + member_post (Type const&) + { + pop_ (); + } + + // StructType + // + // + + StructType:: + StructType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + StructType:: + StructType () + { + } + + void StructType:: + traverse (Type const& o) + { + Traversal::StructType::traverse (o); + } + + void StructType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::StructType::name (o); + pop_ (); + } + + void StructType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::StructType::typeId (o); + pop_ (); + } + + void StructType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void StructType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void StructType:: + member_post (Type const&) + { + pop_ (); + } + + // StructMemberType + // + // + + StructMemberType:: + StructMemberType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + StructMemberType:: + StructMemberType () + { + } + + void StructMemberType:: + traverse (Type const& o) + { + Traversal::StructMemberType::traverse (o); + } + + void StructMemberType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::StructMemberType::name (o); + pop_ (); + } + + void StructMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::StructMemberType::type (o); + pop_ (); + } + + // ValueType + // + // + + ValueType:: + ValueType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ValueType:: + ValueType () + { + } + + void ValueType:: + traverse (Type const& o) + { + Traversal::ValueType::traverse (o); + } + + void ValueType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ValueType::name (o); + pop_ (); + } + + void ValueType:: + typeId (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("typeId", top_ ())); + Traversal::ValueType::typeId (o); + pop_ (); + } + + void ValueType:: + modifier (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("modifier", top_ ())); + Traversal::ValueType::modifier (o); + pop_ (); + } + + void ValueType:: + baseType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("baseType", top_ ())); + Traversal::ValueType::baseType (o); + pop_ (); + } + + void ValueType:: + member_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("member", top_ ())); + } + + void ValueType:: + member_next (Type const& o) + { + member_post (o); + member_pre (o); + } + + void ValueType:: + member_post (Type const&) + { + pop_ (); + } + + // ValueMemberType + // + // + + ValueMemberType:: + ValueMemberType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ValueMemberType:: + ValueMemberType () + { + } + + void ValueMemberType:: + traverse (Type const& o) + { + Traversal::ValueMemberType::traverse (o); + } + + void ValueMemberType:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ValueMemberType::name (o); + pop_ (); + } + + void ValueMemberType:: + visibility (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("visibility", top_ ())); + Traversal::ValueMemberType::visibility (o); + pop_ (); + } + + void ValueMemberType:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::ValueMemberType::type (o); + pop_ (); + } + + // NamedValue + // + // + + NamedValue:: + NamedValue (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + NamedValue:: + NamedValue () + { + } + + void NamedValue:: + traverse (Type const& o) + { + Traversal::NamedValue::traverse (o); + } + + void NamedValue:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::NamedValue::name (o); + pop_ (); + } + + void NamedValue:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::NamedValue::value (o); + pop_ (); + } + + // SequenceType + // + // + + SequenceType:: + SequenceType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SequenceType:: + SequenceType () + { + } + + void SequenceType:: + traverse (Type const& o) + { + Traversal::SequenceType::traverse (o); + } + + void SequenceType:: + bound (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("bound", top_ ())); + Traversal::SequenceType::bound (o); + pop_ (); + } + + void SequenceType:: + elementType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("elementType", top_ ())); + Traversal::SequenceType::elementType (o); + pop_ (); + } + + // Any + // + // + + Any:: + Any (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Any:: + Any () + { + } + + void Any:: + traverse (Type const& o) + { + Traversal::Any::traverse (o); + } + + void Any:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::Any::type (o); + pop_ (); + } + + void Any:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::Any::value (o); + pop_ (); + } + + // Property + // + // + + Property:: + Property (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Property:: + Property () + { + } + + void Property:: + traverse (Type const& o) + { + Traversal::Property::traverse (o); + } + + void Property:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Property::name (o); + pop_ (); + } + + void Property:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::Property::value (o); + pop_ (); + } + + // SatisfierPropertyKind + // + // + + SatisfierPropertyKind:: + SatisfierPropertyKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SatisfierPropertyKind:: + SatisfierPropertyKind () + { + } + + void SatisfierPropertyKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Quantity) s = "Quantity"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Capacity) s = "Capacity"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Minimum) s = "Minimum"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Maximum) s = "Maximum"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Attribute) s = "Attribute"; + else if (o == ::CIAO::Config_Handlers::SatisfierPropertyKind::Selection) s = "Selection"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // SatisfierProperty + // + // + + SatisfierProperty:: + SatisfierProperty (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SatisfierProperty:: + SatisfierProperty () + { + } + + void SatisfierProperty:: + traverse (Type const& o) + { + Traversal::SatisfierProperty::traverse (o); + } + + void SatisfierProperty:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::SatisfierProperty::name (o); + pop_ (); + } + + void SatisfierProperty:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::SatisfierProperty::kind (o); + pop_ (); + } + + void SatisfierProperty:: + dynamic (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("dynamic", top_ ())); + Traversal::SatisfierProperty::dynamic (o); + pop_ (); + } + + void SatisfierProperty:: + value (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("value", top_ ())); + Traversal::SatisfierProperty::value (o); + pop_ (); + } + + // Resource + // + // + + Resource:: + Resource (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Resource:: + Resource () + { + } + + void Resource:: + traverse (Type const& o) + { + Traversal::Resource::traverse (o); + } + + void Resource:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Resource::name (o); + pop_ (); + } + + void Resource:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + } + + void Resource:: + resourceType_next (Type const& o) + { + resourceType_post (o); + resourceType_pre (o); + } + + void Resource:: + resourceType_post (Type const&) + { + pop_ (); + } + + void Resource:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Resource:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Resource:: + property_post (Type const&) + { + pop_ (); + } + + // Requirement + // + // + + Requirement:: + Requirement (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Requirement:: + Requirement () + { + } + + void Requirement:: + traverse (Type const& o) + { + Traversal::Requirement::traverse (o); + } + + void Requirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + Traversal::Requirement::resourceType (o); + pop_ (); + } + + void Requirement:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Requirement::name (o); + pop_ (); + } + + void Requirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Requirement:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Requirement:: + property_post (Type const&) + { + pop_ (); + } + + // ResourceDeploymentDescription + // + // + + ResourceDeploymentDescription:: + ResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ResourceDeploymentDescription:: + ResourceDeploymentDescription () + { + } + + void ResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ResourceDeploymentDescription::traverse (o); + } + + void ResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::ResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::ResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // ArtifactDeploymentDescription + // + // + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ArtifactDeploymentDescription:: + ArtifactDeploymentDescription () + { + } + + void ArtifactDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ArtifactDeploymentDescription::traverse (o); + } + + void ArtifactDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ArtifactDeploymentDescription::name (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + } + + void ArtifactDeploymentDescription:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void ArtifactDeploymentDescription:: + source_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::ArtifactDeploymentDescription::node (o); + pop_ (); + } + + void ArtifactDeploymentDescription:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("location", top_ ())); + } + + void ArtifactDeploymentDescription:: + location_next (Type const& o) + { + location_post (o); + location_pre (o); + } + + void ArtifactDeploymentDescription:: + location_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + execParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("execParameter", top_ ())); + } + + void ArtifactDeploymentDescription:: + execParameter_next (Type const& o) + { + execParameter_post (o); + execParameter_pre (o); + } + + void ArtifactDeploymentDescription:: + execParameter_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void ArtifactDeploymentDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void ArtifactDeploymentDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void ArtifactDeploymentDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void ArtifactDeploymentDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + void ArtifactDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ArtifactDeploymentDescription::id (o); + attr_ (0); + } + + // MonolithicDeploymentDescription + // + // + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + MonolithicDeploymentDescription:: + MonolithicDeploymentDescription () + { + } + + void MonolithicDeploymentDescription:: + traverse (Type const& o) + { + Traversal::MonolithicDeploymentDescription::traverse (o); + } + + void MonolithicDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::MonolithicDeploymentDescription::name (o); + pop_ (); + } + + void MonolithicDeploymentDescription:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + } + + void MonolithicDeploymentDescription:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void MonolithicDeploymentDescription:: + source_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + artifact_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("artifact", top_ ())); + } + + void MonolithicDeploymentDescription:: + artifact_next (Type const& o) + { + artifact_post (o); + artifact_pre (o); + } + + void MonolithicDeploymentDescription:: + artifact_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + execParameter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("execParameter", top_ ())); + } + + void MonolithicDeploymentDescription:: + execParameter_next (Type const& o) + { + execParameter_post (o); + execParameter_pre (o); + } + + void MonolithicDeploymentDescription:: + execParameter_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void MonolithicDeploymentDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void MonolithicDeploymentDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void MonolithicDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::MonolithicDeploymentDescription::id (o); + attr_ (0); + } + + // ResourceUsageKind + // + // + + ResourceUsageKind:: + ResourceUsageKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ResourceUsageKind:: + ResourceUsageKind () + { + } + + void ResourceUsageKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::ResourceUsageKind::None) s = "None"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::InstanceUsesResource) s = "InstanceUsesResource"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesInstance) s = "ResourceUsesInstance"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::PortUsesResource) s = "PortUsesResource"; + else if (o == ::CIAO::Config_Handlers::ResourceUsageKind::ResourceUsesPort) s = "ResourceUsesPort"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // InstanceResourceDeploymentDescription + // + // + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + InstanceResourceDeploymentDescription:: + InstanceResourceDeploymentDescription () + { + } + + void InstanceResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::InstanceResourceDeploymentDescription::traverse (o); + } + + void InstanceResourceDeploymentDescription:: + resourceUsage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceUsage", top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceUsage (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::InstanceResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::InstanceResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void InstanceResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void InstanceResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void InstanceResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // InstanceDeploymentDescription + // + // + + InstanceDeploymentDescription:: + InstanceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + InstanceDeploymentDescription:: + InstanceDeploymentDescription () + { + } + + void InstanceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::InstanceDeploymentDescription::traverse (o); + } + + void InstanceDeploymentDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::InstanceDeploymentDescription::name (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::InstanceDeploymentDescription::node (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + Traversal::InstanceDeploymentDescription::source (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + implementation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("implementation", top_ ())); + Traversal::InstanceDeploymentDescription::implementation (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("configProperty", top_ ())); + } + + void InstanceDeploymentDescription:: + configProperty_next (Type const& o) + { + configProperty_post (o); + configProperty_pre (o); + } + + void InstanceDeploymentDescription:: + configProperty_post (Type const&) + { + pop_ (); + } + + void InstanceDeploymentDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void InstanceDeploymentDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void InstanceDeploymentDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + void InstanceDeploymentDescription:: + deployedSharedResource (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedSharedResource", top_ ())); + Traversal::InstanceDeploymentDescription::deployedSharedResource (o); + pop_ (); + } + + void InstanceDeploymentDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::InstanceDeploymentDescription::id (o); + attr_ (0); + } + + // CCMComponentPortKind + // + // + + CCMComponentPortKind:: + CCMComponentPortKind (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + CCMComponentPortKind:: + CCMComponentPortKind () + { + } + + void CCMComponentPortKind:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::Facet) s = "Facet"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::SimplexReceptacle) s = "SimplexReceptacle"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::MultiplexReceptacle) s = "MultiplexReceptacle"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventEmitter) s = "EventEmitter"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventPublisher) s = "EventPublisher"; + else if (o == ::CIAO::Config_Handlers::CCMComponentPortKind::EventConsumer) s = "EventConsumer"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // ComponentPortDescription + // + // + + ComponentPortDescription:: + ComponentPortDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPortDescription:: + ComponentPortDescription () + { + } + + void ComponentPortDescription:: + traverse (Type const& o) + { + Traversal::ComponentPortDescription::traverse (o); + } + + void ComponentPortDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ComponentPortDescription::name (o); + pop_ (); + } + + void ComponentPortDescription:: + specificType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("specificType", top_ ())); + Traversal::ComponentPortDescription::specificType (o); + pop_ (); + } + + void ComponentPortDescription:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("supportedType", top_ ())); + } + + void ComponentPortDescription:: + supportedType_next (Type const& o) + { + supportedType_post (o); + supportedType_pre (o); + } + + void ComponentPortDescription:: + supportedType_post (Type const&) + { + pop_ (); + } + + void ComponentPortDescription:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("provider", top_ ())); + Traversal::ComponentPortDescription::provider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveProvider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("exclusiveProvider", top_ ())); + Traversal::ComponentPortDescription::exclusiveProvider (o); + pop_ (); + } + + void ComponentPortDescription:: + exclusiveUser (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("exclusiveUser", top_ ())); + Traversal::ComponentPortDescription::exclusiveUser (o); + pop_ (); + } + + void ComponentPortDescription:: + optional (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("optional", top_ ())); + Traversal::ComponentPortDescription::optional (o); + pop_ (); + } + + void ComponentPortDescription:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::ComponentPortDescription::kind (o); + pop_ (); + } + + // ComponentPropertyDescription + // + // + + ComponentPropertyDescription:: + ComponentPropertyDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPropertyDescription:: + ComponentPropertyDescription () + { + } + + void ComponentPropertyDescription:: + traverse (Type const& o) + { + Traversal::ComponentPropertyDescription::traverse (o); + } + + void ComponentPropertyDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ComponentPropertyDescription::name (o); + pop_ (); + } + + void ComponentPropertyDescription:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::ComponentPropertyDescription::type (o); + pop_ (); + } + + // ComponentExternalPortEndpoint + // + // + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentExternalPortEndpoint:: + ComponentExternalPortEndpoint () + { + } + + void ComponentExternalPortEndpoint:: + traverse (Type const& o) + { + Traversal::ComponentExternalPortEndpoint::traverse (o); + } + + void ComponentExternalPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::ComponentExternalPortEndpoint::portName (o); + pop_ (); + } + + // PlanSubcomponentPortEndpoint + // + // + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanSubcomponentPortEndpoint:: + PlanSubcomponentPortEndpoint () + { + } + + void PlanSubcomponentPortEndpoint:: + traverse (Type const& o) + { + Traversal::PlanSubcomponentPortEndpoint::traverse (o); + } + + void PlanSubcomponentPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + provider (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("provider", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::provider (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + kind (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("kind", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::kind (o); + pop_ (); + } + + void PlanSubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("instance", top_ ())); + Traversal::PlanSubcomponentPortEndpoint::instance (o); + pop_ (); + } + + // ExternalReferenceEndpoint + // + // + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ExternalReferenceEndpoint:: + ExternalReferenceEndpoint () + { + } + + void ExternalReferenceEndpoint:: + traverse (Type const& o) + { + Traversal::ExternalReferenceEndpoint::traverse (o); + } + + void ExternalReferenceEndpoint:: + location (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("location", top_ ())); + Traversal::ExternalReferenceEndpoint::location (o); + pop_ (); + } + + // ConnectionResourceDeploymentDescription + // + // + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ConnectionResourceDeploymentDescription:: + ConnectionResourceDeploymentDescription () + { + } + + void ConnectionResourceDeploymentDescription:: + traverse (Type const& o) + { + Traversal::ConnectionResourceDeploymentDescription::traverse (o); + } + + void ConnectionResourceDeploymentDescription:: + targetName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("targetName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::targetName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + requirementName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requirementName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::requirementName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + resourceName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceName", top_ ())); + Traversal::ConnectionResourceDeploymentDescription::resourceName (o); + pop_ (); + } + + void ConnectionResourceDeploymentDescription:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ConnectionResourceDeploymentDescription:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ConnectionResourceDeploymentDescription:: + property_post (Type const&) + { + pop_ (); + } + + // PlanConnectionDescription + // + // + + PlanConnectionDescription:: + PlanConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PlanConnectionDescription:: + PlanConnectionDescription () + { + } + + void PlanConnectionDescription:: + traverse (Type const& o) + { + Traversal::PlanConnectionDescription::traverse (o); + } + + void PlanConnectionDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::PlanConnectionDescription::name (o); + pop_ (); + } + + void PlanConnectionDescription:: + source (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + Traversal::PlanConnectionDescription::source (o); + pop_ (); + } + + void PlanConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void PlanConnectionDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void PlanConnectionDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + externalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalEndpoint", top_ ())); + } + + void PlanConnectionDescription:: + externalEndpoint_next (Type const& o) + { + externalEndpoint_post (o); + externalEndpoint_pre (o); + } + + void PlanConnectionDescription:: + externalEndpoint_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + internalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("internalEndpoint", top_ ())); + } + + void PlanConnectionDescription:: + internalEndpoint_next (Type const& o) + { + internalEndpoint_post (o); + internalEndpoint_pre (o); + } + + void PlanConnectionDescription:: + internalEndpoint_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + externalReference_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalReference", top_ ())); + } + + void PlanConnectionDescription:: + externalReference_next (Type const& o) + { + externalReference_post (o); + externalReference_pre (o); + } + + void PlanConnectionDescription:: + externalReference_post (Type const&) + { + pop_ (); + } + + void PlanConnectionDescription:: + deployedResource_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployedResource", top_ ())); + } + + void PlanConnectionDescription:: + deployedResource_next (Type const& o) + { + deployedResource_post (o); + deployedResource_pre (o); + } + + void PlanConnectionDescription:: + deployedResource_post (Type const&) + { + pop_ (); + } + + // ImplementationDependency + // + // + + ImplementationDependency:: + ImplementationDependency (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ImplementationDependency:: + ImplementationDependency () + { + } + + void ImplementationDependency:: + traverse (Type const& o) + { + Traversal::ImplementationDependency::traverse (o); + } + + void ImplementationDependency:: + requiredType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredType", top_ ())); + Traversal::ImplementationDependency::requiredType (o); + pop_ (); + } + + // Capability + // + // + + Capability:: + Capability (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Capability:: + Capability () + { + } + + void Capability:: + traverse (Type const& o) + { + Traversal::Capability::traverse (o); + } + + void Capability:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Capability::name (o); + pop_ (); + } + + void Capability:: + resourceType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + } + + void Capability:: + resourceType_next (Type const& o) + { + resourceType_post (o); + resourceType_pre (o); + } + + void Capability:: + resourceType_post (Type const&) + { + pop_ (); + } + + void Capability:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void Capability:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void Capability:: + property_post (Type const&) + { + pop_ (); + } + + // ImplementationRequirement + // + // + + ImplementationRequirement:: + ImplementationRequirement (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ImplementationRequirement:: + ImplementationRequirement () + { + } + + void ImplementationRequirement:: + traverse (Type const& o) + { + Traversal::ImplementationRequirement::traverse (o); + } + + void ImplementationRequirement:: + resourceUsage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceUsage", top_ ())); + Traversal::ImplementationRequirement::resourceUsage (o); + pop_ (); + } + + void ImplementationRequirement:: + resourcePort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourcePort", top_ ())); + Traversal::ImplementationRequirement::resourcePort (o); + pop_ (); + } + + void ImplementationRequirement:: + componentPort (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("componentPort", top_ ())); + Traversal::ImplementationRequirement::componentPort (o); + pop_ (); + } + + void ImplementationRequirement:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + Traversal::ImplementationRequirement::resourceType (o); + pop_ (); + } + + void ImplementationRequirement:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::ImplementationRequirement::name (o); + pop_ (); + } + + void ImplementationRequirement:: + property_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + } + + void ImplementationRequirement:: + property_next (Type const& o) + { + property_post (o); + property_pre (o); + } + + void ImplementationRequirement:: + property_post (Type const&) + { + pop_ (); + } + + // ComponentPackageReference + // + // + + ComponentPackageReference:: + ComponentPackageReference (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ComponentPackageReference:: + ComponentPackageReference () + { + } + + void ComponentPackageReference:: + traverse (Type const& o) + { + Traversal::ComponentPackageReference::traverse (o); + } + + void ComponentPackageReference:: + requiredUUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredUUID", top_ ())); + Traversal::ComponentPackageReference::requiredUUID (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredName", top_ ())); + Traversal::ComponentPackageReference::requiredName (o); + pop_ (); + } + + void ComponentPackageReference:: + requiredType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("requiredType", top_ ())); + Traversal::ComponentPackageReference::requiredType (o); + pop_ (); + } + + // SubcomponentPortEndpoint + // + // + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + SubcomponentPortEndpoint:: + SubcomponentPortEndpoint () + { + } + + void SubcomponentPortEndpoint:: + traverse (Type const& o) + { + Traversal::SubcomponentPortEndpoint::traverse (o); + } + + void SubcomponentPortEndpoint:: + portName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("portName", top_ ())); + Traversal::SubcomponentPortEndpoint::portName (o); + pop_ (); + } + + void SubcomponentPortEndpoint:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("instance", top_ ())); + Traversal::SubcomponentPortEndpoint::instance (o); + pop_ (); + } + + // AssemblyConnectionDescription + // + // + + AssemblyConnectionDescription:: + AssemblyConnectionDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + AssemblyConnectionDescription:: + AssemblyConnectionDescription () + { + } + + void AssemblyConnectionDescription:: + traverse (Type const& o) + { + Traversal::AssemblyConnectionDescription::traverse (o); + } + + void AssemblyConnectionDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::AssemblyConnectionDescription::name (o); + pop_ (); + } + + void AssemblyConnectionDescription:: + deployRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("deployRequirement", top_ ())); + } + + void AssemblyConnectionDescription:: + deployRequirement_next (Type const& o) + { + deployRequirement_post (o); + deployRequirement_pre (o); + } + + void AssemblyConnectionDescription:: + deployRequirement_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + internalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("internalEndpoint", top_ ())); + } + + void AssemblyConnectionDescription:: + internalEndpoint_next (Type const& o) + { + internalEndpoint_post (o); + internalEndpoint_pre (o); + } + + void AssemblyConnectionDescription:: + internalEndpoint_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + externalEndpoint_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalEndpoint", top_ ())); + } + + void AssemblyConnectionDescription:: + externalEndpoint_next (Type const& o) + { + externalEndpoint_post (o); + externalEndpoint_pre (o); + } + + void AssemblyConnectionDescription:: + externalEndpoint_post (Type const&) + { + pop_ (); + } + + void AssemblyConnectionDescription:: + externalReference_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalReference", top_ ())); + } + + void AssemblyConnectionDescription:: + externalReference_next (Type const& o) + { + externalReference_post (o); + externalReference_pre (o); + } + + void AssemblyConnectionDescription:: + externalReference_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp new file mode 100644 index 00000000000..f67d45baeaa --- /dev/null +++ b/CIAO/tools/Config_Handlers/Basic_Deployment_Data.hpp @@ -0,0 +1,8252 @@ +/* $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 TCKind; + class DataType; + class DataValue; + 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 ComponentPackageReference; + class SubcomponentPortEndpoint; + class AssemblyConnectionDescription; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + 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_wfixed; + 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_wfixed_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; + + // 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_; + + // 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; + + // short + // + public: + typedef ::std::list< ::XMLSchema::short_ >::iterator short_iterator; + typedef ::std::list< ::XMLSchema::short_ >::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 (::XMLSchema::short_ const& ); + size_t count_short (void) const; + + protected: + ::std::list< ::XMLSchema::short_ > short_; + + // long + // + public: + typedef ::std::list< ::XMLSchema::int_ >::iterator long_iterator; + typedef ::std::list< ::XMLSchema::int_ >::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 (::XMLSchema::int_ const& ); + size_t count_long (void) const; + + protected: + ::std::list< ::XMLSchema::int_ > long_; + + // ushort + // + public: + typedef ::std::list< ::XMLSchema::unsignedShort >::iterator ushort_iterator; + typedef ::std::list< ::XMLSchema::unsignedShort >::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 (::XMLSchema::unsignedShort const& ); + size_t count_ushort (void) const; + + protected: + ::std::list< ::XMLSchema::unsignedShort > ushort_; + + // ulong + // + public: + typedef ::std::list< ::XMLSchema::unsignedInt >::iterator ulong_iterator; + typedef ::std::list< ::XMLSchema::unsignedInt >::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 (::XMLSchema::unsignedInt const& ); + size_t count_ulong (void) const; + + protected: + ::std::list< ::XMLSchema::unsignedInt > ulong_; + + // float + // + public: + typedef ::std::list< ::XMLSchema::float_ >::iterator float_iterator; + typedef ::std::list< ::XMLSchema::float_ >::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 (::XMLSchema::float_ const& ); + size_t count_float (void) const; + + protected: + ::std::list< ::XMLSchema::float_ > float_; + + // double + // + public: + typedef ::std::list< ::XMLSchema::double_ >::iterator double_iterator; + typedef ::std::list< ::XMLSchema::double_ >::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 (::XMLSchema::double_ const& ); + size_t count_double (void) const; + + protected: + ::std::list< ::XMLSchema::double_ > double_; + + // boolean + // + public: + typedef ::std::list< ::XMLSchema::boolean >::iterator boolean_iterator; + typedef ::std::list< ::XMLSchema::boolean >::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 (::XMLSchema::boolean const& ); + size_t count_boolean (void) const; + + protected: + ::std::list< ::XMLSchema::boolean > boolean_; + + // octet + // + public: + typedef ::std::list< ::XMLSchema::unsignedByte >::iterator octet_iterator; + typedef ::std::list< ::XMLSchema::unsignedByte >::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 (::XMLSchema::unsignedByte const& ); + size_t count_octet (void) const; + + protected: + ::std::list< ::XMLSchema::unsignedByte > octet_; + + // enum + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator enum_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_enum (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > enum_; + + // string + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator string_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_string (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > string_; + + // longlong + // + public: + typedef ::std::list< ::XMLSchema::long_ >::iterator longlong_iterator; + typedef ::std::list< ::XMLSchema::long_ >::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 (::XMLSchema::long_ const& ); + size_t count_longlong (void) const; + + protected: + ::std::list< ::XMLSchema::long_ > longlong_; + + // ulonglong + // + public: + typedef ::std::list< ::XMLSchema::unsignedLong >::iterator ulonglong_iterator; + typedef ::std::list< ::XMLSchema::unsignedLong >::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 (::XMLSchema::unsignedLong const& ); + size_t count_ulonglong (void) const; + + protected: + ::std::list< ::XMLSchema::unsignedLong > ulonglong_; + + // longdouble + // + public: + typedef ::std::list< ::XMLSchema::double_ >::iterator longdouble_iterator; + typedef ::std::list< ::XMLSchema::double_ >::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 (::XMLSchema::double_ const& ); + size_t count_longdouble (void) const; + + protected: + ::std::list< ::XMLSchema::double_ > longdouble_; + + // member + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::NamedValue >::iterator member_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::NamedValue >::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 (::CIAO::Config_Handlers::NamedValue const& ); + size_t count_member (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::NamedValue > 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 EnumType : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator member_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_member (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > member_; + + public: + EnumType (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& typeId__); + + 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; + + // 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< ::CIAO::Config_Handlers::StructMemberType >::iterator member_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::StructMemberType >::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 (::CIAO::Config_Handlers::StructMemberType const& ); + size_t count_member (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::StructMemberType > 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; + + // 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; + + // 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< ::CIAO::Config_Handlers::ValueMemberType >::iterator member_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ValueMemberType >::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 (::CIAO::Config_Handlers::ValueMemberType const& ); + size_t count_member (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ValueMemberType > 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; + + // 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; + + // 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; + + // bound + // + public: + bool bound_p () const; + ::XMLSchema::string< ACE_TCHAR > const& bound () const; + void bound (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > 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; + + // 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; + + // 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; + + // 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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator resourceType_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_resourceType (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > resourceType_; + + // property + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SatisfierProperty >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SatisfierProperty >::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 (::CIAO::Config_Handlers::SatisfierProperty const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SatisfierProperty > property_; + + public: + Resource (::XMLSchema::string< ACE_TCHAR > const& name__); + + 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > property_; + + public: + Requirement (::XMLSchema::string< ACE_TCHAR > const& resourceType__, + ::XMLSchema::string< ACE_TCHAR > const& name__); + + 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator source_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_source (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > source_; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator location_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_location (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > location_; + + // execParameter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator execParameter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > execParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > deployRequirement_; + + // deployedResource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ResourceDeploymentDescription >::iterator deployedResource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ResourceDeploymentDescription >::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 (::CIAO::Config_Handlers::ResourceDeploymentDescription const& ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ResourceDeploymentDescription > 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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator source_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_source (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > source_; + + // artifact + // + public: + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::iterator artifact_iterator; + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::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 (::XMLSchema::IDREF< ACE_TCHAR > const& ); + size_t count_artifact (void) const; + + protected: + ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > > artifact_; + + // execParameter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator execParameter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > execParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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; + + // 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: + ::XMLSchema::IDREF< ACE_TCHAR > const& implementation () const; + void implementation (::XMLSchema::IDREF< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > implementation_; + + // configProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > configProperty_; + + // deployedResource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription >::iterator deployedResource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription >::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 (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > 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__, + ::XMLSchema::IDREF< ACE_TCHAR > 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; + + enum Value + { + Facet_l, SimplexReceptacle_l, MultiplexReceptacle_l, EventEmitter_l, EventPublisher_l, EventConsumer_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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator supportedType_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_supportedType (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > 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_; + + 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; + + // 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; + + // 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; + + // 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: + ::XMLSchema::IDREF< ACE_TCHAR > const& instance () const; + void instance (::XMLSchema::IDREF< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > instance_; + + public: + PlanSubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::CIAO::Config_Handlers::CCMComponentPortKind const& kind__, + ::XMLSchema::IDREF< ACE_TCHAR > 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; + + // 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_; + + public: + ExternalReferenceEndpoint (::XMLSchema::string< ACE_TCHAR > const& location__); + + 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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; + + // 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< ::CIAO::Config_Handlers::Requirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > deployRequirement_; + + // externalEndpoint + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::iterator externalEndpoint_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::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 (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& ); + size_t count_externalEndpoint (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > externalEndpoint_; + + // internalEndpoint + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint >::iterator internalEndpoint_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint >::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 (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& ); + size_t count_internalEndpoint (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint > internalEndpoint_; + + // externalReference + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::iterator externalReference_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::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 (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& ); + size_t count_externalReference (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > externalReference_; + + // deployedResource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription >::iterator deployedResource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription >::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 (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& ); + size_t count_deployedResource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription > 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; + + // 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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator resourceType_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_resourceType (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > resourceType_; + + // property + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SatisfierProperty >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SatisfierProperty >::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 (::CIAO::Config_Handlers::SatisfierProperty const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SatisfierProperty > 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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 ComponentPackageReference : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // 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: + ::XMLSchema::string< ACE_TCHAR > const& requiredType () const; + void requiredType (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > requiredType_; + + public: + ComponentPackageReference (::XMLSchema::string< ACE_TCHAR > 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 SubcomponentPortEndpoint : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // 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: + ::XMLSchema::IDREF< ACE_TCHAR > const& instance () const; + void instance (::XMLSchema::IDREF< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > instance_; + + public: + SubcomponentPortEndpoint (::XMLSchema::string< ACE_TCHAR > const& portName__, + ::XMLSchema::IDREF< ACE_TCHAR > 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; + + // 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< ::CIAO::Config_Handlers::Requirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > deployRequirement_; + + // internalEndpoint + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SubcomponentPortEndpoint >::iterator internalEndpoint_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SubcomponentPortEndpoint >::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 (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& ); + size_t count_internalEndpoint (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SubcomponentPortEndpoint > internalEndpoint_; + + // externalEndpoint + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::iterator externalEndpoint_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::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 (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& ); + size_t count_externalEndpoint (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > externalEndpoint_; + + // externalReference + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::iterator externalReference_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::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 (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& ); + size_t count_externalReference (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > 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__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + 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 + 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 + 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 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 + 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 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 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 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&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + 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 + 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 + 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 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 + 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: + 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&); + + 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&); + + 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 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 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 (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // BASIC_DEPLOYMENT_DATA_HPP diff --git a/CIAO/tools/Config_Handlers/CCD_Handler.cpp b/CIAO/tools/Config_Handlers/CCD_Handler.cpp new file mode 100644 index 00000000000..8256f089f68 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CCD_Handler.cpp @@ -0,0 +1,186 @@ +// $Id$ + +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" + +#include "ciao/CIAO_common.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 (desc.UUID ().c_str ()); + + if (desc.label_p ()) + { + toconfig.label = + CORBA::string_dup (desc.label ().c_str ()); + } + + if (desc.specificType_p ()) + { + toconfig.specificType = + CORBA::string_dup (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++] = 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++] = 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< char > uuid ((src.UUID)); + XMLSchema::string< char > label ((src.label)); + XMLSchema::string< char > specifict ((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< char > curr ((src.supportedType[i])); + cid.add_supportedType (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< char > curr ((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/CIAO/tools/Config_Handlers/CCD_Handler.h b/CIAO/tools/Config_Handlers/CCD_Handler.h new file mode 100644 index 00000000000..b3e8292f038 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/CEPE_Handler.cpp b/CIAO/tools/Config_Handlers/CEPE_Handler.cpp new file mode 100644 index 00000000000..4c93545f2c6 --- /dev/null +++ b/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/CIAO_common.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 = 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< char > portname ((src.portName)); + return ComponentExternalPortEndpoint (portname); + } + } +} diff --git a/CIAO/tools/Config_Handlers/CEPE_Handler.h b/CIAO/tools/Config_Handlers/CEPE_Handler.h new file mode 100644 index 00000000000..6a7f003fcd6 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp new file mode 100644 index 00000000000..a31c183415d --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.cpp @@ -0,0 +1,3031 @@ +/* $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 "CIAOEvents.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // EventServiceType + // + + EventServiceType::Value EventServiceType:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::EventServiceType const& a, ::CIAO::Config_Handlers::EventServiceType const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::EventServiceType const& a, ::CIAO::Config_Handlers::EventServiceType const& b) + { + return a.v_ != b.v_; + } + + EventServiceType:: + EventServiceType (EventServiceType::Value v) + : v_ (v) + { + } + + // CIAOEventsDef + // + + CIAOEventsDef:: + CIAOEventsDef () + : + ::XSCRT::Type (), + regulator__ () + { + } + + CIAOEventsDef:: + CIAOEventsDef (::CIAO::Config_Handlers::CIAOEventsDef const& s) + : + ::XSCRT::Type (), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + { + for (eventServiceConfiguration_const_iterator i (s.eventServiceConfiguration_.begin ());i != s.eventServiceConfiguration_.end ();++i) add_eventServiceConfiguration (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::CIAOEventsDef& CIAOEventsDef:: + operator= (::CIAO::Config_Handlers::CIAOEventsDef const& s) + { + eventServiceConfiguration_.clear (); + { + for (eventServiceConfiguration_const_iterator i (s.eventServiceConfiguration_.begin ());i != s.eventServiceConfiguration_.end ();++i) add_eventServiceConfiguration (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // CIAOEventsDef + // + CIAOEventsDef::eventServiceConfiguration_iterator CIAOEventsDef:: + begin_eventServiceConfiguration () + { + return eventServiceConfiguration_.begin (); + } + + CIAOEventsDef::eventServiceConfiguration_iterator CIAOEventsDef:: + end_eventServiceConfiguration () + { + return eventServiceConfiguration_.end (); + } + + CIAOEventsDef::eventServiceConfiguration_const_iterator CIAOEventsDef:: + begin_eventServiceConfiguration () const + { + return eventServiceConfiguration_.begin (); + } + + CIAOEventsDef::eventServiceConfiguration_const_iterator CIAOEventsDef:: + end_eventServiceConfiguration () const + { + return eventServiceConfiguration_.end (); + } + + void CIAOEventsDef:: + add_eventServiceConfiguration (::CIAO::Config_Handlers::EventServiceDescription const& e) + { + eventServiceConfiguration_.push_back (e); + } + + size_t CIAOEventsDef:: + count_eventServiceConfiguration(void) const + { + return eventServiceConfiguration_.size (); + } + + // CIAOEventsDef + // + bool CIAOEventsDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& CIAOEventsDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& CIAOEventsDef:: + id () + { + return *id_; + } + + void CIAOEventsDef:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // EventServiceDescription + // + + EventServiceDescription:: + EventServiceDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::CIAO::Config_Handlers::EventServiceType const& type__, + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (node__)), + type_ (new ::CIAO::Config_Handlers::EventServiceType (type__)), + svc_cfg_file_ (new ::XMLSchema::string< ACE_TCHAR > (svc_cfg_file__)), + regulator__ () + { + name_->container (this); + node_->container (this); + type_->container (this); + svc_cfg_file_->container (this); + } + + EventServiceDescription:: + EventServiceDescription (::CIAO::Config_Handlers::EventServiceDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + node_ (new ::XMLSchema::string< ACE_TCHAR > (*s.node_)), + type_ (new ::CIAO::Config_Handlers::EventServiceType (*s.type_)), + svc_cfg_file_ (new ::XMLSchema::string< ACE_TCHAR > (*s.svc_cfg_file_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + node_->container (this); + type_->container (this); + svc_cfg_file_->container (this); + { + for (filter_const_iterator i (s.filter_.begin ());i != s.filter_.end ();++i) add_filter (*i); + } + + { + for (addr_serv_const_iterator i (s.addr_serv_.begin ());i != s.addr_serv_.end ();++i) add_addr_serv (*i); + } + + { + for (udp_sender_const_iterator i (s.udp_sender_.begin ());i != s.udp_sender_.end ();++i) add_udp_sender (*i); + } + + { + for (udp_receiver_const_iterator i (s.udp_receiver_.begin ());i != s.udp_receiver_.end ();++i) add_udp_receiver (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::EventServiceDescription& EventServiceDescription:: + operator= (::CIAO::Config_Handlers::EventServiceDescription const& s) + { + name (s.name ()); + + node (s.node ()); + + type (s.type ()); + + svc_cfg_file (s.svc_cfg_file ()); + + filter_.clear (); + { + for (filter_const_iterator i (s.filter_.begin ());i != s.filter_.end ();++i) add_filter (*i); + } + + addr_serv_.clear (); + { + for (addr_serv_const_iterator i (s.addr_serv_.begin ());i != s.addr_serv_.end ();++i) add_addr_serv (*i); + } + + udp_sender_.clear (); + { + for (udp_sender_const_iterator i (s.udp_sender_.begin ());i != s.udp_sender_.end ();++i) add_udp_sender (*i); + } + + udp_receiver_.clear (); + { + for (udp_receiver_const_iterator i (s.udp_receiver_.begin ());i != s.udp_receiver_.end ();++i) add_udp_receiver (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + name () const + { + return *name_; + } + + void EventServiceDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + node () const + { + return *node_; + } + + void EventServiceDescription:: + node (::XMLSchema::string< ACE_TCHAR > const& e) + { + *node_ = e; + } + + // EventServiceDescription + // + ::CIAO::Config_Handlers::EventServiceType const& EventServiceDescription:: + type () const + { + return *type_; + } + + void EventServiceDescription:: + type (::CIAO::Config_Handlers::EventServiceType const& e) + { + *type_ = e; + } + + // EventServiceDescription + // + ::XMLSchema::string< ACE_TCHAR > const& EventServiceDescription:: + svc_cfg_file () const + { + return *svc_cfg_file_; + } + + void EventServiceDescription:: + svc_cfg_file (::XMLSchema::string< ACE_TCHAR > const& e) + { + *svc_cfg_file_ = e; + } + + // EventServiceDescription + // + EventServiceDescription::filter_iterator EventServiceDescription:: + begin_filter () + { + return filter_.begin (); + } + + EventServiceDescription::filter_iterator EventServiceDescription:: + end_filter () + { + return filter_.end (); + } + + EventServiceDescription::filter_const_iterator EventServiceDescription:: + begin_filter () const + { + return filter_.begin (); + } + + EventServiceDescription::filter_const_iterator EventServiceDescription:: + end_filter () const + { + return filter_.end (); + } + + void EventServiceDescription:: + add_filter (::CIAO::Config_Handlers::Filter const& e) + { + filter_.push_back (e); + } + + size_t EventServiceDescription:: + count_filter(void) const + { + return filter_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::addr_serv_iterator EventServiceDescription:: + begin_addr_serv () + { + return addr_serv_.begin (); + } + + EventServiceDescription::addr_serv_iterator EventServiceDescription:: + end_addr_serv () + { + return addr_serv_.end (); + } + + EventServiceDescription::addr_serv_const_iterator EventServiceDescription:: + begin_addr_serv () const + { + return addr_serv_.begin (); + } + + EventServiceDescription::addr_serv_const_iterator EventServiceDescription:: + end_addr_serv () const + { + return addr_serv_.end (); + } + + void EventServiceDescription:: + add_addr_serv (::CIAO::Config_Handlers::AddressServerDescription const& e) + { + addr_serv_.push_back (e); + } + + size_t EventServiceDescription:: + count_addr_serv(void) const + { + return addr_serv_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::udp_sender_iterator EventServiceDescription:: + begin_udp_sender () + { + return udp_sender_.begin (); + } + + EventServiceDescription::udp_sender_iterator EventServiceDescription:: + end_udp_sender () + { + return udp_sender_.end (); + } + + EventServiceDescription::udp_sender_const_iterator EventServiceDescription:: + begin_udp_sender () const + { + return udp_sender_.begin (); + } + + EventServiceDescription::udp_sender_const_iterator EventServiceDescription:: + end_udp_sender () const + { + return udp_sender_.end (); + } + + void EventServiceDescription:: + add_udp_sender (::CIAO::Config_Handlers::UDPSenderDescription const& e) + { + udp_sender_.push_back (e); + } + + size_t EventServiceDescription:: + count_udp_sender(void) const + { + return udp_sender_.size (); + } + + // EventServiceDescription + // + EventServiceDescription::udp_receiver_iterator EventServiceDescription:: + begin_udp_receiver () + { + return udp_receiver_.begin (); + } + + EventServiceDescription::udp_receiver_iterator EventServiceDescription:: + end_udp_receiver () + { + return udp_receiver_.end (); + } + + EventServiceDescription::udp_receiver_const_iterator EventServiceDescription:: + begin_udp_receiver () const + { + return udp_receiver_.begin (); + } + + EventServiceDescription::udp_receiver_const_iterator EventServiceDescription:: + end_udp_receiver () const + { + return udp_receiver_.end (); + } + + void EventServiceDescription:: + add_udp_receiver (::CIAO::Config_Handlers::UDPReceiverDescription const& e) + { + udp_receiver_.push_back (e); + } + + size_t EventServiceDescription:: + count_udp_receiver(void) const + { + return udp_receiver_.size (); + } + + // EventServiceDescription + // + bool EventServiceDescription:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& EventServiceDescription:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& EventServiceDescription:: + id () + { + return *id_; + } + + void EventServiceDescription:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // FilterType + // + + FilterType::Value FilterType:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::FilterType const& a, ::CIAO::Config_Handlers::FilterType const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::FilterType const& a, ::CIAO::Config_Handlers::FilterType const& b) + { + return a.v_ != b.v_; + } + + FilterType:: + FilterType (FilterType::Value v) + : v_ (v) + { + } + + // Filter + // + + Filter:: + Filter (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::FilterType const& type__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + type_ (new ::CIAO::Config_Handlers::FilterType (type__)), + regulator__ () + { + name_->container (this); + type_->container (this); + } + + Filter:: + Filter (::CIAO::Config_Handlers::Filter const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + type_ (new ::CIAO::Config_Handlers::FilterType (*s.type_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + name_->container (this); + type_->container (this); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::Filter& Filter:: + operator= (::CIAO::Config_Handlers::Filter const& s) + { + name (s.name ()); + + type (s.type ()); + + source_.clear (); + { + for (source_const_iterator i (s.source_.begin ());i != s.source_.end ();++i) add_source (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // Filter + // + ::XMLSchema::string< ACE_TCHAR > const& Filter:: + name () const + { + return *name_; + } + + void Filter:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // Filter + // + ::CIAO::Config_Handlers::FilterType const& Filter:: + type () const + { + return *type_; + } + + void Filter:: + type (::CIAO::Config_Handlers::FilterType const& e) + { + *type_ = e; + } + + // Filter + // + Filter::source_iterator Filter:: + begin_source () + { + return source_.begin (); + } + + Filter::source_iterator Filter:: + end_source () + { + return source_.end (); + } + + Filter::source_const_iterator Filter:: + begin_source () const + { + return source_.begin (); + } + + Filter::source_const_iterator Filter:: + end_source () const + { + return source_.end (); + } + + void Filter:: + add_source (::XMLSchema::string< ACE_TCHAR > const& e) + { + source_.push_back (e); + } + + size_t Filter:: + count_source(void) const + { + return source_.size (); + } + + // Filter + // + bool Filter:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& Filter:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& Filter:: + id () + { + return *id_; + } + + void Filter:: + id (::XMLSchema::ID< ACE_TCHAR > const& e) + { + if (id_.get ()) + { + *id_ = e; + } + + else + { + id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (new ::XMLSchema::ID< ACE_TCHAR > (e)); + id_->container (this); + } + } + + + // AddressServerDescription + // + + AddressServerDescription:: + AddressServerDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::unsignedShort const& port__, + ::XMLSchema::string< ACE_TCHAR > const& address__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + port_ (new ::XMLSchema::unsignedShort (port__)), + address_ (new ::XMLSchema::string< ACE_TCHAR > (address__)), + regulator__ () + { + name_->container (this); + port_->container (this); + address_->container (this); + } + + AddressServerDescription:: + AddressServerDescription (::CIAO::Config_Handlers::AddressServerDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + port_ (new ::XMLSchema::unsignedShort (*s.port_)), + address_ (new ::XMLSchema::string< ACE_TCHAR > (*s.address_)), + regulator__ () + { + name_->container (this); + port_->container (this); + address_->container (this); + } + + ::CIAO::Config_Handlers::AddressServerDescription& AddressServerDescription:: + operator= (::CIAO::Config_Handlers::AddressServerDescription const& s) + { + name (s.name ()); + + port (s.port ()); + + address (s.address ()); + + return *this; + } + + + // AddressServerDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AddressServerDescription:: + name () const + { + return *name_; + } + + void AddressServerDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // AddressServerDescription + // + ::XMLSchema::unsignedShort const& AddressServerDescription:: + port () const + { + return *port_; + } + + void AddressServerDescription:: + port (::XMLSchema::unsignedShort const& e) + { + *port_ = e; + } + + // AddressServerDescription + // + ::XMLSchema::string< ACE_TCHAR > const& AddressServerDescription:: + address () const + { + return *address_; + } + + void AddressServerDescription:: + address (::XMLSchema::string< ACE_TCHAR > const& e) + { + *address_ = e; + } + + + // UDPSenderDescription + // + + UDPSenderDescription:: + UDPSenderDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + addr_serv_id_ (new ::XMLSchema::string< ACE_TCHAR > (addr_serv_id__)), + regulator__ () + { + name_->container (this); + addr_serv_id_->container (this); + } + + UDPSenderDescription:: + UDPSenderDescription (::CIAO::Config_Handlers::UDPSenderDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + addr_serv_id_ (new ::XMLSchema::string< ACE_TCHAR > (*s.addr_serv_id_)), + regulator__ () + { + name_->container (this); + addr_serv_id_->container (this); + } + + ::CIAO::Config_Handlers::UDPSenderDescription& UDPSenderDescription:: + operator= (::CIAO::Config_Handlers::UDPSenderDescription const& s) + { + name (s.name ()); + + addr_serv_id (s.addr_serv_id ()); + + return *this; + } + + + // UDPSenderDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPSenderDescription:: + name () const + { + return *name_; + } + + void UDPSenderDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // UDPSenderDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPSenderDescription:: + addr_serv_id () const + { + return *addr_serv_id_; + } + + void UDPSenderDescription:: + addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& e) + { + *addr_serv_id_ = e; + } + + + // UDPReceiverDescription + // + + UDPReceiverDescription:: + UDPReceiverDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& is_multicast__, + ::XMLSchema::unsignedShort const& listen_port__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + is_multicast_ (new ::XMLSchema::boolean (is_multicast__)), + listen_port_ (new ::XMLSchema::unsignedShort (listen_port__)), + regulator__ () + { + name_->container (this); + is_multicast_->container (this); + listen_port_->container (this); + } + + UDPReceiverDescription:: + UDPReceiverDescription (::CIAO::Config_Handlers::UDPReceiverDescription const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + addr_serv_id_ (s.addr_serv_id_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.addr_serv_id_) : 0), + is_multicast_ (new ::XMLSchema::boolean (*s.is_multicast_)), + listen_port_ (new ::XMLSchema::unsignedShort (*s.listen_port_)), + regulator__ () + { + name_->container (this); + if (addr_serv_id_.get ()) addr_serv_id_->container (this); + is_multicast_->container (this); + listen_port_->container (this); + } + + ::CIAO::Config_Handlers::UDPReceiverDescription& UDPReceiverDescription:: + operator= (::CIAO::Config_Handlers::UDPReceiverDescription const& s) + { + name (s.name ()); + + if (s.addr_serv_id_.get ()) addr_serv_id (*(s.addr_serv_id_)); + else addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + is_multicast (s.is_multicast ()); + + listen_port (s.listen_port ()); + + return *this; + } + + + // UDPReceiverDescription + // + ::XMLSchema::string< ACE_TCHAR > const& UDPReceiverDescription:: + name () const + { + return *name_; + } + + void UDPReceiverDescription:: + name (::XMLSchema::string< ACE_TCHAR > const& e) + { + *name_ = e; + } + + // UDPReceiverDescription + // + bool UDPReceiverDescription:: + addr_serv_id_p () const + { + return addr_serv_id_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& UDPReceiverDescription:: + addr_serv_id () const + { + return *addr_serv_id_; + } + + void UDPReceiverDescription:: + addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (addr_serv_id_.get ()) + { + *addr_serv_id_ = e; + } + + else + { + addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + addr_serv_id_->container (this); + } + } + + // UDPReceiverDescription + // + ::XMLSchema::boolean const& UDPReceiverDescription:: + is_multicast () const + { + return *is_multicast_; + } + + void UDPReceiverDescription:: + is_multicast (::XMLSchema::boolean const& e) + { + *is_multicast_ = e; + } + + // UDPReceiverDescription + // + ::XMLSchema::unsignedShort const& UDPReceiverDescription:: + listen_port () const + { + return *listen_port_; + } + + void UDPReceiverDescription:: + listen_port (::XMLSchema::unsignedShort const& e) + { + *listen_port_ = e; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // EventServiceType + // + + EventServiceType:: + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "EC") v_ = EC_l; + else if (v == "RTEC") v_ = RTEC_l; + else if (v == "NOTIFY") v_ = NOTIFY_l; + else if (v == "RTNOTIFY") v_ = RTNOTIFY_l; + else + { + } + } + + EventServiceType:: + EventServiceType (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "EC") v_ = EC_l; + else if (v == "RTEC") v_ = RTEC_l; + else if (v == "NOTIFY") v_ = NOTIFY_l; + else if (v == "RTNOTIFY") v_ = RTNOTIFY_l; + else + { + } + } + + EventServiceType const EventServiceType::EC (EventServiceType::EC_l); + EventServiceType const EventServiceType::RTEC (EventServiceType::RTEC_l); + EventServiceType const EventServiceType::NOTIFY (EventServiceType::NOTIFY_l); + EventServiceType const EventServiceType::RTNOTIFY (EventServiceType::RTNOTIFY_l); + + // CIAOEventsDef + // + + CIAOEventsDef:: + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "eventServiceConfiguration") + { + ::CIAO::Config_Handlers::EventServiceDescription t (e); + add_eventServiceConfiguration (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // EventServiceDescription + // + + EventServiceDescription:: + EventServiceDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + node_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::EventServiceType > (new ::CIAO::Config_Handlers::EventServiceType (e)); + type_->container (this); + } + + else if (n == "svc_cfg_file") + { + svc_cfg_file_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + svc_cfg_file_->container (this); + } + + else if (n == "filter") + { + ::CIAO::Config_Handlers::Filter t (e); + add_filter (t); + } + + else if (n == "addr_serv") + { + ::CIAO::Config_Handlers::AddressServerDescription t (e); + add_addr_serv (t); + } + + else if (n == "udp_sender") + { + ::CIAO::Config_Handlers::UDPSenderDescription t (e); + add_udp_sender (t); + } + + else if (n == "udp_receiver") + { + ::CIAO::Config_Handlers::UDPReceiverDescription t (e); + add_udp_receiver (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // FilterType + // + + FilterType:: + FilterType (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "CONJUNCTION") v_ = CONJUNCTION_l; + else if (v == "DISJUNCTION") v_ = DISJUNCTION_l; + else if (v == "LOGICAL_AND") v_ = LOGICAL_AND_l; + else if (v == "NEGATE") v_ = NEGATE_l; + else + { + } + } + + FilterType:: + FilterType (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "CONJUNCTION") v_ = CONJUNCTION_l; + else if (v == "DISJUNCTION") v_ = DISJUNCTION_l; + else if (v == "LOGICAL_AND") v_ = LOGICAL_AND_l; + else if (v == "NEGATE") v_ = NEGATE_l; + else + { + } + } + + FilterType const FilterType::CONJUNCTION (FilterType::CONJUNCTION_l); + FilterType const FilterType::DISJUNCTION (FilterType::DISJUNCTION_l); + FilterType const FilterType::LOGICAL_AND (FilterType::LOGICAL_AND_l); + FilterType const FilterType::NEGATE (FilterType::NEGATE_l); + + // Filter + // + + Filter:: + Filter (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "type") + { + type_ = ::std::auto_ptr< ::CIAO::Config_Handlers::FilterType > (new ::CIAO::Config_Handlers::FilterType (e)); + type_->container (this); + } + + else if (n == "source") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_source (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // AddressServerDescription + // + + AddressServerDescription:: + AddressServerDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "port") + { + port_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (new ::XMLSchema::unsignedShort (e)); + port_->container (this); + } + + else if (n == "address") + { + address_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + address_->container (this); + } + + else + { + } + } + } + + // UDPSenderDescription + // + + UDPSenderDescription:: + UDPSenderDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "addr_serv_id") + { + addr_serv_id_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + addr_serv_id_->container (this); + } + + else + { + } + } + } + + // UDPReceiverDescription + // + + UDPReceiverDescription:: + UDPReceiverDescription (::XSCRT::XML::Element< ACE_TCHAR > const& e) + :Base (e), regulator__ () + { + + ::XSCRT::Parser< ACE_TCHAR > p (e); + + while (p.more_elements ()) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (p.next_element ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (e.name ())); + + if (n == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "addr_serv_id") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + addr_serv_id (t); + } + + else if (n == "is_multicast") + { + is_multicast_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + is_multicast_->container (this); + } + + else if (n == "listen_port") + { + listen_port_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (new ::XMLSchema::unsignedShort (e)); + listen_port_->container (this); + } + + else + { + } + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + ::CIAO::Config_Handlers::CIAOEventsDef + CIAOEvents (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "CIAOEvents") + { + ::CIAO::Config_Handlers::CIAOEventsDef r (e); + return r; + } + + else + { + throw 1; + } + } + } +} + +#include "XMLSchema/TypeInfo.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace + { + ::XMLSchema::TypeInfoInitializer < ACE_TCHAR > XMLSchemaTypeInfoInitializer_ (::XSCRT::extended_type_info_map ()); + + struct EventServiceTypeTypeInfoInitializer + { + EventServiceTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (EventServiceType)); + ::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)); + } + }; + + EventServiceTypeTypeInfoInitializer EventServiceTypeTypeInfoInitializer_; + + struct CIAOEventsDefTypeInfoInitializer + { + CIAOEventsDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (CIAOEventsDef)); + ::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)); + } + }; + + CIAOEventsDefTypeInfoInitializer CIAOEventsDefTypeInfoInitializer_; + + struct EventServiceDescriptionTypeInfoInitializer + { + EventServiceDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (EventServiceDescription)); + ::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)); + } + }; + + EventServiceDescriptionTypeInfoInitializer EventServiceDescriptionTypeInfoInitializer_; + + struct FilterTypeTypeInfoInitializer + { + FilterTypeTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (FilterType)); + ::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)); + } + }; + + FilterTypeTypeInfoInitializer FilterTypeTypeInfoInitializer_; + + struct FilterTypeInfoInitializer + { + FilterTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (Filter)); + ::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)); + } + }; + + FilterTypeInfoInitializer FilterTypeInfoInitializer_; + + struct AddressServerDescriptionTypeInfoInitializer + { + AddressServerDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (AddressServerDescription)); + ::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)); + } + }; + + AddressServerDescriptionTypeInfoInitializer AddressServerDescriptionTypeInfoInitializer_; + + struct UDPSenderDescriptionTypeInfoInitializer + { + UDPSenderDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (UDPSenderDescription)); + ::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)); + } + }; + + UDPSenderDescriptionTypeInfoInitializer UDPSenderDescriptionTypeInfoInitializer_; + + struct UDPReceiverDescriptionTypeInfoInitializer + { + UDPReceiverDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (UDPReceiverDescription)); + ::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)); + } + }; + + UDPReceiverDescriptionTypeInfoInitializer UDPReceiverDescriptionTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // CIAOEventsDef + // + // + + void CIAOEventsDef:: + traverse (Type& o) + { + pre (o); + eventServiceConfiguration (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void CIAOEventsDef:: + traverse (Type const& o) + { + pre (o); + eventServiceConfiguration (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void CIAOEventsDef:: + pre (Type&) + { + } + + void CIAOEventsDef:: + pre (Type const&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration (Type& o) + { + // VC6 anathema strikes again + // + CIAOEventsDef::Type::eventServiceConfiguration_iterator b (o.begin_eventServiceConfiguration()), e (o.end_eventServiceConfiguration()); + + if (b != e) + { + eventServiceConfiguration_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) eventServiceConfiguration_next (o); + } + + eventServiceConfiguration_post (o); + } + } + + void CIAOEventsDef:: + eventServiceConfiguration (Type const& o) + { + // VC6 anathema strikes again + // + CIAOEventsDef::Type::eventServiceConfiguration_const_iterator b (o.begin_eventServiceConfiguration()), e (o.end_eventServiceConfiguration()); + + if (b != e) + { + eventServiceConfiguration_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) eventServiceConfiguration_next (o); + } + + eventServiceConfiguration_post (o); + } + } + + void CIAOEventsDef:: + eventServiceConfiguration_pre (Type&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration_pre (Type const&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration_next (Type&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration_next (Type const&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration_post (Type&) + { + } + + void CIAOEventsDef:: + eventServiceConfiguration_post (Type const&) + { + } + + void CIAOEventsDef:: + id (Type& o) + { + dispatch (o.id ()); + } + + void CIAOEventsDef:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void CIAOEventsDef:: + id_none (Type&) + { + } + + void CIAOEventsDef:: + id_none (Type const&) + { + } + + void CIAOEventsDef:: + post (Type&) + { + } + + void CIAOEventsDef:: + post (Type const&) + { + } + + // EventServiceDescription + // + // + + void EventServiceDescription:: + traverse (Type& o) + { + pre (o); + name (o); + node (o); + type (o); + svc_cfg_file (o); + filter (o); + addr_serv (o); + udp_sender (o); + udp_receiver (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void EventServiceDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + node (o); + type (o); + svc_cfg_file (o); + filter (o); + addr_serv (o); + udp_sender (o); + udp_receiver (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void EventServiceDescription:: + pre (Type&) + { + } + + void EventServiceDescription:: + pre (Type const&) + { + } + + void EventServiceDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void EventServiceDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void EventServiceDescription:: + node (Type& o) + { + dispatch (o.node ()); + } + + void EventServiceDescription:: + node (Type const& o) + { + dispatch (o.node ()); + } + + void EventServiceDescription:: + type (Type& o) + { + dispatch (o.type ()); + } + + void EventServiceDescription:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void EventServiceDescription:: + svc_cfg_file (Type& o) + { + dispatch (o.svc_cfg_file ()); + } + + void EventServiceDescription:: + svc_cfg_file (Type const& o) + { + dispatch (o.svc_cfg_file ()); + } + + void EventServiceDescription:: + filter (Type& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::filter_iterator b (o.begin_filter()), e (o.end_filter()); + + if (b != e) + { + filter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) filter_next (o); + } + + filter_post (o); + } + + else filter_none (o); + } + + void EventServiceDescription:: + filter (Type const& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::filter_const_iterator b (o.begin_filter()), e (o.end_filter()); + + if (b != e) + { + filter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) filter_next (o); + } + + filter_post (o); + } + + else filter_none (o); + } + + void EventServiceDescription:: + filter_pre (Type&) + { + } + + void EventServiceDescription:: + filter_pre (Type const&) + { + } + + void EventServiceDescription:: + filter_next (Type&) + { + } + + void EventServiceDescription:: + filter_next (Type const&) + { + } + + void EventServiceDescription:: + filter_post (Type&) + { + } + + void EventServiceDescription:: + filter_post (Type const&) + { + } + + void EventServiceDescription:: + filter_none (Type&) + { + } + + void EventServiceDescription:: + filter_none (Type const&) + { + } + + void EventServiceDescription:: + addr_serv (Type& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::addr_serv_iterator b (o.begin_addr_serv()), e (o.end_addr_serv()); + + if (b != e) + { + addr_serv_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) addr_serv_next (o); + } + + addr_serv_post (o); + } + + else addr_serv_none (o); + } + + void EventServiceDescription:: + addr_serv (Type const& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::addr_serv_const_iterator b (o.begin_addr_serv()), e (o.end_addr_serv()); + + if (b != e) + { + addr_serv_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) addr_serv_next (o); + } + + addr_serv_post (o); + } + + else addr_serv_none (o); + } + + void EventServiceDescription:: + addr_serv_pre (Type&) + { + } + + void EventServiceDescription:: + addr_serv_pre (Type const&) + { + } + + void EventServiceDescription:: + addr_serv_next (Type&) + { + } + + void EventServiceDescription:: + addr_serv_next (Type const&) + { + } + + void EventServiceDescription:: + addr_serv_post (Type&) + { + } + + void EventServiceDescription:: + addr_serv_post (Type const&) + { + } + + void EventServiceDescription:: + addr_serv_none (Type&) + { + } + + void EventServiceDescription:: + addr_serv_none (Type const&) + { + } + + void EventServiceDescription:: + udp_sender (Type& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::udp_sender_iterator b (o.begin_udp_sender()), e (o.end_udp_sender()); + + if (b != e) + { + udp_sender_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) udp_sender_next (o); + } + + udp_sender_post (o); + } + + else udp_sender_none (o); + } + + void EventServiceDescription:: + udp_sender (Type const& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::udp_sender_const_iterator b (o.begin_udp_sender()), e (o.end_udp_sender()); + + if (b != e) + { + udp_sender_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) udp_sender_next (o); + } + + udp_sender_post (o); + } + + else udp_sender_none (o); + } + + void EventServiceDescription:: + udp_sender_pre (Type&) + { + } + + void EventServiceDescription:: + udp_sender_pre (Type const&) + { + } + + void EventServiceDescription:: + udp_sender_next (Type&) + { + } + + void EventServiceDescription:: + udp_sender_next (Type const&) + { + } + + void EventServiceDescription:: + udp_sender_post (Type&) + { + } + + void EventServiceDescription:: + udp_sender_post (Type const&) + { + } + + void EventServiceDescription:: + udp_sender_none (Type&) + { + } + + void EventServiceDescription:: + udp_sender_none (Type const&) + { + } + + void EventServiceDescription:: + udp_receiver (Type& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::udp_receiver_iterator b (o.begin_udp_receiver()), e (o.end_udp_receiver()); + + if (b != e) + { + udp_receiver_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) udp_receiver_next (o); + } + + udp_receiver_post (o); + } + + else udp_receiver_none (o); + } + + void EventServiceDescription:: + udp_receiver (Type const& o) + { + // VC6 anathema strikes again + // + EventServiceDescription::Type::udp_receiver_const_iterator b (o.begin_udp_receiver()), e (o.end_udp_receiver()); + + if (b != e) + { + udp_receiver_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) udp_receiver_next (o); + } + + udp_receiver_post (o); + } + + else udp_receiver_none (o); + } + + void EventServiceDescription:: + udp_receiver_pre (Type&) + { + } + + void EventServiceDescription:: + udp_receiver_pre (Type const&) + { + } + + void EventServiceDescription:: + udp_receiver_next (Type&) + { + } + + void EventServiceDescription:: + udp_receiver_next (Type const&) + { + } + + void EventServiceDescription:: + udp_receiver_post (Type&) + { + } + + void EventServiceDescription:: + udp_receiver_post (Type const&) + { + } + + void EventServiceDescription:: + udp_receiver_none (Type&) + { + } + + void EventServiceDescription:: + udp_receiver_none (Type const&) + { + } + + void EventServiceDescription:: + id (Type& o) + { + dispatch (o.id ()); + } + + void EventServiceDescription:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void EventServiceDescription:: + id_none (Type&) + { + } + + void EventServiceDescription:: + id_none (Type const&) + { + } + + void EventServiceDescription:: + post (Type&) + { + } + + void EventServiceDescription:: + post (Type const&) + { + } + + // Filter + // + // + + void Filter:: + traverse (Type& o) + { + pre (o); + name (o); + type (o); + source (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void Filter:: + traverse (Type const& o) + { + pre (o); + name (o); + type (o); + source (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void Filter:: + pre (Type&) + { + } + + void Filter:: + pre (Type const&) + { + } + + void Filter:: + name (Type& o) + { + dispatch (o.name ()); + } + + void Filter:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void Filter:: + type (Type& o) + { + dispatch (o.type ()); + } + + void Filter:: + type (Type const& o) + { + dispatch (o.type ()); + } + + void Filter:: + source (Type& o) + { + // VC6 anathema strikes again + // + Filter::Type::source_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void Filter:: + source (Type const& o) + { + // VC6 anathema strikes again + // + Filter::Type::source_const_iterator b (o.begin_source()), e (o.end_source()); + + if (b != e) + { + source_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) source_next (o); + } + + source_post (o); + } + } + + void Filter:: + source_pre (Type&) + { + } + + void Filter:: + source_pre (Type const&) + { + } + + void Filter:: + source_next (Type&) + { + } + + void Filter:: + source_next (Type const&) + { + } + + void Filter:: + source_post (Type&) + { + } + + void Filter:: + source_post (Type const&) + { + } + + void Filter:: + id (Type& o) + { + dispatch (o.id ()); + } + + void Filter:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void Filter:: + id_none (Type&) + { + } + + void Filter:: + id_none (Type const&) + { + } + + void Filter:: + post (Type&) + { + } + + void Filter:: + post (Type const&) + { + } + + // AddressServerDescription + // + // + + void AddressServerDescription:: + traverse (Type& o) + { + pre (o); + name (o); + port (o); + address (o); + post (o); + } + + void AddressServerDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + port (o); + address (o); + post (o); + } + + void AddressServerDescription:: + pre (Type&) + { + } + + void AddressServerDescription:: + pre (Type const&) + { + } + + void AddressServerDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void AddressServerDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void AddressServerDescription:: + port (Type& o) + { + dispatch (o.port ()); + } + + void AddressServerDescription:: + port (Type const& o) + { + dispatch (o.port ()); + } + + void AddressServerDescription:: + address (Type& o) + { + dispatch (o.address ()); + } + + void AddressServerDescription:: + address (Type const& o) + { + dispatch (o.address ()); + } + + void AddressServerDescription:: + post (Type&) + { + } + + void AddressServerDescription:: + post (Type const&) + { + } + + // UDPSenderDescription + // + // + + void UDPSenderDescription:: + traverse (Type& o) + { + pre (o); + name (o); + addr_serv_id (o); + post (o); + } + + void UDPSenderDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + addr_serv_id (o); + post (o); + } + + void UDPSenderDescription:: + pre (Type&) + { + } + + void UDPSenderDescription:: + pre (Type const&) + { + } + + void UDPSenderDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void UDPSenderDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void UDPSenderDescription:: + addr_serv_id (Type& o) + { + dispatch (o.addr_serv_id ()); + } + + void UDPSenderDescription:: + addr_serv_id (Type const& o) + { + dispatch (o.addr_serv_id ()); + } + + void UDPSenderDescription:: + post (Type&) + { + } + + void UDPSenderDescription:: + post (Type const&) + { + } + + // UDPReceiverDescription + // + // + + void UDPReceiverDescription:: + traverse (Type& o) + { + pre (o); + name (o); + if (o.addr_serv_id_p ()) addr_serv_id (o); + else addr_serv_id_none (o); + is_multicast (o); + listen_port (o); + post (o); + } + + void UDPReceiverDescription:: + traverse (Type const& o) + { + pre (o); + name (o); + if (o.addr_serv_id_p ()) addr_serv_id (o); + else addr_serv_id_none (o); + is_multicast (o); + listen_port (o); + post (o); + } + + void UDPReceiverDescription:: + pre (Type&) + { + } + + void UDPReceiverDescription:: + pre (Type const&) + { + } + + void UDPReceiverDescription:: + name (Type& o) + { + dispatch (o.name ()); + } + + void UDPReceiverDescription:: + name (Type const& o) + { + dispatch (o.name ()); + } + + void UDPReceiverDescription:: + addr_serv_id (Type& o) + { + dispatch (o.addr_serv_id ()); + } + + void UDPReceiverDescription:: + addr_serv_id (Type const& o) + { + dispatch (o.addr_serv_id ()); + } + + void UDPReceiverDescription:: + addr_serv_id_none (Type&) + { + } + + void UDPReceiverDescription:: + addr_serv_id_none (Type const&) + { + } + + void UDPReceiverDescription:: + is_multicast (Type& o) + { + dispatch (o.is_multicast ()); + } + + void UDPReceiverDescription:: + is_multicast (Type const& o) + { + dispatch (o.is_multicast ()); + } + + void UDPReceiverDescription:: + listen_port (Type& o) + { + dispatch (o.listen_port ()); + } + + void UDPReceiverDescription:: + listen_port (Type const& o) + { + dispatch (o.listen_port ()); + } + + void UDPReceiverDescription:: + post (Type&) + { + } + + void UDPReceiverDescription:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // EventServiceType + // + // + + EventServiceType:: + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + EventServiceType:: + EventServiceType () + { + } + + void EventServiceType:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::EventServiceType::EC) s = "EC"; + else if (o == ::CIAO::Config_Handlers::EventServiceType::RTEC) s = "RTEC"; + else if (o == ::CIAO::Config_Handlers::EventServiceType::NOTIFY) s = "NOTIFY"; + else if (o == ::CIAO::Config_Handlers::EventServiceType::RTNOTIFY) s = "RTNOTIFY"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // CIAOEventsDef + // + // + + CIAOEventsDef:: + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + CIAOEventsDef:: + CIAOEventsDef () + { + } + + void CIAOEventsDef:: + traverse (Type const& o) + { + Traversal::CIAOEventsDef::traverse (o); + } + + void CIAOEventsDef:: + eventServiceConfiguration_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("eventServiceConfiguration", top_ ())); + } + + void CIAOEventsDef:: + eventServiceConfiguration_next (Type const& o) + { + eventServiceConfiguration_post (o); + eventServiceConfiguration_pre (o); + } + + void CIAOEventsDef:: + eventServiceConfiguration_post (Type const&) + { + pop_ (); + } + + void CIAOEventsDef:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::CIAOEventsDef::id (o); + attr_ (0); + } + + // EventServiceDescription + // + // + + EventServiceDescription:: + EventServiceDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + EventServiceDescription:: + EventServiceDescription () + { + } + + void EventServiceDescription:: + traverse (Type const& o) + { + Traversal::EventServiceDescription::traverse (o); + } + + void EventServiceDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::EventServiceDescription::name (o); + pop_ (); + } + + void EventServiceDescription:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::EventServiceDescription::node (o); + pop_ (); + } + + void EventServiceDescription:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::EventServiceDescription::type (o); + pop_ (); + } + + void EventServiceDescription:: + svc_cfg_file (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("svc_cfg_file", top_ ())); + Traversal::EventServiceDescription::svc_cfg_file (o); + pop_ (); + } + + void EventServiceDescription:: + filter_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("filter", top_ ())); + } + + void EventServiceDescription:: + filter_next (Type const& o) + { + filter_post (o); + filter_pre (o); + } + + void EventServiceDescription:: + filter_post (Type const&) + { + pop_ (); + } + + void EventServiceDescription:: + addr_serv_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("addr_serv", top_ ())); + } + + void EventServiceDescription:: + addr_serv_next (Type const& o) + { + addr_serv_post (o); + addr_serv_pre (o); + } + + void EventServiceDescription:: + addr_serv_post (Type const&) + { + pop_ (); + } + + void EventServiceDescription:: + udp_sender_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("udp_sender", top_ ())); + } + + void EventServiceDescription:: + udp_sender_next (Type const& o) + { + udp_sender_post (o); + udp_sender_pre (o); + } + + void EventServiceDescription:: + udp_sender_post (Type const&) + { + pop_ (); + } + + void EventServiceDescription:: + udp_receiver_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("udp_receiver", top_ ())); + } + + void EventServiceDescription:: + udp_receiver_next (Type const& o) + { + udp_receiver_post (o); + udp_receiver_pre (o); + } + + void EventServiceDescription:: + udp_receiver_post (Type const&) + { + pop_ (); + } + + void EventServiceDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::EventServiceDescription::id (o); + attr_ (0); + } + + // FilterType + // + // + + FilterType:: + FilterType (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + FilterType:: + FilterType () + { + } + + void FilterType:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::FilterType::CONJUNCTION) s = "CONJUNCTION"; + else if (o == ::CIAO::Config_Handlers::FilterType::DISJUNCTION) s = "DISJUNCTION"; + else if (o == ::CIAO::Config_Handlers::FilterType::LOGICAL_AND) s = "LOGICAL_AND"; + else if (o == ::CIAO::Config_Handlers::FilterType::NEGATE) s = "NEGATE"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // Filter + // + // + + Filter:: + Filter (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + Filter:: + Filter () + { + } + + void Filter:: + traverse (Type const& o) + { + Traversal::Filter::traverse (o); + } + + void Filter:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::Filter::name (o); + pop_ (); + } + + void Filter:: + type (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("type", top_ ())); + Traversal::Filter::type (o); + pop_ (); + } + + void Filter:: + source_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("source", top_ ())); + } + + void Filter:: + source_next (Type const& o) + { + source_post (o); + source_pre (o); + } + + void Filter:: + source_post (Type const&) + { + pop_ (); + } + + void Filter:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::Filter::id (o); + attr_ (0); + } + + // AddressServerDescription + // + // + + AddressServerDescription:: + AddressServerDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + AddressServerDescription:: + AddressServerDescription () + { + } + + void AddressServerDescription:: + traverse (Type const& o) + { + Traversal::AddressServerDescription::traverse (o); + } + + void AddressServerDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::AddressServerDescription::name (o); + pop_ (); + } + + void AddressServerDescription:: + port (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("port", top_ ())); + Traversal::AddressServerDescription::port (o); + pop_ (); + } + + void AddressServerDescription:: + address (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("address", top_ ())); + Traversal::AddressServerDescription::address (o); + pop_ (); + } + + // UDPSenderDescription + // + // + + UDPSenderDescription:: + UDPSenderDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + UDPSenderDescription:: + UDPSenderDescription () + { + } + + void UDPSenderDescription:: + traverse (Type const& o) + { + Traversal::UDPSenderDescription::traverse (o); + } + + void UDPSenderDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::UDPSenderDescription::name (o); + pop_ (); + } + + void UDPSenderDescription:: + addr_serv_id (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("addr_serv_id", top_ ())); + Traversal::UDPSenderDescription::addr_serv_id (o); + pop_ (); + } + + // UDPReceiverDescription + // + // + + UDPReceiverDescription:: + UDPReceiverDescription (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + UDPReceiverDescription:: + UDPReceiverDescription () + { + } + + void UDPReceiverDescription:: + traverse (Type const& o) + { + Traversal::UDPReceiverDescription::traverse (o); + } + + void UDPReceiverDescription:: + name (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("name", top_ ())); + Traversal::UDPReceiverDescription::name (o); + pop_ (); + } + + void UDPReceiverDescription:: + addr_serv_id (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("addr_serv_id", top_ ())); + Traversal::UDPReceiverDescription::addr_serv_id (o); + pop_ (); + } + + void UDPReceiverDescription:: + is_multicast (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("is_multicast", top_ ())); + Traversal::UDPReceiverDescription::is_multicast (o); + pop_ (); + } + + void UDPReceiverDescription:: + listen_port (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("listen_port", top_ ())); + Traversal::UDPReceiverDescription::listen_port (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + void + CIAOEvents (::CIAO::Config_Handlers::CIAOEventsDef const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "CIAOEvents") + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::CIAOEventsDef, + virtual ::CIAO::Config_Handlers::Writer::EventServiceDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::EventServiceType, + virtual ::CIAO::Config_Handlers::Writer::Filter, + virtual ::CIAO::Config_Handlers::Writer::FilterType, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::AddressServerDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedShort, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::UDPSenderDescription, + virtual ::CIAO::Config_Handlers::Writer::UDPReceiverDescription, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, 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/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp new file mode 100644 index 00000000000..96eb968efca --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents.hpp @@ -0,0 +1,1532 @@ +/* $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 CIAOEVENTS_HPP +#define CIAOEVENTS_HPP + +#include "CIAO_Events_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class EventServiceType; + class CIAOEventsDef; + class EventServiceDescription; + class FilterType; + class Filter; + class AddressServerDescription; + class UDPSenderDescription; + class UDPReceiverDescription; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class CIAO_Events_Handlers_Export EventServiceType : public ::XSCRT::Type + { + public: + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR > const&); + EventServiceType (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static EventServiceType const EC; + static EventServiceType const RTEC; + static EventServiceType const NOTIFY; + static EventServiceType const RTNOTIFY; + + enum Value + { + EC_l, RTEC_l, NOTIFY_l, RTNOTIFY_l + }; + + + Value + integral () const; + + friend bool CIAO_Events_Handlers_Export + operator== (EventServiceType const& a, EventServiceType const& b); + + friend bool CIAO_Events_Handlers_Export + operator!= (EventServiceType const& a, EventServiceType const& b); + + private: + EventServiceType (Value v); + + Value v_; + }; + + bool CIAO_Events_Handlers_Export operator== (EventServiceType const &a, EventServiceType const &b); + + bool CIAO_Events_Handlers_Export operator!= (EventServiceType const &a, EventServiceType const &b); + + + class CIAO_Events_Handlers_Export CIAOEventsDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // eventServiceConfiguration + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::EventServiceDescription >::iterator eventServiceConfiguration_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::EventServiceDescription >::const_iterator eventServiceConfiguration_const_iterator; + eventServiceConfiguration_iterator begin_eventServiceConfiguration (); + eventServiceConfiguration_iterator end_eventServiceConfiguration (); + eventServiceConfiguration_const_iterator begin_eventServiceConfiguration () const; + eventServiceConfiguration_const_iterator end_eventServiceConfiguration () const; + void add_eventServiceConfiguration (::CIAO::Config_Handlers::EventServiceDescription const& ); + size_t count_eventServiceConfiguration (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::EventServiceDescription > eventServiceConfiguration_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + CIAOEventsDef (); + + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + CIAOEventsDef (CIAOEventsDef const& s); + + CIAOEventsDef& + operator= (CIAOEventsDef const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export EventServiceDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // node + // + public: + ::XMLSchema::string< ACE_TCHAR > const& node () const; + void node (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > node_; + + // type + // + public: + ::CIAO::Config_Handlers::EventServiceType const& type () const; + void type (::CIAO::Config_Handlers::EventServiceType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::EventServiceType > type_; + + // svc_cfg_file + // + public: + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file () const; + void svc_cfg_file (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > svc_cfg_file_; + + // filter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Filter >::iterator filter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Filter >::const_iterator filter_const_iterator; + filter_iterator begin_filter (); + filter_iterator end_filter (); + filter_const_iterator begin_filter () const; + filter_const_iterator end_filter () const; + void add_filter (::CIAO::Config_Handlers::Filter const& ); + size_t count_filter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Filter > filter_; + + // addr_serv + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::AddressServerDescription >::iterator addr_serv_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::AddressServerDescription >::const_iterator addr_serv_const_iterator; + addr_serv_iterator begin_addr_serv (); + addr_serv_iterator end_addr_serv (); + addr_serv_const_iterator begin_addr_serv () const; + addr_serv_const_iterator end_addr_serv () const; + void add_addr_serv (::CIAO::Config_Handlers::AddressServerDescription const& ); + size_t count_addr_serv (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::AddressServerDescription > addr_serv_; + + // udp_sender + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription >::iterator udp_sender_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription >::const_iterator udp_sender_const_iterator; + udp_sender_iterator begin_udp_sender (); + udp_sender_iterator end_udp_sender (); + udp_sender_const_iterator begin_udp_sender () const; + udp_sender_const_iterator end_udp_sender () const; + void add_udp_sender (::CIAO::Config_Handlers::UDPSenderDescription const& ); + size_t count_udp_sender (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::UDPSenderDescription > udp_sender_; + + // udp_receiver + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription >::iterator udp_receiver_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription >::const_iterator udp_receiver_const_iterator; + udp_receiver_iterator begin_udp_receiver (); + udp_receiver_iterator end_udp_receiver (); + udp_receiver_const_iterator begin_udp_receiver () const; + udp_receiver_const_iterator end_udp_receiver () const; + void add_udp_receiver (::CIAO::Config_Handlers::UDPReceiverDescription const& ); + size_t count_udp_receiver (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::UDPReceiverDescription > udp_receiver_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + EventServiceDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& node__, + ::CIAO::Config_Handlers::EventServiceType const& type__, + ::XMLSchema::string< ACE_TCHAR > const& svc_cfg_file__); + + EventServiceDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + EventServiceDescription (EventServiceDescription const& s); + + EventServiceDescription& + operator= (EventServiceDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export FilterType : public ::XSCRT::Type + { + public: + FilterType (::XSCRT::XML::Element< ACE_TCHAR > const&); + FilterType (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static FilterType const CONJUNCTION; + static FilterType const DISJUNCTION; + static FilterType const LOGICAL_AND; + static FilterType const NEGATE; + + enum Value + { + CONJUNCTION_l, DISJUNCTION_l, LOGICAL_AND_l, NEGATE_l + }; + + + Value + integral () const; + + friend bool CIAO_Events_Handlers_Export + operator== (FilterType const& a, FilterType const& b); + + friend bool CIAO_Events_Handlers_Export + operator!= (FilterType const& a, FilterType const& b); + + private: + FilterType (Value v); + + Value v_; + }; + + bool CIAO_Events_Handlers_Export operator== (FilterType const &a, FilterType const &b); + + bool CIAO_Events_Handlers_Export operator!= (FilterType const &a, FilterType const &b); + + + class CIAO_Events_Handlers_Export Filter : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // type + // + public: + ::CIAO::Config_Handlers::FilterType const& type () const; + void type (::CIAO::Config_Handlers::FilterType const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::FilterType > type_; + + // source + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator source_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::const_iterator source_const_iterator; + source_iterator begin_source (); + source_iterator end_source (); + source_const_iterator begin_source () const; + source_const_iterator end_source () const; + void add_source (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_source (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > source_; + + // id + // + public: + bool id_p () const; + ::XMLSchema::ID< ACE_TCHAR > const& id () const; + ::XMLSchema::ID< ACE_TCHAR >& id (); + void id (::XMLSchema::ID< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > id_; + + public: + Filter (::XMLSchema::string< ACE_TCHAR > const& name__, + ::CIAO::Config_Handlers::FilterType const& type__); + + Filter (::XSCRT::XML::Element< ACE_TCHAR > const&); + Filter (Filter const& s); + + Filter& + operator= (Filter const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export AddressServerDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // port + // + public: + ::XMLSchema::unsignedShort const& port () const; + void port (::XMLSchema::unsignedShort const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedShort > port_; + + // address + // + public: + ::XMLSchema::string< ACE_TCHAR > const& address () const; + void address (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > address_; + + public: + AddressServerDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::unsignedShort const& port__, + ::XMLSchema::string< ACE_TCHAR > const& address__); + + AddressServerDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + AddressServerDescription (AddressServerDescription const& s); + + AddressServerDescription& + operator= (AddressServerDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export UDPSenderDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // addr_serv_id + // + public: + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id () const; + void addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > addr_serv_id_; + + public: + UDPSenderDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id__); + + UDPSenderDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + UDPSenderDescription (UDPSenderDescription const& s); + + UDPSenderDescription& + operator= (UDPSenderDescription const& s); + + private: + char regulator__; + }; + + + class CIAO_Events_Handlers_Export UDPReceiverDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // addr_serv_id + // + public: + bool addr_serv_id_p () const; + ::XMLSchema::string< ACE_TCHAR > const& addr_serv_id () const; + void addr_serv_id (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > addr_serv_id_; + + // is_multicast + // + public: + ::XMLSchema::boolean const& is_multicast () const; + void is_multicast (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > is_multicast_; + + // listen_port + // + public: + ::XMLSchema::unsignedShort const& listen_port () const; + void listen_port (::XMLSchema::unsignedShort const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedShort > listen_port_; + + public: + UDPReceiverDescription (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::boolean const& is_multicast__, + ::XMLSchema::unsignedShort const& listen_port__); + + UDPReceiverDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + UDPReceiverDescription (UDPReceiverDescription const& s); + + UDPReceiverDescription& + operator= (UDPReceiverDescription const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + CIAO_Events_Handlers_Export + ::CIAO::Config_Handlers::CIAOEventsDef + CIAOEvents (xercesc::DOMDocument const*); + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::EventServiceType > + EventServiceType; + + struct CIAO_Events_Handlers_Export CIAOEventsDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::CIAOEventsDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + eventServiceConfiguration (Type&); + + virtual void + eventServiceConfiguration (Type const&); + + virtual void + eventServiceConfiguration_pre (Type&); + + virtual void + eventServiceConfiguration_pre (Type const&); + + virtual void + eventServiceConfiguration_next (Type&); + + virtual void + eventServiceConfiguration_next (Type const&); + + virtual void + eventServiceConfiguration_post (Type&); + + virtual void + eventServiceConfiguration_post (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 CIAO_Events_Handlers_Export EventServiceDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::EventServiceDescription > + { + 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 + type (Type&); + + virtual void + type (Type const&); + + virtual void + svc_cfg_file (Type&); + + virtual void + svc_cfg_file (Type const&); + + virtual void + filter (Type&); + + virtual void + filter (Type const&); + + virtual void + filter_pre (Type&); + + virtual void + filter_pre (Type const&); + + virtual void + filter_next (Type&); + + virtual void + filter_next (Type const&); + + virtual void + filter_post (Type&); + + virtual void + filter_post (Type const&); + + virtual void + filter_none (Type&); + + virtual void + filter_none (Type const&); + + virtual void + addr_serv (Type&); + + virtual void + addr_serv (Type const&); + + virtual void + addr_serv_pre (Type&); + + virtual void + addr_serv_pre (Type const&); + + virtual void + addr_serv_next (Type&); + + virtual void + addr_serv_next (Type const&); + + virtual void + addr_serv_post (Type&); + + virtual void + addr_serv_post (Type const&); + + virtual void + addr_serv_none (Type&); + + virtual void + addr_serv_none (Type const&); + + virtual void + udp_sender (Type&); + + virtual void + udp_sender (Type const&); + + virtual void + udp_sender_pre (Type&); + + virtual void + udp_sender_pre (Type const&); + + virtual void + udp_sender_next (Type&); + + virtual void + udp_sender_next (Type const&); + + virtual void + udp_sender_post (Type&); + + virtual void + udp_sender_post (Type const&); + + virtual void + udp_sender_none (Type&); + + virtual void + udp_sender_none (Type const&); + + virtual void + udp_receiver (Type&); + + virtual void + udp_receiver (Type const&); + + virtual void + udp_receiver_pre (Type&); + + virtual void + udp_receiver_pre (Type const&); + + virtual void + udp_receiver_next (Type&); + + virtual void + udp_receiver_next (Type const&); + + virtual void + udp_receiver_post (Type&); + + virtual void + udp_receiver_post (Type const&); + + virtual void + udp_receiver_none (Type&); + + virtual void + udp_receiver_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::FilterType > + FilterType; + + struct CIAO_Events_Handlers_Export Filter : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::Filter > + { + 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 + 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 + 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 CIAO_Events_Handlers_Export AddressServerDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::AddressServerDescription > + { + 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 + port (Type&); + + virtual void + port (Type const&); + + virtual void + address (Type&); + + virtual void + address (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct CIAO_Events_Handlers_Export UDPSenderDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::UDPSenderDescription > + { + 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 + addr_serv_id (Type&); + + virtual void + addr_serv_id (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct CIAO_Events_Handlers_Export UDPReceiverDescription : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::UDPReceiverDescription > + { + 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 + addr_serv_id (Type&); + + virtual void + addr_serv_id (Type const&); + + virtual void + addr_serv_id_none (Type&); + + virtual void + addr_serv_id_none (Type const&); + + virtual void + is_multicast (Type&); + + virtual void + is_multicast (Type const&); + + virtual void + listen_port (Type&); + + virtual void + listen_port (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct EventServiceType : Traversal::EventServiceType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + EventServiceType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + EventServiceType (); + }; + + struct CIAOEventsDef : Traversal::CIAOEventsDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::CIAOEventsDef Type; + CIAOEventsDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + eventServiceConfiguration_pre (Type &o) + { + + this->eventServiceConfiguration_pre (const_cast <Type const &> (o)); + } + + + virtual void + eventServiceConfiguration_pre (Type const&); + + virtual void + eventServiceConfiguration_next (Type &o) + { + + this->eventServiceConfiguration_next (const_cast <Type const &> (o)); + } + + + virtual void + eventServiceConfiguration_next (Type const&); + + virtual void + eventServiceConfiguration_post (Type &o) + { + + this->eventServiceConfiguration_post (const_cast <Type const &> (o)); + } + + + virtual void + eventServiceConfiguration_post (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + CIAOEventsDef (); + }; + + struct EventServiceDescription : Traversal::EventServiceDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::EventServiceDescription Type; + EventServiceDescription (::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 + type (Type &o) + { + + this->type (const_cast <Type const &> (o)); + } + + + virtual void + type (Type const&); + + virtual void + svc_cfg_file (Type &o) + { + + this->svc_cfg_file (const_cast <Type const &> (o)); + } + + + virtual void + svc_cfg_file (Type const&); + + virtual void + filter_pre (Type &o) + { + + this->filter_pre (const_cast <Type const &> (o)); + } + + + virtual void + filter_pre (Type const&); + + virtual void + filter_next (Type &o) + { + + this->filter_next (const_cast <Type const &> (o)); + } + + + virtual void + filter_next (Type const&); + + virtual void + filter_post (Type &o) + { + + this->filter_post (const_cast <Type const &> (o)); + } + + + virtual void + filter_post (Type const&); + + virtual void + addr_serv_pre (Type &o) + { + + this->addr_serv_pre (const_cast <Type const &> (o)); + } + + + virtual void + addr_serv_pre (Type const&); + + virtual void + addr_serv_next (Type &o) + { + + this->addr_serv_next (const_cast <Type const &> (o)); + } + + + virtual void + addr_serv_next (Type const&); + + virtual void + addr_serv_post (Type &o) + { + + this->addr_serv_post (const_cast <Type const &> (o)); + } + + + virtual void + addr_serv_post (Type const&); + + virtual void + udp_sender_pre (Type &o) + { + + this->udp_sender_pre (const_cast <Type const &> (o)); + } + + + virtual void + udp_sender_pre (Type const&); + + virtual void + udp_sender_next (Type &o) + { + + this->udp_sender_next (const_cast <Type const &> (o)); + } + + + virtual void + udp_sender_next (Type const&); + + virtual void + udp_sender_post (Type &o) + { + + this->udp_sender_post (const_cast <Type const &> (o)); + } + + + virtual void + udp_sender_post (Type const&); + + virtual void + udp_receiver_pre (Type &o) + { + + this->udp_receiver_pre (const_cast <Type const &> (o)); + } + + + virtual void + udp_receiver_pre (Type const&); + + virtual void + udp_receiver_next (Type &o) + { + + this->udp_receiver_next (const_cast <Type const &> (o)); + } + + + virtual void + udp_receiver_next (Type const&); + + virtual void + udp_receiver_post (Type &o) + { + + this->udp_receiver_post (const_cast <Type const &> (o)); + } + + + virtual void + udp_receiver_post (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + EventServiceDescription (); + }; + + struct FilterType : Traversal::FilterType, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + FilterType (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + FilterType (); + }; + + struct Filter : Traversal::Filter, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::Filter Type; + Filter (::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&); + + 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 + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + Filter (); + }; + + struct AddressServerDescription : Traversal::AddressServerDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::AddressServerDescription Type; + AddressServerDescription (::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 + port (Type &o) + { + + this->port (const_cast <Type const &> (o)); + } + + + virtual void + port (Type const&); + + virtual void + address (Type &o) + { + + this->address (const_cast <Type const &> (o)); + } + + + virtual void + address (Type const&); + + protected: + AddressServerDescription (); + }; + + struct UDPSenderDescription : Traversal::UDPSenderDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::UDPSenderDescription Type; + UDPSenderDescription (::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 + addr_serv_id (Type &o) + { + + this->addr_serv_id (const_cast <Type const &> (o)); + } + + + virtual void + addr_serv_id (Type const&); + + protected: + UDPSenderDescription (); + }; + + struct UDPReceiverDescription : Traversal::UDPReceiverDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::UDPReceiverDescription Type; + UDPReceiverDescription (::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 + addr_serv_id (Type &o) + { + + this->addr_serv_id (const_cast <Type const &> (o)); + } + + + virtual void + addr_serv_id (Type const&); + + virtual void + is_multicast (Type &o) + { + + this->is_multicast (const_cast <Type const &> (o)); + } + + + virtual void + is_multicast (Type const&); + + virtual void + listen_port (Type &o) + { + + this->listen_port (const_cast <Type const &> (o)); + } + + + virtual void + listen_port (Type const&); + + protected: + UDPReceiverDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + CIAO_Events_Handlers_Export + void + CIAOEvents (::CIAO::Config_Handlers::CIAOEventsDef const&, xercesc::DOMDocument*); + } +} + +#endif // CIAOEVENTS_HPP diff --git a/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp new file mode 100644 index 00000000000..e95c0656506 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.cpp @@ -0,0 +1,197 @@ +// $Id$ +#include "Utils/XML_Helper.h" +#include "CIAOEvents_Handler.h" +#include "CIAOEvents.hpp" +#include "DAnCE/Deployment/Deployment_EventsC.h" + +namespace CIAO +{ + namespace Config_Handlers + { + CIAOEvents_Handler::CIAOEvents_Handler (const ACE_TCHAR *file) : + idl_esd_(0), + esd_(0), + retval_ (false) + { + XML_Helper helper; + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + helper.create_dom (file); + + if (!dom) + throw CIAOEvents_Handler::NoESD (); + + this->esd_.reset (new CIAOEventsDef + (CIAOEvents (dom))); + + if (!this->build_esd ()) + throw NoESD (); + } + + CIAOEvents_Handler::CIAOEvents_Handler (CIAOEventsDef *esd): + idl_esd_(0), + esd_(esd), + retval_(false) + { + if(!this->build_esd()) + throw NoESD (); + } + + + CIAOEvents_Handler::~CIAOEvents_Handler (void) + { + } + + bool + CIAOEvents_Handler::build_esd () + { + this->idl_esd_.reset ( new ::CIAO::DAnCE::EventServiceDeploymentDescriptions ); + + + this->idl_esd_->length (this->esd_->count_eventServiceConfiguration ()); + CORBA::ULong pos_i = 0; + for (CIAOEventsDef::eventServiceConfiguration_const_iterator i = this->esd_->begin_eventServiceConfiguration (); + i != this->esd_->end_eventServiceConfiguration (); + i++) + { + CIAO::DAnCE::EventServiceDeploymentDescription a_esd; + + a_esd.name = CORBA::string_dup (i->name ().c_str ()); + a_esd.node = CORBA::string_dup (i->node ().c_str ()); + + switch (i->type ().integral ()) + { + case ::CIAO::Config_Handlers::EventServiceType::EC_l: + a_esd.type = CIAO::EC; + break; + case ::CIAO::Config_Handlers::EventServiceType::NOTIFY_l: + a_esd.type = CIAO::NOTIFY; + break; + case ::CIAO::Config_Handlers::EventServiceType::RTEC_l: + a_esd.type = CIAO::RTEC; + break; + case ::CIAO::Config_Handlers::EventServiceType::RTNOTIFY_l: + a_esd.type = CIAO::RTNOTIFY; + break; + default: + ACE_ERROR ((LM_ERROR, + "Invalid event service type\n")); + return false; + } + + a_esd.svc_cfg_file = CORBA::string_dup (i->svc_cfg_file ().c_str ()); + + + // Populate filtering information for this event channel + a_esd.filters.length (i->count_filter ()); + CORBA::ULong pos_j = 0; + for (EventServiceDescription::filter_const_iterator j = i->begin_filter (); + j != i->end_filter (); + j++) + { + a_esd.filters[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + switch (j->type ().integral ()) + { + case ::CIAO::Config_Handlers::FilterType::CONJUNCTION_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::CONJUNCTION; + break; + case ::CIAO::Config_Handlers::FilterType::DISJUNCTION_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::DISJUNCTION; + break; + case ::CIAO::Config_Handlers::FilterType::LOGICAL_AND_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::LOGICAL_AND; + break; + case ::CIAO::Config_Handlers::FilterType::NEGATE_l: + a_esd.filters[pos_j].type = CIAO::DAnCE::NEGATE; + break; + default: + ACE_ERROR ((LM_ERROR, + "Invalid filter type\n")); + return false; + } + + a_esd.filters[pos_j].sources.length (j->count_source ()); + CORBA::ULong pos_k = 0; + for (Filter::source_const_iterator k = j->begin_source (); + k != j->end_source (); + k++) + { + a_esd.filters[pos_j].sources[pos_k] = CORBA::string_dup (k->c_str ()); + pos_k++; + + } + pos_j++; + } + + // Populate address server information for this event channel + a_esd.addr_servs.length (i->count_addr_serv ()); + pos_j = 0; + for (EventServiceDescription::addr_serv_const_iterator j = i->begin_addr_serv (); + j != i->end_addr_serv (); + j++) + { + a_esd.addr_servs[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.addr_servs[pos_j].port = j->port (); + a_esd.addr_servs[pos_j].address = CORBA::string_dup (j->address ().c_str ()); + pos_j++; + } + + // Populate UDP sender information for this event channel + a_esd.senders.length (i->count_udp_sender ()); + pos_j = 0; + for (EventServiceDescription::udp_sender_const_iterator j = i->begin_udp_sender (); + j != i->end_udp_sender (); + j++) + { + a_esd.senders[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.senders[pos_j].addr_serv_id = + CORBA::string_dup (j->addr_serv_id ().c_str ()); + pos_j++; + } + + // Populate UDP receiver information for this event channel + a_esd.receivers.length (i->count_udp_receiver ()); + pos_j = 0; + for (EventServiceDescription::udp_receiver_const_iterator j = i->begin_udp_receiver (); + j != i->end_udp_receiver (); + j++) + { + a_esd.receivers[pos_j].name = CORBA::string_dup (j->name ().c_str ()); + a_esd.receivers[pos_j].addr_serv_id = + CORBA::string_dup (j->addr_serv_id ().c_str ()); + a_esd.receivers[pos_j].is_multicast = j->is_multicast (); + a_esd.receivers[pos_j].listen_port = j->listen_port (); + pos_j++; + } + + (*this->idl_esd_)[pos_i] = a_esd; + pos_i++; + } + return true; + } + + + ::CIAO::DAnCE::EventServiceDeploymentDescriptions const * + CIAOEvents_Handler::esd_idl () const + throw (CIAOEvents_Handler::NoESD) + { + if(!this->idl_esd_.get()) + throw NoESD (); + + //else + return this->idl_esd_.get(); + } + + ::CIAO::DAnCE::EventServiceDeploymentDescriptions * + CIAOEvents_Handler::esd_idl () + throw (CIAOEvents_Handler::NoESD) + { + if(!this->idl_esd_.get()) + throw NoESD(); + + //else + return this->idl_esd_.release(); + } + } +} + diff --git a/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h new file mode 100644 index 00000000000..f45ff89afb4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAOEvents_Handler.h @@ -0,0 +1,74 @@ +//================================================ +/** + * @file CIAOEvents_Handler.h + * + * $Id$ + * + * @author Ming Xiong <mxiong@dre.vanderbilt.edu> + */ +//================================================ + +#ifndef CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "Utils/XML_Helper.h" +#include "DAnCE/Deployment/Deployment_EventsC.h" +#include "CIAO_Events_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 CIAOEventsDef; + + /* + * @class CIAOEvents_Handler + * + * @brief Handler class for <CIAOEvents> types. + * + * This class defines handler methods to map values from + * XSC objects, parsed from the descriptor files, to the + * corresponding CORBA IDL type for the schema element. + * + */ + class CIAO_Events_Handlers_Export CIAOEvents_Handler + { + + public: + class NoESD {}; + + CIAOEvents_Handler (const ACE_TCHAR *file); + + CIAOEvents_Handler(CIAOEventsDef *esd); + + ~CIAOEvents_Handler (void); + + CIAO::DAnCE::EventServiceDeploymentDescriptions const *esd_idl (void) const + throw (CIAOEvents_Handler::NoESD); + + CIAO::DAnCE::EventServiceDeploymentDescriptions *esd_idl (void) + throw (CIAOEvents_Handler::NoESD); + + private: + bool build_esd (); + + auto_ptr <CIAO::DAnCE::EventServiceDeploymentDescriptions > idl_esd_; + + auto_ptr <CIAOEventsDef> esd_; + + bool retval_; + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CIAOEvents_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc b/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc new file mode 100644 index 00000000000..b25f0cb1d97 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers.mpc @@ -0,0 +1,47 @@ +//$Id$ + +project (CIAO_Events_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 CIAO_Events_Handlers_Export + xscflags += --cxx-namespace-regex <%quote%>%.*vanderbilt.*%CIAO/Config_Handlers%<%quote%> + xscflags += --cxx-export-header CIAO_Events_Handlers_Export.h + xscflags += --search-path "$(CIAO_ROOT)/docs/schema" + + custom_only = 1 + + XSC_Files { + gendir = . + $(CIAO_ROOT)/docs/schema/CIAOEvents.xsd + } +} + +project (CIAO_Events_Handlers) : acelib, ciao_config_handlers_base, ciao_events_dnc, ciao_deployment_stub { + sharedname = CIAO_Events_Handlers + dynamicflags = CIAO_EVENTS_HANDLERS_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + + after += CIAO_Events_XML_Generation + Source_Files { + CIAOEvents.cpp + CIAOEvents_Handler.cpp + } + + Header_Files { + } +} + +project (CIAO_Events_Handlers_Tests) : ciao_config_handlers_base, ciao_server_dnc { + exename = test + after += CIAO_Events_Handlers + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + libs += CIAO_Events_Handlers + + Source_Files { + test.cpp + } +} diff --git a/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h b/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h new file mode 100644 index 00000000000..efe95849905 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/CIAO_Events_Handlers_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl -n CIAO_Events_Handlers +// ------------------------------ +#ifndef CIAO_EVENTS_HANDLERS_EXPORT_H +#define CIAO_EVENTS_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (CIAO_EVENTS_HANDLERS_HAS_DLL) +# define CIAO_EVENTS_HANDLERS_HAS_DLL 1 +#endif /* ! CIAO_EVENTS_HANDLERS_HAS_DLL */ + +#if defined (CIAO_EVENTS_HANDLERS_HAS_DLL) && (CIAO_EVENTS_HANDLERS_HAS_DLL == 1) +# if defined (CIAO_EVENTS_HANDLERS_BUILD_DLL) +# define CIAO_Events_Handlers_Export ACE_Proper_Export_Flag +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* CIAO_EVENTS_HANDLERS_BUILD_DLL */ +# define CIAO_Events_Handlers_Export ACE_Proper_Import_Flag +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* CIAO_EVENTS_HANDLERS_BUILD_DLL */ +#else /* CIAO_EVENTS_HANDLERS_HAS_DLL == 1 */ +# define CIAO_Events_Handlers_Export +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARATION(T) +# define CIAO_EVENTS_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* CIAO_EVENTS_HANDLERS_HAS_DLL == 1 */ + +// Set CIAO_EVENTS_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (CIAO_EVENTS_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define CIAO_EVENTS_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define CIAO_EVENTS_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !CIAO_EVENTS_HANDLERS_NTRACE */ + +#if (CIAO_EVENTS_HANDLERS_NTRACE == 1) +# define CIAO_EVENTS_HANDLERS_TRACE(X) +#else /* (CIAO_EVENTS_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define CIAO_EVENTS_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (CIAO_EVENTS_HANDLERS_NTRACE == 1) */ + +#endif /* CIAO_EVENTS_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp b/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp new file mode 100644 index 00000000000..d4f92a9a990 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CIAO_Events/test.cpp @@ -0,0 +1,58 @@ +// $Id$ + +#include <iostream> + +#include "CIAOEvents.hpp" +#include "CIAOEvents_Handler.h" +#include "DAnCE/Deployment/Deployment_EventsC.h" + +#include "ace/Get_Opt.h" +#include "tao/ORB.h" + +static const char *input_file = "test.ced"; + + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "i:"); + + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'i': + input_file = get_opts.opt_arg (); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-i <input file> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command-line + return 0; +} + +using namespace CIAO::Config_Handlers; + +int main (int argc, char *argv[]) +{ + + if (parse_args (argc, argv) != 0) + return 1; + + CIAOEvents_Handler event_handler (input_file); + // Convert XSC to idl datatype + + std::cout << "Instance document import succeeded. Dumping contents to file\n"; + + std::cout << "Test completed!"; + + return 0; + +} diff --git a/CIAO/tools/Config_Handlers/CPD_Handler.cpp b/CIAO/tools/Config_Handlers/CPD_Handler.cpp new file mode 100644 index 00000000000..97a9e50ae23 --- /dev/null +++ b/CIAO/tools/Config_Handlers/CPD_Handler.cpp @@ -0,0 +1,150 @@ +// $Id$ + +#include "CPD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/CIAO_common.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 = + desc.name ().c_str (); + + if (desc.specificType_p ()) + toconfig.specificType = + 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< char > name ((src.name)); + ::XMLSchema::string< char > stype ((src.specificType)); + + ::XMLSchema::string< char > tval ("true"); + ::XMLSchema::string< char > fval ("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, "Invalid port kind in connection %s\n", + name.c_str ())); + } + + for (CORBA::ULong i = 0; i < src.supportedType.length (); ++i) + cpd.add_supportedType (XMLSchema::string< char > ((src.supportedType[i]))); + + return cpd; + } + + } +} diff --git a/CIAO/tools/Config_Handlers/CPD_Handler.h b/CIAO/tools/Config_Handlers/CPD_Handler.h new file mode 100644 index 00000000000..16e78f661f2 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/CRDD_Handler.cpp b/CIAO/tools/Config_Handlers/CRDD_Handler.cpp new file mode 100644 index 00000000000..87d1b6511e5 --- /dev/null +++ b/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/CIAO_common.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 = desc.targetName ().c_str (); + toconfig.requirementName = desc.requirementName ().c_str (); + toconfig.resourceName = 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 ((src.targetName)); + XMLSchema::string< ACE_TCHAR > reqname ((src.requirementName)); + XMLSchema::string <ACE_TCHAR> resname ((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/CIAO/tools/Config_Handlers/CRDD_Handler.h b/CIAO/tools/Config_Handlers/CRDD_Handler.h new file mode 100644 index 00000000000..8f5c964aab4 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Common.h b/CIAO/tools/Config_Handlers/Common.h new file mode 100644 index 00000000000..6057cbb74be --- /dev/null +++ b/CIAO/tools/Config_Handlers/Common.h @@ -0,0 +1,41 @@ +// $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::string &name, +const std::string &error) : +name_ (name), +error_ (error) +{}; + +/// Some identifying information about the element that +/// caused the error +std::string name_; + +/// A human readable error message +std::string error_; + +}; +} +} +#endif /* CONFIG_HANDLERS_COMMON_H */ + + diff --git a/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.cpp b/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.cpp new file mode 100644 index 00000000000..d916bf8076f --- /dev/null +++ b/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/CIAO_common.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 (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< char > name ((src.name)); + DataType dt (DataType_Handler::data_type (src.type)); + ComponentPropertyDescription cpd (name,dt); + return cpd; + } + + } +} diff --git a/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.h b/CIAO/tools/Config_Handlers/ComponentPropertyDescription_Handler.h new file mode 100644 index 00000000000..f87edc7fcea --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Config_Handlers.mpc b/CIAO/tools/Config_Handlers/Config_Handlers.mpc new file mode 100644 index 00000000000..0363001958f --- /dev/null +++ b/CIAO/tools/Config_Handlers/Config_Handlers.mpc @@ -0,0 +1,138 @@ +//$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 <%quote%>%.*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/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 { + sharedname += XSC_XML_Handlers + dynamicflags = XSC_XML_HANDLERS_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + after += XSC_XML_Generation + + Source_Files { + Deployment.cpp + ccd.cpp + cdd.cpp + cdp.cpp + cid.cpp + cpd.cpp + iad.cpp + pcd.cpp + toplevel.cpp + Basic_Deployment_Data.cpp + } + + Header_Files { + XSC_XML_Handlers_Export.h + } + + verbatim(gnuace, macros) { + override no_hidden_visibility = 1 + } + +} + +project (XSC_Config_Handlers) : ciao_deployment_stub, ciao_events_dnc, ciao_config_handlers_base { + after += CIAO_Events_Handlers \ + RT_CCM_Config_Handlers \ + XSC_DynAny_Handler \ + XSC_Config_Handlers_Common + sharedname = XSC_Config_Handlers + dynamicflags = CONFIG_HANDLERS_BUILD_DLL + libs += CIAO_XML_Utils \ + CIAO_Events_Handlers \ + RT_CCM_Config_Handlers \ + XSC_XML_Handlers \ + XSC_DynAny_Handler \ + XSC_Config_Handlers_Common + + 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 + XML_File_Intf.cpp + IDREF_Base.cpp + DnC_Dump.cpp + DnC_Dump_T.cpp + Dump_Obj.cpp + PCD_Handler.cpp + IRDD_Handler.cpp + DD_Handler.cpp + + } + + Header_Files { + Config_Handlers_Export.h + } + +} + +project (XSC_Config_Handlers_Common) : ciao_deployment_stub, ciao_config_handlers_base { + 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) : ciao_component_dnc, ciao_config_handlers, ifr_client { +// requires += dummy_label +includes += $(CIAO_ROOT)/tools/Config_Handlers +exename = test +dynamicflags = CONFIG_HANDLERS_BUILD_DLL +macros += XML_USE_PTHREADS + +Source_Files { +test.cpp +} +} + + diff --git a/CIAO/tools/Config_Handlers/Config_Handlers_Common_Export.h b/CIAO/tools/Config_Handlers/Config_Handlers_Common_Export.h new file mode 100644 index 00000000000..f1583c7e71d --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Config_Handlers_Export.h b/CIAO/tools/Config_Handlers/Config_Handlers_Export.h new file mode 100644 index 00000000000..64dec8bdfa5 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/DD_Handler.cpp b/CIAO/tools/Config_Handlers/DD_Handler.cpp new file mode 100644 index 00000000000..18ed4013c8c --- /dev/null +++ b/CIAO/tools/Config_Handlers/DD_Handler.cpp @@ -0,0 +1,244 @@ +// $Id$ + +#include "Utils/XML_Helper.h" +#include "SatisfierProperty_Handler.h" +#include "DD_Handler.h" +#include "Any_Handler.h" +#include "Deployment.hpp" +#include "DAnCE/Deployment/Deployment_TargetDataC.h" +#include "CIAO_common.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"); + XML_Helper helper; + + if (CIAO::debug_level () > 9) + { + ACE_DEBUG ((LM_DEBUG , "inside DD_Handler")); + } + + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + helper.create_dom (file); + + if (CIAO::debug_level () > 9) + { + ACE_DEBUG ((LM_DEBUG , "after create dom")); + } + + if (!dom) + throw DD_Handler::NoDomain (); + + Domain *dm = + new Domain (domain (dom)); + + // Domain d = domain (dom); + + if (CIAO::debug_level () > 9) + { + ACE_DEBUG ((LM_DEBUG , "dom")); + } + + + this->domain_.reset (dm); + + if (CIAO::debug_level () > 9) + { + ACE_DEBUG ((LM_DEBUG , "after reset")); + } + + 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 (domain_->label ().c_str ()); + + if (domain_->UUID_p ()) + this->idl_domain_->UUID = + CORBA::string_dup (domain_->UUID ().c_str ()); + + CORBA::ULong len = domain_->count_node (); + this->idl_domain_->node.length (len); + + if (CIAO::debug_level () > 9) + { + ACE_DEBUG ((LM_DEBUG , "The node length is [%d]\n",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 (iter->name ().c_str ()); + + if (iter->label_p ()) + this->idl_domain_->node[i].label = + CORBA::string_dup (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 (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 (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 (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 + throw (DD_Handler::NoDomain) + { + if(!this->idl_domain_.get()) + throw NoDomain (); + + //else + return this->idl_domain_.get(); + } + + ::Deployment::Domain * + DD_Handler::domain_idl () + throw (DD_Handler::NoDomain) + { + if(!this->idl_domain_.get()) + throw NoDomain(); + + //else + return this->idl_domain_.release(); + } + + Domain const * + DD_Handler::domain_xsc () const + throw (DD_Handler::NoDomain) + { + if(!this->domain_.get()) + throw NoDomain (); + + //else + return this->domain_.get(); + } + + Domain * + DD_Handler::domain_xsc () + throw (DD_Handler::NoDomain) + { + if(!this->domain_.get()) + throw NoDomain (); + + //else + return this->domain_.release(); + } + } +} + diff --git a/CIAO/tools/Config_Handlers/DD_Handler.h b/CIAO/tools/Config_Handlers/DD_Handler.h new file mode 100644 index 00000000000..7c77d0f6b54 --- /dev/null +++ b/CIAO/tools/Config_Handlers/DD_Handler.h @@ -0,0 +1,119 @@ +// $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" +// #include "Utils/XML_Helper.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 +throw (NoDomain); + +/** +* @brief Returns the IDL domain +* @return Domain* the IDL domain pointer +*/ +::Deployment::Domain *domain_idl (void) +throw (NoDomain); + +/** +* @brief Returns the const XSC domain +* @return Domain* the XSC domain pointer +*/ +Domain const *domain_xsc (void) const +throw (NoDomain); + +/** +* @brief Returns the XSC domain +* @return Domain* the XSC domain pointer +*/ +Domain *domain_xsc (void) +throw (NoDomain); + +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/CIAO/tools/Config_Handlers/DP_Handler.cpp b/CIAO/tools/Config_Handlers/DP_Handler.cpp new file mode 100644 index 00000000000..c5ff32d9c35 --- /dev/null +++ b/CIAO/tools/Config_Handlers/DP_Handler.cpp @@ -0,0 +1,325 @@ +// $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 "Property_Handler.h" +#include "cdp.hpp" +#include "RT-CCM/SRD_Handler.h" +#include "RT-CCM/CIAOServerResources.hpp" +#include "CIAO_Events/CIAOEvents_Handler.h" +#include "CIAO_Events/CIAOEvents.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 + throw (DP_Handler::NoPlan) + { + if (this->retval_ && this->xsc_dp_.get () != 0) + return this->xsc_dp_.get (); + + throw NoPlan (); + } + + DeploymentPlan * + DP_Handler::xsc (void) + throw (DP_Handler::NoPlan) + { + if (this->retval_ && this->xsc_dp_.get () != 0) + return this->xsc_dp_.release (); + + throw NoPlan (); + } + + ::Deployment::DeploymentPlan const * + DP_Handler::plan (void) const + throw (DP_Handler::NoPlan) + { + if (this->retval_ && this->idl_dp_.get () != 0) + return this->idl_dp_.get (); + + throw NoPlan (); + } + + ::Deployment::DeploymentPlan * + DP_Handler::plan (void) + throw (DP_Handler::NoPlan) + + { + 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 (xsc_dp.label ().c_str ()); + } + + // Read in the UUID, if present + if (xsc_dp.UUID_p ()) + { + this->idl_dp_->UUID = + CORBA::string_dup (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); + + if (pstart->name () == "CIAOServerResources") + { + /* + * Hook for RT-CCM + */ + + + ACE_DEBUG ((LM_DEBUG, + "Importing ServerResources...\n")); + + // Parse the SR document + SRD_Handler srd_handler (pstart->value ().value ().begin_string ()->c_str ()); + + // Populate the property + this->idl_dp_->infoProperty [len].name = pstart->name ().c_str (); + this->idl_dp_->infoProperty [len].value <<= *(srd_handler.srd_idl ()); + } + else if (pstart->name () == "CIAOEvents") + { + /* + * Hook for EVENTS + */ + + ACE_DEBUG ((LM_DEBUG, + "Importing CIAOEvents...\n")); + + // Parse the SR document + CIAOEvents_Handler event_handler (pstart->value ().value ().begin_string ()->c_str ()); + + // Populate the property + this->idl_dp_->infoProperty [len].name = pstart->name ().c_str (); + this->idl_dp_->infoProperty [len].value <<= *(event_handler.esd_idl ()); + } + else + { + 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)); + + //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< char > i((plan.label)); + this->xsc_dp_->label(i); + } + + // Read in the UUID, if present + if (plan.UUID != 0) + { + XMLSchema::string< char > j((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/CIAO/tools/Config_Handlers/DP_Handler.h b/CIAO/tools/Config_Handlers/DP_Handler.h new file mode 100644 index 00000000000..50620822263 --- /dev/null +++ b/CIAO/tools/Config_Handlers/DP_Handler.h @@ -0,0 +1,91 @@ +//============================================================== +/** +* @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 +throw (NoPlan); + +DeploymentPlan *xsc (void) +throw (NoPlan); + +/// Generates the XSC->IDL mapping. returns null +/// if the method fails or the class was constructed +::Deployment::DeploymentPlan const *plan (void) const +throw (NoPlan); + +::Deployment::DeploymentPlan *plan (void) +throw (NoPlan); + +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/CIAO/tools/Config_Handlers/DP_PCD_Handler.cpp b/CIAO/tools/Config_Handlers/DP_PCD_Handler.cpp new file mode 100644 index 00000000000..2be43fb3b5b --- /dev/null +++ b/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/CIAO_common.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/CIAO/tools/Config_Handlers/DP_PCD_Handler.h b/CIAO/tools/Config_Handlers/DP_PCD_Handler.h new file mode 100644 index 00000000000..cc411c37383 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/DataType_Handler.cpp b/CIAO/tools/Config_Handlers/DataType_Handler.cpp new file mode 100644 index 00000000000..02034f6d56a --- /dev/null +++ b/CIAO/tools/Config_Handlers/DataType_Handler.cpp @@ -0,0 +1,180 @@ +//$Id$ + +#include "DataType_Handler.h" +#include "tao/AnyTypeCode/TypeCode.h" +#include "ciao/CIAO_common.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, "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, "Invalid typecode\n")); + throw 1; + } + + } + + } +} diff --git a/CIAO/tools/Config_Handlers/DataType_Handler.h b/CIAO/tools/Config_Handlers/DataType_Handler.h new file mode 100644 index 00000000000..b2a3240fbec --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Deployment.cpp b/CIAO/tools/Config_Handlers/Deployment.cpp new file mode 100644 index 00000000000..20003d72205 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Deployment.cpp @@ -0,0 +1,717 @@ +/* $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 + { + ::CIAO::Config_Handlers::Domain + domain (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "domain") + { + ::CIAO::Config_Handlers::Domain r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::DeploymentPlan + deploymentPlan (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "deploymentPlan") + { + ::CIAO::Config_Handlers::DeploymentPlan r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::ImplementationArtifactDescription + implementationArtifactDescription (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "implementationArtifactDescription") + { + ::CIAO::Config_Handlers::ImplementationArtifactDescription r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription + componentInterfaceDescription (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "componentInterfaceDescription") + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::ComponentImplementationDescription + componentImplementationDescription (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "componentImplementationDescription") + { + ::CIAO::Config_Handlers::ComponentImplementationDescription r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::ComponentPackageDescription + componentPackageDescription (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "componentPackageDescription") + { + ::CIAO::Config_Handlers::ComponentPackageDescription r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::PackageConfiguration + packageConfiguration (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "packageConfiguration") + { + ::CIAO::Config_Handlers::PackageConfiguration r (e); + return r; + } + + else + { + throw 1; + } + } + + ::CIAO::Config_Handlers::TopLevelPackageDescription + topLevelPackageDescription (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "topLevelPackageDescription") + { + ::CIAO::Config_Handlers::TopLevelPackageDescription r (e); + 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 + { + void + domain (::CIAO::Config_Handlers::Domain const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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); + } + + void + deploymentPlan (::CIAO::Config_Handlers::DeploymentPlan const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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 ::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::ImplementationDependency, + virtual ::CIAO::Config_Handlers::Writer::ArtifactDeploymentDescription, + virtual ::CIAO::Config_Handlers::Writer::ResourceDeploymentDescription, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + W (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + }; + + W w (e); + w.dispatch (s); + } + + void + implementationArtifactDescription (::CIAO::Config_Handlers::ImplementationArtifactDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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); + } + + void + componentInterfaceDescription (::CIAO::Config_Handlers::ComponentInterfaceDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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); + } + + void + componentImplementationDescription (::CIAO::Config_Handlers::ComponentImplementationDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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 ::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::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); + } + + void + componentPackageDescription (::CIAO::Config_Handlers::ComponentPackageDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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 ::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::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); + } + + void + packageConfiguration (::CIAO::Config_Handlers::PackageConfiguration const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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 ::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::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); + } + + void + topLevelPackageDescription (::CIAO::Config_Handlers::TopLevelPackageDescription const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "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::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::unsignedInt, 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 ::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::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/CIAO/tools/Config_Handlers/Deployment.hpp b/CIAO/tools/Config_Handlers/Deployment.hpp new file mode 100644 index 00000000000..d0477b78113 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Deployment.hpp @@ -0,0 +1,152 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#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 + { + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::Domain + domain (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::DeploymentPlan + deploymentPlan (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ImplementationArtifactDescription + implementationArtifactDescription (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentInterfaceDescription + componentInterfaceDescription (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentImplementationDescription + componentImplementationDescription (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::ComponentPackageDescription + componentPackageDescription (xercesc::DOMDocument const*); + + XSC_XML_Handlers_Export + ::CIAO::Config_Handlers::PackageConfiguration + packageConfiguration (xercesc::DOMDocument const*); + + 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 + { + XSC_XML_Handlers_Export + void + domain (::CIAO::Config_Handlers::Domain const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + deploymentPlan (::CIAO::Config_Handlers::DeploymentPlan const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + implementationArtifactDescription (::CIAO::Config_Handlers::ImplementationArtifactDescription const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + componentInterfaceDescription (::CIAO::Config_Handlers::ComponentInterfaceDescription const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + componentImplementationDescription (::CIAO::Config_Handlers::ComponentImplementationDescription const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + componentPackageDescription (::CIAO::Config_Handlers::ComponentPackageDescription const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + packageConfiguration (::CIAO::Config_Handlers::PackageConfiguration const&, xercesc::DOMDocument*); + + XSC_XML_Handlers_Export + void + topLevelPackageDescription (::CIAO::Config_Handlers::TopLevelPackageDescription const&, xercesc::DOMDocument*); + } +} + +#endif // DEPLOYMENT_HPP diff --git a/CIAO/tools/Config_Handlers/DnC_Dump.cpp b/CIAO/tools/Config_Handlers/DnC_Dump.cpp new file mode 100644 index 00000000000..475b8894dab --- /dev/null +++ b/CIAO/tools/Config_Handlers/DnC_Dump.cpp @@ -0,0 +1,969 @@ +// $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); + } + + // 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.reference); + 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; + + default: + ACE_DEBUG ((LM_DEBUG, "Unknown type encoded in Any\n")); + throw CORBA::INTERNAL (); + } + } +} diff --git a/CIAO/tools/Config_Handlers/DnC_Dump.h b/CIAO/tools/Config_Handlers/DnC_Dump.h new file mode 100644 index 00000000000..17fb49377de --- /dev/null +++ b/CIAO/tools/Config_Handlers/DnC_Dump.h @@ -0,0 +1,152 @@ +//================================================================== +/** +* @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/DeploymentC.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/CIAO/tools/Config_Handlers/DnC_Dump_T.cpp b/CIAO/tools/Config_Handlers/DnC_Dump_T.cpp new file mode 100644 index 00000000000..6dd83b18989 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/DnC_Dump_T.h b/CIAO/tools/Config_Handlers/DnC_Dump_T.h new file mode 100644 index 00000000000..88a5c55f3cd --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Dump_Obj.cpp b/CIAO/tools/Config_Handlers/Dump_Obj.cpp new file mode 100644 index 00000000000..3caf5440e9b --- /dev/null +++ b/CIAO/tools/Config_Handlers/Dump_Obj.cpp @@ -0,0 +1,64 @@ +// $Id$ +#include "Dump_Obj.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, "%s%s:\n", indent_.c_str(), caption)); + indent_.append(" "); + } + + + Dump_Obj::Dump_Obj(const char* caption, + CORBA::Any &val) + : desc_(caption) + { + ACE_DEBUG ((LM_DEBUG, "%s%s:\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 %s 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 %s is not in the node map.\n", + desc_.c_str())); + throw Node_Not_Exist(); + } + } + } + + } diff --git a/CIAO/tools/Config_Handlers/Dump_Obj.h b/CIAO/tools/Config_Handlers/Dump_Obj.h new file mode 100644 index 00000000000..bb5d0139ce8 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Dump_Obj.h @@ -0,0 +1,76 @@ +//================================================================== +/** +* @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 <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 <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/CIAO/tools/Config_Handlers/DynAny_Handler.mpc b/CIAO/tools/Config_Handlers/DynAny_Handler.mpc new file mode 100644 index 00000000000..170d67aa9ad --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler.mpc @@ -0,0 +1,18 @@ +// $Id$ + +project (XSC_DynAny_Handler) : xerces, dynamicany, typecodefactory, ciao_client_dnc, ciao_config_handlers_base { + 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 + } + + Header_Files { + DynAny_Handler_Export.h + } +} diff --git a/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp b/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp new file mode 100644 index 00000000000..77567e3739c --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp @@ -0,0 +1,180 @@ +//$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 1; + } + + // 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 1; + } + + return type; + } + + } +} diff --git a/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h b/CIAO/tools/Config_Handlers/DynAny_Handler/DataType_Handler.h new file mode 100644 index 00000000000..c16b4b21fe3 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp b/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp new file mode 100644 index 00000000000..64690ad61c1 --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp @@ -0,0 +1,241 @@ +// $Id$ + +#include /**/ "ace/pre.h" + +#include "DynAny_Handler.h" +#include "DynEnum_Handler.h" +#include "Basic_Deployment_Data.hpp" + +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, "Unable to narrow Dynamic Any factory\n")); + throw 1; + } + } + + 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) + { + DynamicAny::DynAny_var retval; + + 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 = 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + retval = this->daf_->create_dyn_any_from_type_code (CORBA::_tc_string); + retval->insert_string (value.begin_string ()->c_str ()); + break; + + case TCKind::tk_longlong_l: + 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: + 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_longdouble_l: + break; + + case TCKind::tk_wchar_l: + 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_wstring_l: + break; + + case TCKind::tk_enum_l: + ACE_ERROR ((LM_ERROR, "Preparing to extract into enum\n")); + return DynEnum_Handler::extract_into_dynany (type, value); + + 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_struct_l: + case TCKind::tk_union_l: + case TCKind::tk_sequence_l: + case TCKind::tk_array_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_component_l: + case TCKind::tk_home_l: + case TCKind::tk_event_l: + ACE_ERROR ((LM_ERROR, "Type not supported\n")); + throw 1; + } + + 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; + + 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, "DynAny_Handler: I have no idea how to perform a referse mapping.\n")); + throw 1; + } + + } + } +} +#include /**/ "ace/post.h" diff --git a/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h b/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h new file mode 100644 index 00000000000..a209b3eae2c --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler.h @@ -0,0 +1,72 @@ +//============================================================== +/** + * @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/ORB.h" +#include "tao/DynamicAny/DynamicAny.h" +#include "ace/Singleton.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 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); + + Any extract_from_dynany (const CORBA::Any &any); + + CORBA::ORB_ptr orb (); + + DynamicAny::DynAnyFactory_ptr daf (); + + private: + + CORBA::ORB_var orb_; + + DynamicAny::DynAnyFactory_var daf_; + }; + + 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/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h b/CIAO/tools/Config_Handlers/DynAny_Handler/DynAny_Handler_Export.h new file mode 100644 index 00000000000..78a3ee57b77 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp b/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp new file mode 100644 index 00000000000..66eee609aad --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp @@ -0,0 +1,72 @@ +// $Id$ + +#include "DynEnum_Handler.h" +#include "DynAny_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#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) + { + if (!type.enum_p ()) + { + ACE_ERROR ((LM_ERROR, "ERROR: Enum type descriptioin required")); + throw 1; + } + + // 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 (i->c_str ()); + } + + // Grab pointer to the DynAny_Handler to use the orb and any factory. + // DynAny_Handler *dah = DynAny_Handler::instance (); + + // @@ Leak this guy onto the heap to avoid a compile problem. + CORBA::TypeCode_ptr tc = + DYNANY_HANDLER->orb ()->create_enum_tc (type.enum_ ().typeId ().c_str (), + type.enum_ ().name ().c_str (), + members); + + ACE_ERROR ((LM_ERROR, "Type: %s \nName: %s\nvalue: %s\n", + type.enum_ ().typeId ().c_str (), + type.enum_ ().name ().c_str (), + value.begin_enum ()->c_str ())); + + // 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 (value.begin_enum ()->c_str ()); + + return retval._retn (); + } + + void + DynEnum_Handler::extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn) + { + ACE_UNUSED_ARG (dyn); + ACE_ERROR ((LM_ERROR, "Extracting Enums not yet supported\n")); + } + } +} + + diff --git a/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h b/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h new file mode 100644 index 00000000000..009b8b37659 --- /dev/null +++ b/CIAO/tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.h @@ -0,0 +1,49 @@ +/** + * $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); + + static void extract_out_of_dynany (const DynamicAny::DynAny_ptr dyn); + }; + + } +} + + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_DYNENUM_HANDLER_H*/ + diff --git a/CIAO/tools/Config_Handlers/ERE_Handler.cpp b/CIAO/tools/Config_Handlers/ERE_Handler.cpp new file mode 100644 index 00000000000..17c9bd2b34e --- /dev/null +++ b/CIAO/tools/Config_Handlers/ERE_Handler.cpp @@ -0,0 +1,52 @@ +// $Id$ + +#include "ERE_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/CIAO_common.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 = + src.location ().c_str (); + } + + ExternalReferenceEndpoint + ERE_Handler::external_ref_endpoint ( + const Deployment::ExternalReferenceEndpoint& src) + { + CIAO_TRACE("ERE_Handler::external_ref_endpoint - reverse"); + XMLSchema::string< char > loc ((src.location)); + ExternalReferenceEndpoint erp (loc); + return erp; + } + } +} diff --git a/CIAO/tools/Config_Handlers/ERE_Handler.h b/CIAO/tools/Config_Handlers/ERE_Handler.h new file mode 100644 index 00000000000..a89b6dcc725 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/ESD_Handler.cpp b/CIAO/tools/Config_Handlers/ESD_Handler.cpp new file mode 100644 index 00000000000..4bb1134ae44 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ESD_Handler.cpp @@ -0,0 +1,127 @@ +// $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) + throw (Config_Error) + { + 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) + throw (Config_Error) + { + 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) + throw (Config_Error) + { + 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/CIAO/tools/Config_Handlers/ESD_Handler.h b/CIAO/tools/Config_Handlers/ESD_Handler.h new file mode 100644 index 00000000000..f89480f00e4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ESD_Handler.h @@ -0,0 +1,73 @@ +//============================================================== +/** + * @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) + throw (Config_Error); + + static EventServiceDeploymentDescription es_deployment_descr ( + const Deployment::EventServiceDeploymentDescription &src) + throw (Config_Error); + + static IDREF_Base<CORBA::ULong> IDREF; + + private: + static void es_deployment_descr ( + const EventServiceDeploymentDescription &src, + ::Deployment::EventServiceDeploymentDescription &dest, + CORBA::ULong pos) + throw (Config_Error); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IDD_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/IDD_Handler.cpp b/CIAO/tools/Config_Handlers/IDD_Handler.cpp new file mode 100644 index 00000000000..bb137ff7920 --- /dev/null +++ b/CIAO/tools/Config_Handlers/IDD_Handler.cpp @@ -0,0 +1,163 @@ +// $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) + throw (Config_Error) + { + 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) + throw (Config_Error) + { + CIAO_TRACE("IDD_Handler::instance_deployment_descr"); + try + { + dest.name = src.name ().c_str (); + dest.node = src.node ().c_str (); + + if (src.id_p ()) + { + ACE_CString 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", + src.name ().c_str ())); + } + + // We know there should be only one element + dest.source.length (1); + dest.source [0] = + src.source ().c_str (); + + CORBA::ULong tmp = 0; + MDD_Handler::IDREF.find_ref + (ACE_CString (src.implementation ().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 () + ":" + ex.name_; + throw ex; + } + // Done! + } + + InstanceDeploymentDescription + IDD_Handler::instance_deployment_descr ( + const Deployment::InstanceDeploymentDescription& src) + throw (Config_Error) + { + CIAO_TRACE("IDD_Handler::instance_deployment_descr - reverse"); + //Get all the string/IDREFs + XMLSchema::string < ACE_TCHAR > name ((src.name)); + XMLSchema::string < ACE_TCHAR > node ((src.node)); + XMLSchema::string < ACE_TCHAR > source (""); + if (src.source.length () > 0) + { + XMLSchema::string < ACE_TCHAR > source_detail (src.source[0]); + source = source_detail; + } + ACE_CString temp; + MDD_Handler::IDREF.find_ref(src.implementationRef, temp); + XMLSchema::IDREF< ACE_TCHAR > implementation ((temp.c_str())); + + // Instantiate the IDD + InstanceDeploymentDescription idd (name, node, source, implementation); + + //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 ()->generateUUID (uuid); + ACE_CString idd_id ("_"); + idd_id += *uuid.to_string (); + + 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/CIAO/tools/Config_Handlers/IDD_Handler.h b/CIAO/tools/Config_Handlers/IDD_Handler.h new file mode 100644 index 00000000000..735038e2468 --- /dev/null +++ b/CIAO/tools/Config_Handlers/IDD_Handler.h @@ -0,0 +1,76 @@ +//============================================================== +/** +* @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) +throw (Config_Error); + +static InstanceDeploymentDescription instance_deployment_descr ( +const Deployment::InstanceDeploymentDescription &src) +throw (Config_Error); + +static IDREF_Base<CORBA::ULong> IDREF; + +private: +static void instance_deployment_descr ( +const InstanceDeploymentDescription &src, +::Deployment::InstanceDeploymentDescription &dest, +CORBA::ULong pos) +throw (Config_Error); + +}; +} +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_IDD_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/IDREF_Base.cpp b/CIAO/tools/Config_Handlers/IDREF_Base.cpp new file mode 100644 index 00000000000..b2249b82895 --- /dev/null +++ b/CIAO/tools/Config_Handlers/IDREF_Base.cpp @@ -0,0 +1,114 @@ +// $Id$ + +#ifndef IDREF_BASE_CPP +#define IDREF_BASE_CPP + +#include "ciao/CIAO_common.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_CString& id, T value) + throw (Config_Error) + { + 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 (), + "Failed to bind an IDRef. This likely indicates a name clash."); + } + + template <typename T> + void + IDREF_Base<T>::bind_next_available (ACE_CString &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 (), + "Failed to bind an IDRef. This likely indicates a name clash"); + + } + + template <typename T> + void + IDREF_Base<T>::find_ref (const ACE_CString& id, T& val) + throw (Config_Error) + { + 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 (), + "Unable to look up an IDRef."); + } + + template <typename T> + void + IDREF_Base<T>::find_ref (const T& value, ACE_CString& id) + throw (Config_Error) + { + 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 ("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/CIAO/tools/Config_Handlers/IDREF_Base.h b/CIAO/tools/Config_Handlers/IDREF_Base.h new file mode 100644 index 00000000000..85f0d3a4f22 --- /dev/null +++ b/CIAO/tools/Config_Handlers/IDREF_Base.h @@ -0,0 +1,92 @@ +/** +* $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_CString& id, T value) +throw (Config_Error); + +void bind_next_available (ACE_CString &id); + +/// Get the index associated with an IDREF +void find_ref (const ACE_CString& id, T& value) +throw (Config_Error); + +/// get the IDREF associated with an index +void find_ref (const T &value, ACE_CString& id) +throw (Config_Error); + +/// Unbind all IDREFS +bool +unbind_refs (void); + +typedef ACE_Hash_Map_Manager<ACE_CString, +T, +ACE_Null_Mutex> IDREF_MAP; + + +typedef ACE_Hash_Map_Manager<T, +ACE_CString, +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/CIAO/tools/Config_Handlers/ID_Handler.cpp b/CIAO/tools/Config_Handlers/ID_Handler.cpp new file mode 100644 index 00000000000..b2e888338e0 --- /dev/null +++ b/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/CIAO_common.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 (desc.requiredType ().c_str ()); + } + + ImplementationDependency + ID_Handler::impl_dependency ( + const ::Deployment::ImplementationDependency& src) + { + CIAO_TRACE("ID_Handler::get_ImplementationDependency - reverse"); + XMLSchema::string< char > reqtype ((src.requiredType)); + + ImplementationDependency id (reqtype); + + return id; + } + + } + +} diff --git a/CIAO/tools/Config_Handlers/ID_Handler.h b/CIAO/tools/Config_Handlers/ID_Handler.h new file mode 100644 index 00000000000..bea6ec2b1a6 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/IRDD_Handler.cpp b/CIAO/tools/Config_Handlers/IRDD_Handler.cpp new file mode 100644 index 00000000000..97443a495ba --- /dev/null +++ b/CIAO/tools/Config_Handlers/IRDD_Handler.cpp @@ -0,0 +1,121 @@ +// $Id$ + +#include "IRDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Property_Handler.h" +#include "ciao/CIAO_common.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) + throw (Config_Error) + { + 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 (), + "Unknown ResourceUsageKind."); + break; + } + + toconfig.requirementName = desc.requirementName ().c_str (); + + toconfig.resourceName= 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) + throw (Config_Error) + { + CIAO_TRACE("IRDD_Handler::instance_resource_deployment_descr - reverse"); + + XMLSchema::string< char > reqname ((src.requirementName)); + XMLSchema::string< char > resname ((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 (src.resourceName.in (), + "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/CIAO/tools/Config_Handlers/IRDD_Handler.h b/CIAO/tools/Config_Handlers/IRDD_Handler.h new file mode 100644 index 00000000000..0b85306d2ce --- /dev/null +++ b/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 "Common.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 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/CIAO/tools/Config_Handlers/MDD_Handler.cpp b/CIAO/tools/Config_Handlers/MDD_Handler.cpp new file mode 100644 index 00000000000..b0c5f7cfe94 --- /dev/null +++ b/CIAO/tools/Config_Handlers/MDD_Handler.cpp @@ -0,0 +1,177 @@ +// $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 (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 ((*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_CString (ab->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_CString 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 < char > name ((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< char > curr ((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_CString tmp; + ADD_Handler::IDREF.find_ref(src.artifactRef[j], tmp); + XMLSchema::IDREF< ACE_TCHAR > curr(tmp.c_str()); + mdd.add_artifact (curr); + } + + //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 ()->generateUUID (uuid); + ACE_CString mdd_id ("_"); + mdd_id += *uuid.to_string (); + + 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/CIAO/tools/Config_Handlers/MDD_Handler.h b/CIAO/tools/Config_Handlers/MDD_Handler.h new file mode 100644 index 00000000000..2d95ff71e2d --- /dev/null +++ b/CIAO/tools/Config_Handlers/MDD_Handler.h @@ -0,0 +1,71 @@ +//============================================================== +/** +* @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/CIAO/tools/Config_Handlers/PCD_Handler.cpp b/CIAO/tools/Config_Handlers/PCD_Handler.cpp new file mode 100644 index 00000000000..071194d778a --- /dev/null +++ b/CIAO/tools/Config_Handlers/PCD_Handler.cpp @@ -0,0 +1,140 @@ +// $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/CIAO_common.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 (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] = 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< char > name ((src.name)); + + PlanConnectionDescription pcd(name); + + //Get the source if it exists + if(src.source.length() != 0) + { + XMLSchema::string< char > source((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/CIAO/tools/Config_Handlers/PCD_Handler.h b/CIAO/tools/Config_Handlers/PCD_Handler.h new file mode 100644 index 00000000000..3813fa2badc --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/PSPE_Handler.cpp b/CIAO/tools/Config_Handlers/PSPE_Handler.cpp new file mode 100644 index 00000000000..0da66acefd4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/PSPE_Handler.cpp @@ -0,0 +1,145 @@ +// $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 = + src.portName ().c_str (); + + if (src.provider_p ()) + { + dest.provider = src.provider () == "true"; + } + else + { + dest.provider = false; + } + + CORBA::ULong tmp = 0; + + IDD_Handler::IDREF.find_ref (ACE_CString (src.instance ().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< char > pname ((src.portName)); + XMLSchema::string< char > tval ("true"); + XMLSchema::string< char > prov (""); + ACE_CString id; + IDD_Handler::IDREF.find_ref(src.instanceRef, id); + XMLSchema::IDREF < ACE_TCHAR > idref(id.c_str()); + + if (src.provider) + prov = tval; + + PlanSubcomponentPortEndpoint pspe (pname, + CCMComponentPortKind::Facet, + idref); + 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/CIAO/tools/Config_Handlers/PSPE_Handler.h b/CIAO/tools/Config_Handlers/PSPE_Handler.h new file mode 100644 index 00000000000..aeb92da9eb0 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp new file mode 100644 index 00000000000..8907ce0b0b1 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp @@ -0,0 +1,266 @@ +// $Id$ + +#include "Package_Handlers/CAD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "cid.hpp" +#include "DAnCE/Deployment/DeploymentC.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 = desc.portName ().c_str (); + + ACE_CString str (desc.instance ().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_CString str; + SID_Handler::IDREF.find_ref (src.instanceRef, str); + + return SubcomponentPortEndpoint (src.portName.in (), + str.c_str ()); + } + }; + + 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 = 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 (src.name.in ()); + + 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])); + + 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 = desc.propertyName ().c_str (); + + ACE_CString str (desc.instance ().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_CString str; + SID_Handler::IDREF.find_ref (src.instanceRef, str); + + return SubcomponentPropertyReference (src.propertyName.in (), + str.c_str ()); + } + + }; + + 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 = desc.name ().c_str (); + toconfig.externalName = 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 (src.name.in (), + src.externalName.in ()); + + for (CORBA::ULong i = 0; i < src.delegatesTo.length (); ++i) + retval.add_delegatesTo (SPR_Handler::get_spr (src.delegatesTo[i])); + + 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; + + 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])); + + 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/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/CAD_Handler.h new file mode 100644 index 00000000000..139c24936ce --- /dev/null +++ b/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 "Utils/XML_Helper.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/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp new file mode 100644 index 00000000000..78d865eb366 --- /dev/null +++ b/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 "Utils/XML_Helper.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 = 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 (src.name.in ()); + + 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])); + + 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 (), + "Unknown ResourceUsageKind."); + break; + } + } + + if (desc.resourcePort_p ()) + toconfig.resourcePort = desc.resourcePort ().c_str (); + + if (desc.componentPort_p ()) + toconfig.componentPort = desc.componentPort ().c_str (); + + toconfig.resourceType = desc.resourceType ().c_str (); + toconfig.name = 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 (src.resourceType.in (), + 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 (src.name.in (), + "Unknown ResourceUsageKind."); + break; + } + + retval.resourcePort (src.resourcePort.in ()); + + retval.componentPort (src.componentPort.in ()); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (Property_Handler::get_property (src.property[i])); + + 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; + + 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])); + + 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 = cid->label ().c_str (); + + if (cid->UUID_p ()) + toconfig.UUID = 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 ("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 = 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 (src.label.in ()); + retval.UUID (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")); + + 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])); + } + + return retval; + } + + ComponentImplementationDescription * + CID_Handler::resolve_cid (const char *uri) + { + CIAO_TRACE ("CID_Handler::resolve_cid"); + + xercesc::DOMDocument *dom = XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for CID"); + + try { + return new ComponentImplementationDescription + (componentImplementationDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for CID"); + } + } + } + + } +} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.h new file mode 100644 index 00000000000..ef1263ad139 --- /dev/null +++ b/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 char *uri); + }; + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_PACKAGING_CID_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp new file mode 100644 index 00000000000..b857c893bf8 --- /dev/null +++ b/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 = 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 (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 = cpd->label ().c_str (); + + if (cpd->UUID_p ()) + toconfig.UUID = 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 (src.label.in ()); + + if (src.UUID.in () != 0) + toconfig.UUID (src.UUID.in ()); + + { + toconfig.realizes + (Comp_Intf_Descr_Handler::comp_intf_descr (src.realizes)); + } + + 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])); + } + + return toconfig; + } + + ComponentPackageDescription * CPD_Handler::resolve_cpd (const char *uri) + { + CIAO_TRACE ("CPD_Handler::resolve_cpd"); + if (!XML_HELPER->is_initialized ()) + return 0; + + xercesc::DOMDocument* dom = + XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for component package description"); + + try { + //ACE_ERROR ((LM_ERROR, "Creating new CPD XSC Object\n")); + return new ComponentPackageDescription (componentPackageDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for CID"); + } + } + } + + + } +} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/CPD_Handler.h new file mode 100644 index 00000000000..9535d24eef2 --- /dev/null +++ b/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 "Utils/XML_Helper.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 char *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/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp new file mode 100644 index 00000000000..f13260480ad --- /dev/null +++ b/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp @@ -0,0 +1,165 @@ +// $Id$ +#include "Comp_Intf_Descr_Handler.h" + +#include "Utils/XML_Helper.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/CIAO_common.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 = 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 (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 = cid->label ().c_str (); + + if (cid->UUID_p ()) + toconfig.UUID = cid->UUID ().c_str (); + + // MAJO: SpecificType should be required. + if (cid->specificType_p ()) + toconfig.specificType = 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 (src.label.in ()); + retval.UUID (src.UUID.in ()); + retval.specificType (src.specificType.in ()); + + 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])); + + return retval; + } + + ComponentInterfaceDescription * + Comp_Intf_Descr_Handler::resolve_cid (const char *uri) + { + CIAO_TRACE ("Comp_Intf_Descr_Handler::resolve_cid"); + + xercesc::DOMDocument *dom = XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for Component Interface Description."); + + try { + return new ComponentInterfaceDescription + (componentInterfaceDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for Component Interface Description"); + } + } + } + }} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h new file mode 100644 index 00000000000..02f07fbb438 --- /dev/null +++ b/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 "Utils/XML_Helper.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 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 char *uri); + }; + } + } +} + +#include /**/ "ace/post.h" + +#endif /* CIAO_PACKAGING_COMP_INTF_DESCR_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp new file mode 100644 index 00000000000..97aa436df82 --- /dev/null +++ b/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 "Utils/XML_Helper.h" + +#include "Deployment.hpp" +#include "ciao/CIAO_common.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 = iad->label ().c_str (); + + if (iad->UUID_p ()) + toconfig.UUID = 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 (src.label.in ()); + retval.UUID (src.UUID.in ()); + + 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])); + + return retval; + } + + ImplementationArtifactDescription * IAD_Handler::resolve_iad (const char *uri) + { + CIAO_TRACE ("IAD_Handler::resolve_iad"); + + xercesc::DOMDocument *dom = XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for IAD"); + + try { + return new ImplementationArtifactDescription + (implementationArtifactDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for IAD"); + } + } + + } + } +} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/IAD_Handler.h new file mode 100644 index 00000000000..869dbe25a8a --- /dev/null +++ b/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 char *uri); + }; + } + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_IAD_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/NIA_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/NIA_Handler.h new file mode 100644 index 00000000000..2f3f2845343 --- /dev/null +++ b/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 = desc.name ().c_str (); + IAD_Handler::impl_artifact_descr (desc.referencedArtifact (), + toconfig.referencedArtifact); + } + + + static NamedImplementationArtifact + get_nia (const ::Deployment::NamedImplementationArtifact &src) + { + return NamedImplementationArtifact (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/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp new file mode 100644 index 00000000000..d596adc6108 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp @@ -0,0 +1,163 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "ciao/CIAO_common.h" +#include "DAnCE/Deployment/Deployment_Packaging_DataC.h" +#include "Utils/XML_Helper.h" +#include "Utils/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> + +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->create_dom (uri); + + if (dom == 0) + { + std::string error ("Unable to open file: "); + error += uri; + throw Parse_Error (error); + } + + XStr root = dom->getDocumentElement ()->getTagName (); + + if (root == XStr ("Deployment:topLevelPackageDescription")) + { + TopLevelPackageDescription tpd; + + tpd = topLevelPackageDescription (dom); + + PCD_Handler::package_config (*tpd.begin_basePackage (), + toconfig); + } + else if (root == XStr ("Deployment:packageConfiguration")) + { + PackageConfiguration pcd; + pcd = 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 ("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 = + pcd->label ().c_str (); + + if (pcd->UUID_p ()) + toconfig.UUID = + 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 (src.label.in ()); + + if (src.UUID.in () != 0) + pcd.UUID (src.UUID.in ()); + + if (src.basePackage.length () > 0) + { + ACE_DEBUG ((LM_DEBUG, "5\n")); + pcd.basePackage (CPD_Handler::component_package_descr (src.basePackage[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])); + + return pcd; + + } + + PackageConfiguration * PCD_Handler::resolve_package_config (const char *uri) + { + xercesc::DOMDocument* dom = + XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for PackageConfiguration"); + + try { + return new PackageConfiguration (packageConfiguration (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for PackageConfiguration"); + } + + } + + + } + } +} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/PCD_Handler.h new file mode 100644 index 00000000000..be92a6871c0 --- /dev/null +++ b/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 char *uri); + }; + } + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.cpp new file mode 100644 index 00000000000..e265295d040 --- /dev/null +++ b/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/CIAO_common.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/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.h b/CIAO/tools/Config_Handlers/Package_Handlers/PC_Intf.h new file mode 100644 index 00000000000..c15ae0389b9 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc b/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc new file mode 100644 index 00000000000..7f4b68c5247 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc @@ -0,0 +1,54 @@ +// $Id$ + +project (Package_Config_Handlers) : acelib, ciao_deployment_stub, ciao_config_handlers_base { + sharedname = Package_Config_Handlers + dynamicflags = PACKAGING_HANDLERS_BUILD_DLL + avoids += ace_for_tao + + includes += $(CIAO_ROOT)/ciao + + after += XSC_Config_Handlers_Common \ + XSC_Config_Handlers \ + XSC_DynAny_Handler \ + XSC_XML_Handlers \ + CIAO_XML_Utils \ + CIAO_Events_Handlers + + libs += XSC_Config_Handlers_Common \ + XSC_Config_Handlers \ + XSC_DynAny_Handler \ + XSC_XML_Handlers \ + CIAO_XML_Utils \ + CIAO_Events_Handlers RT_CCM_Config_Handlers + + 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) : ciao_component_dnc, ciao_config_handlers, ifr_client { + exename = test + macros += XML_USE_PTHREADS + avoids += ace_for_tao + + Source_Files { + test.cpp + } +} diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/Packaging_Handlers_Export.h b/CIAO/tools/Config_Handlers/Package_Handlers/Packaging_Handlers_Export.h new file mode 100644 index 00000000000..86193a1a664 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp new file mode 100644 index 00000000000..c89325ed467 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp @@ -0,0 +1,140 @@ +// $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 "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 = 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 = + desc.referencedPackage ().requiredUUID ().c_str (); + + if (desc.referencedPackage ().requiredName_p ()) + toconfig.referencedPackage[0].requiredName = + desc.referencedPackage ().requiredName ().c_str (); + + toconfig.referencedPackage[0].requiredType = + desc.referencedPackage ().requiredType ().c_str (); + } + + 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_CString str (desc.id ().c_str ()); + SID_Handler::IDREF.bind_next_available (str); + } + else + ACE_ERROR ((LM_ERROR, "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 (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; + + for (CORBA::ULong i = 0; i < src.importedPackage[0].location.length (); ++i) + ci.add_location (src.importedPackage[0].location[i].in ()); + + retval.importedPackage (ci); + } + else if (src.referencedPackage.length () == 1) + { + ComponentPackageReference cpr (src.referencedPackage[0].requiredType.in ()); + cpr.requiredUUID (src.referencedPackage[0].requiredUUID.in ()); + cpr.requiredName (src.referencedPackage[0].requiredName.in ()); + + retval.referencedPackage (cpr); + } + + 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])); + + // @@MAJO This is not a good way of binding reverse IDREFS. + std::auto_ptr <ACE_Utils::UUID> safe_uuid ( + ACE_Utils::UUID_GENERATOR::instance ()->generateUUID ()); + ACE_CString uuid ( 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/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.h b/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.h new file mode 100644 index 00000000000..1bcb73e751e --- /dev/null +++ b/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 "Utils/XML_Helper.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/CIAO/tools/Config_Handlers/Package_Handlers/test.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/test.cpp new file mode 100644 index 00000000000..6812dc20114 --- /dev/null +++ b/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 main (int argc, char *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/CIAO/tools/Config_Handlers/Property_Handler.cpp b/CIAO/tools/Config_Handlers/Property_Handler.cpp new file mode 100644 index 00000000000..ef077426a16 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Property_Handler.cpp @@ -0,0 +1,51 @@ +//$Id$ + +#include "Property_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/CIAO_common.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"); + + toconfig.name = + CORBA::string_dup (desc.name ().c_str ()); + + Any_Handler::extract_into_any (desc.value (), + toconfig.value); + + } + + Property + Property_Handler::get_property ( + const Deployment::Property& src) + { + CIAO_TRACE("Property_Handler::get_property - reverse"); + + ::XMLSchema::string< char > name ((src.name)); + Any value (Any_Handler::get_any (src.value)); + + Property prop (name,value); + + return prop; + } + + } +} diff --git a/CIAO/tools/Config_Handlers/Property_Handler.h b/CIAO/tools/Config_Handlers/Property_Handler.h new file mode 100644 index 00000000000..6da0530f8a8 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/RDD_Handler.cpp b/CIAO/tools/Config_Handlers/RDD_Handler.cpp new file mode 100644 index 00000000000..28ddc5ec7cf --- /dev/null +++ b/CIAO/tools/Config_Handlers/RDD_Handler.cpp @@ -0,0 +1,57 @@ +// $Id$ + +#include "RDD_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "Any_Handler.h" +#include "ciao/CIAO_common.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 = + src.requirementName ().c_str (); + + dest.resourceName= + 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< char > reqname ((src.requirementName)); + XMLSchema::string< char > resname ((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/CIAO/tools/Config_Handlers/RDD_Handler.h b/CIAO/tools/Config_Handlers/RDD_Handler.h new file mode 100644 index 00000000000..e0d19c58ee2 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.cpp new file mode 100644 index 00000000000..85a06851d78 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.cpp @@ -0,0 +1,70 @@ +// $Id$ + +#include "CB_Handler.h" +#include "CIAOServerResources.hpp" +#include "ace/Basic_Types.h" + +namespace CIAO +{ + namespace Config_Handlers + { + // IDREF_Base CB_Handler::IDREF; + + bool + CB_Handler::connection_band (const ConnectionBandsDef &src, + ::CIAO::DAnCE::ORS_ConnectionBands &dest) + { + // Set the number of bands + CORBA::ULong num (dest.bands.length ()); + dest.bands.length (num + src.count_band ()); + + for (ConnectionBandsDef::band_const_iterator i = src.begin_band (); + i != src.end_band (); + ++i) + { + dest.bands[num].low = static_cast <ACE_INT32> ((i->low ())); + dest.bands[num].high = static_cast < ACE_INT32 > (i->high ()); + num++; + } + + if (src.id_p ()) + { + /* + ACE_CString cstr (src.id ().c_str ()); + if (!IDD_Handler::IDREF.bind_ref (cstr, dest)) + return false; + */ + dest.Id = CORBA::string_dup (src.id ().c_str ()); + } + + return true; + } + + + ConnectionBandsDef + CB_Handler::connection_band (const ::CIAO::DAnCE::ORS_ConnectionBands &src) + { + ConnectionBandsDef cb; + + for (CORBA::ULong i = 0; + i < src.bands.length (); + ++i) + { + cb.add_band (PriorityBandDef (src.bands[i].low, + src.bands[i].high)); + } + + /* + ACE_CString cstr; + if (CB_Handler::IDREF.find_ref (src, cstr)) + cb->id (cstr.c_str ()); + */ + + if (src.Id.in () != 0) + cb.id (src.Id.in ()); + + return cb; + } + + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.h new file mode 100644 index 00000000000..9c1363ab420 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CB_Handler.h @@ -0,0 +1,48 @@ +/** + * @file CB_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + + + +#ifndef CIAO_CONFIG_HANDLERS_CB_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CB_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" +#include "IDREF_Base.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class ConnectionBandsDef; + + /* + * @class CB_Handler + * A brief Handler class for <ConnectionBands> + */ + + class RT_CCM_Handlers_Export CB_Handler + { + public: + static bool connection_band (const ConnectionBandsDef &src, + ::CIAO::DAnCE::ORS_ConnectionBands &dest); + + static ConnectionBandsDef connection_band (const ::CIAO::DAnCE::ORS_ConnectionBands &src); + + // static IDREF_Base<::CIAO::DAnCE::ORS_ConnectionBands> IDREF; + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CB_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.cpp b/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.cpp new file mode 100644 index 00000000000..01f192d5201 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.cpp @@ -0,0 +1,5890 @@ +/* $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 "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + // ServerResourcesDef + // + + ServerResourcesDef:: + ServerResourcesDef (::CIAO::Config_Handlers::ORBConfigs const& orbConfigs__) + : + ::XSCRT::Type (), + orbConfigs_ (new ::CIAO::Config_Handlers::ORBConfigs (orbConfigs__)), + regulator__ () + { + orbConfigs_->container (this); + } + + ServerResourcesDef:: + ServerResourcesDef (::CIAO::Config_Handlers::ServerResourcesDef const& s) + : + ::XSCRT::Type (), + cmdline_ (s.cmdline_.get () ? new ::CIAO::Config_Handlers::ServerCmdlineOptions (*s.cmdline_) : 0), + svcconf_ (s.svcconf_.get () ? new ::CIAO::Config_Handlers::ACESvcConf (*s.svcconf_) : 0), + orbConfigs_ (new ::CIAO::Config_Handlers::ORBConfigs (*s.orbConfigs_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + if (cmdline_.get ()) cmdline_->container (this); + if (svcconf_.get ()) svcconf_->container (this); + orbConfigs_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ServerResourcesDef& ServerResourcesDef:: + operator= (::CIAO::Config_Handlers::ServerResourcesDef const& s) + { + if (s.cmdline_.get ()) cmdline (*(s.cmdline_)); + else cmdline_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ServerCmdlineOptions > (0); + + if (s.svcconf_.get ()) svcconf (*(s.svcconf_)); + else svcconf_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ACESvcConf > (0); + + orbConfigs (s.orbConfigs ()); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ServerResourcesDef + // + bool ServerResourcesDef:: + cmdline_p () const + { + return cmdline_.get () != 0; + } + + ::CIAO::Config_Handlers::ServerCmdlineOptions const& ServerResourcesDef:: + cmdline () const + { + return *cmdline_; + } + + void ServerResourcesDef:: + cmdline (::CIAO::Config_Handlers::ServerCmdlineOptions const& e) + { + if (cmdline_.get ()) + { + *cmdline_ = e; + } + + else + { + cmdline_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ServerCmdlineOptions > (new ::CIAO::Config_Handlers::ServerCmdlineOptions (e)); + cmdline_->container (this); + } + } + + // ServerResourcesDef + // + bool ServerResourcesDef:: + svcconf_p () const + { + return svcconf_.get () != 0; + } + + ::CIAO::Config_Handlers::ACESvcConf const& ServerResourcesDef:: + svcconf () const + { + return *svcconf_; + } + + void ServerResourcesDef:: + svcconf (::CIAO::Config_Handlers::ACESvcConf const& e) + { + if (svcconf_.get ()) + { + *svcconf_ = e; + } + + else + { + svcconf_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ACESvcConf > (new ::CIAO::Config_Handlers::ACESvcConf (e)); + svcconf_->container (this); + } + } + + // ServerResourcesDef + // + ::CIAO::Config_Handlers::ORBConfigs const& ServerResourcesDef:: + orbConfigs () const + { + return *orbConfigs_; + } + + void ServerResourcesDef:: + orbConfigs (::CIAO::Config_Handlers::ORBConfigs const& e) + { + *orbConfigs_ = e; + } + + // ServerResourcesDef + // + bool ServerResourcesDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ServerResourcesDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ServerResourcesDef:: + id () + { + return *id_; + } + + void ServerResourcesDef:: + 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); + } + } + + + // ServerCmdlineOptions + // + + ServerCmdlineOptions:: + ServerCmdlineOptions () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ServerCmdlineOptions:: + ServerCmdlineOptions (::CIAO::Config_Handlers::ServerCmdlineOptions const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (arg_const_iterator i (s.arg_.begin ());i != s.arg_.end ();++i) add_arg (*i); + } + } + + ::CIAO::Config_Handlers::ServerCmdlineOptions& ServerCmdlineOptions:: + operator= (::CIAO::Config_Handlers::ServerCmdlineOptions const& s) + { + arg_.clear (); + { + for (arg_const_iterator i (s.arg_.begin ());i != s.arg_.end ();++i) add_arg (*i); + } + + return *this; + } + + + // ServerCmdlineOptions + // + ServerCmdlineOptions::arg_iterator ServerCmdlineOptions:: + begin_arg () + { + return arg_.begin (); + } + + ServerCmdlineOptions::arg_iterator ServerCmdlineOptions:: + end_arg () + { + return arg_.end (); + } + + ServerCmdlineOptions::arg_const_iterator ServerCmdlineOptions:: + begin_arg () const + { + return arg_.begin (); + } + + ServerCmdlineOptions::arg_const_iterator ServerCmdlineOptions:: + end_arg () const + { + return arg_.end (); + } + + void ServerCmdlineOptions:: + add_arg (::XMLSchema::string< ACE_TCHAR > const& e) + { + arg_.push_back (e); + } + + size_t ServerCmdlineOptions:: + count_arg(void) const + { + return arg_.size (); + } + + + // ACESvcConf + // + + ACESvcConf:: + ACESvcConf () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ACESvcConf:: + ACESvcConf (::CIAO::Config_Handlers::ACESvcConf const& s) + : + ::XSCRT::Type (), + uri_ (s.uri_.get () ? new ::XMLSchema::string< ACE_TCHAR > (*s.uri_) : 0), + regulator__ () + { + if (uri_.get ()) uri_->container (this); + } + + ::CIAO::Config_Handlers::ACESvcConf& ACESvcConf:: + operator= (::CIAO::Config_Handlers::ACESvcConf const& s) + { + if (s.uri_.get ()) uri (*(s.uri_)); + else uri_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + return *this; + } + + + // ACESvcConf + // + bool ACESvcConf:: + uri_p () const + { + return uri_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ACESvcConf:: + uri () const + { + return *uri_; + } + + void ACESvcConf:: + uri (::XMLSchema::string< ACE_TCHAR > const& e) + { + if (uri_.get ()) + { + *uri_ = e; + } + + else + { + uri_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + uri_->container (this); + } + } + + + // ORBConfigs + // + + ORBConfigs:: + ORBConfigs () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ORBConfigs:: + ORBConfigs (::CIAO::Config_Handlers::ORBConfigs const& s) + : + ::XSCRT::Type (), + resources_ (s.resources_.get () ? new ::CIAO::Config_Handlers::ORBResources (*s.resources_) : 0), + regulator__ () + { + if (resources_.get ()) resources_->container (this); + { + for (policySet_const_iterator i (s.policySet_.begin ());i != s.policySet_.end ();++i) add_policySet (*i); + } + } + + ::CIAO::Config_Handlers::ORBConfigs& ORBConfigs:: + operator= (::CIAO::Config_Handlers::ORBConfigs const& s) + { + if (s.resources_.get ()) resources (*(s.resources_)); + else resources_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ORBResources > (0); + + policySet_.clear (); + { + for (policySet_const_iterator i (s.policySet_.begin ());i != s.policySet_.end ();++i) add_policySet (*i); + } + + return *this; + } + + + // ORBConfigs + // + bool ORBConfigs:: + resources_p () const + { + return resources_.get () != 0; + } + + ::CIAO::Config_Handlers::ORBResources const& ORBConfigs:: + resources () const + { + return *resources_; + } + + void ORBConfigs:: + resources (::CIAO::Config_Handlers::ORBResources const& e) + { + if (resources_.get ()) + { + *resources_ = e; + } + + else + { + resources_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ORBResources > (new ::CIAO::Config_Handlers::ORBResources (e)); + resources_->container (this); + } + } + + // ORBConfigs + // + ORBConfigs::policySet_iterator ORBConfigs:: + begin_policySet () + { + return policySet_.begin (); + } + + ORBConfigs::policySet_iterator ORBConfigs:: + end_policySet () + { + return policySet_.end (); + } + + ORBConfigs::policySet_const_iterator ORBConfigs:: + begin_policySet () const + { + return policySet_.begin (); + } + + ORBConfigs::policySet_const_iterator ORBConfigs:: + end_policySet () const + { + return policySet_.end (); + } + + void ORBConfigs:: + add_policySet (::CIAO::Config_Handlers::PolicySet const& e) + { + policySet_.push_back (e); + } + + size_t ORBConfigs:: + count_policySet(void) const + { + return policySet_.size (); + } + + + // ORBResources + // + + ORBResources:: + ORBResources () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ORBResources:: + ORBResources (::CIAO::Config_Handlers::ORBResources const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (threadpool_const_iterator i (s.threadpool_.begin ());i != s.threadpool_.end ();++i) add_threadpool (*i); + } + + { + for (threadpoolWithLanes_const_iterator i (s.threadpoolWithLanes_.begin ());i != s.threadpoolWithLanes_.end ();++i) add_threadpoolWithLanes (*i); + } + + { + for (connectionBands_const_iterator i (s.connectionBands_.begin ());i != s.connectionBands_.end ();++i) add_connectionBands (*i); + } + } + + ::CIAO::Config_Handlers::ORBResources& ORBResources:: + operator= (::CIAO::Config_Handlers::ORBResources const& s) + { + threadpool_.clear (); + { + for (threadpool_const_iterator i (s.threadpool_.begin ());i != s.threadpool_.end ();++i) add_threadpool (*i); + } + + threadpoolWithLanes_.clear (); + { + for (threadpoolWithLanes_const_iterator i (s.threadpoolWithLanes_.begin ());i != s.threadpoolWithLanes_.end ();++i) add_threadpoolWithLanes (*i); + } + + connectionBands_.clear (); + { + for (connectionBands_const_iterator i (s.connectionBands_.begin ());i != s.connectionBands_.end ();++i) add_connectionBands (*i); + } + + return *this; + } + + + // ORBResources + // + ORBResources::threadpool_iterator ORBResources:: + begin_threadpool () + { + return threadpool_.begin (); + } + + ORBResources::threadpool_iterator ORBResources:: + end_threadpool () + { + return threadpool_.end (); + } + + ORBResources::threadpool_const_iterator ORBResources:: + begin_threadpool () const + { + return threadpool_.begin (); + } + + ORBResources::threadpool_const_iterator ORBResources:: + end_threadpool () const + { + return threadpool_.end (); + } + + void ORBResources:: + add_threadpool (::CIAO::Config_Handlers::ThreadpoolDef const& e) + { + threadpool_.push_back (e); + } + + size_t ORBResources:: + count_threadpool(void) const + { + return threadpool_.size (); + } + + // ORBResources + // + ORBResources::threadpoolWithLanes_iterator ORBResources:: + begin_threadpoolWithLanes () + { + return threadpoolWithLanes_.begin (); + } + + ORBResources::threadpoolWithLanes_iterator ORBResources:: + end_threadpoolWithLanes () + { + return threadpoolWithLanes_.end (); + } + + ORBResources::threadpoolWithLanes_const_iterator ORBResources:: + begin_threadpoolWithLanes () const + { + return threadpoolWithLanes_.begin (); + } + + ORBResources::threadpoolWithLanes_const_iterator ORBResources:: + end_threadpoolWithLanes () const + { + return threadpoolWithLanes_.end (); + } + + void ORBResources:: + add_threadpoolWithLanes (::CIAO::Config_Handlers::ThreadpoolWithLanesDef const& e) + { + threadpoolWithLanes_.push_back (e); + } + + size_t ORBResources:: + count_threadpoolWithLanes(void) const + { + return threadpoolWithLanes_.size (); + } + + // ORBResources + // + ORBResources::connectionBands_iterator ORBResources:: + begin_connectionBands () + { + return connectionBands_.begin (); + } + + ORBResources::connectionBands_iterator ORBResources:: + end_connectionBands () + { + return connectionBands_.end (); + } + + ORBResources::connectionBands_const_iterator ORBResources:: + begin_connectionBands () const + { + return connectionBands_.begin (); + } + + ORBResources::connectionBands_const_iterator ORBResources:: + end_connectionBands () const + { + return connectionBands_.end (); + } + + void ORBResources:: + add_connectionBands (::CIAO::Config_Handlers::ConnectionBandsDef const& e) + { + connectionBands_.push_back (e); + } + + size_t ORBResources:: + count_connectionBands(void) const + { + return connectionBands_.size (); + } + + + // ThreadpoolDef + // + + ThreadpoolDef:: + ThreadpoolDef (::XMLSchema::unsignedLong const& stacksize__, + ::XMLSchema::unsignedLong const& static_threads__, + ::XMLSchema::unsignedLong const& dynamic_threads__, + ::XMLSchema::int_ const& default_priority__, + ::XMLSchema::boolean const& allow_request_buffering__, + ::XMLSchema::unsignedLong const& max_buffered_requests__, + ::XMLSchema::unsignedLong const& max_request_buffered_size__) + : + ::XSCRT::Type (), + stacksize_ (new ::XMLSchema::unsignedLong (stacksize__)), + static_threads_ (new ::XMLSchema::unsignedLong (static_threads__)), + dynamic_threads_ (new ::XMLSchema::unsignedLong (dynamic_threads__)), + default_priority_ (new ::XMLSchema::int_ (default_priority__)), + allow_request_buffering_ (new ::XMLSchema::boolean (allow_request_buffering__)), + max_buffered_requests_ (new ::XMLSchema::unsignedLong (max_buffered_requests__)), + max_request_buffered_size_ (new ::XMLSchema::unsignedLong (max_request_buffered_size__)), + regulator__ () + { + stacksize_->container (this); + static_threads_->container (this); + dynamic_threads_->container (this); + default_priority_->container (this); + allow_request_buffering_->container (this); + max_buffered_requests_->container (this); + max_request_buffered_size_->container (this); + } + + ThreadpoolDef:: + ThreadpoolDef (::CIAO::Config_Handlers::ThreadpoolDef const& s) + : + ::XSCRT::Type (), + stacksize_ (new ::XMLSchema::unsignedLong (*s.stacksize_)), + static_threads_ (new ::XMLSchema::unsignedLong (*s.static_threads_)), + dynamic_threads_ (new ::XMLSchema::unsignedLong (*s.dynamic_threads_)), + default_priority_ (new ::XMLSchema::int_ (*s.default_priority_)), + allow_request_buffering_ (new ::XMLSchema::boolean (*s.allow_request_buffering_)), + max_buffered_requests_ (new ::XMLSchema::unsignedLong (*s.max_buffered_requests_)), + max_request_buffered_size_ (new ::XMLSchema::unsignedLong (*s.max_request_buffered_size_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + stacksize_->container (this); + static_threads_->container (this); + dynamic_threads_->container (this); + default_priority_->container (this); + allow_request_buffering_->container (this); + max_buffered_requests_->container (this); + max_request_buffered_size_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ThreadpoolDef& ThreadpoolDef:: + operator= (::CIAO::Config_Handlers::ThreadpoolDef const& s) + { + stacksize (s.stacksize ()); + + static_threads (s.static_threads ()); + + dynamic_threads (s.dynamic_threads ()); + + default_priority (s.default_priority ()); + + allow_request_buffering (s.allow_request_buffering ()); + + max_buffered_requests (s.max_buffered_requests ()); + + max_request_buffered_size (s.max_request_buffered_size ()); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ThreadpoolDef + // + ::XMLSchema::unsignedLong const& ThreadpoolDef:: + stacksize () const + { + return *stacksize_; + } + + void ThreadpoolDef:: + stacksize (::XMLSchema::unsignedLong const& e) + { + *stacksize_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::unsignedLong const& ThreadpoolDef:: + static_threads () const + { + return *static_threads_; + } + + void ThreadpoolDef:: + static_threads (::XMLSchema::unsignedLong const& e) + { + *static_threads_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::unsignedLong const& ThreadpoolDef:: + dynamic_threads () const + { + return *dynamic_threads_; + } + + void ThreadpoolDef:: + dynamic_threads (::XMLSchema::unsignedLong const& e) + { + *dynamic_threads_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::int_ const& ThreadpoolDef:: + default_priority () const + { + return *default_priority_; + } + + void ThreadpoolDef:: + default_priority (::XMLSchema::int_ const& e) + { + *default_priority_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::boolean const& ThreadpoolDef:: + allow_request_buffering () const + { + return *allow_request_buffering_; + } + + void ThreadpoolDef:: + allow_request_buffering (::XMLSchema::boolean const& e) + { + *allow_request_buffering_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::unsignedLong const& ThreadpoolDef:: + max_buffered_requests () const + { + return *max_buffered_requests_; + } + + void ThreadpoolDef:: + max_buffered_requests (::XMLSchema::unsignedLong const& e) + { + *max_buffered_requests_ = e; + } + + // ThreadpoolDef + // + ::XMLSchema::unsignedLong const& ThreadpoolDef:: + max_request_buffered_size () const + { + return *max_request_buffered_size_; + } + + void ThreadpoolDef:: + max_request_buffered_size (::XMLSchema::unsignedLong const& e) + { + *max_request_buffered_size_ = e; + } + + // ThreadpoolDef + // + bool ThreadpoolDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ThreadpoolDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ThreadpoolDef:: + id () + { + return *id_; + } + + void ThreadpoolDef:: + 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); + } + } + + + // ThreadpoolWithLanesDef + // + + ThreadpoolWithLanesDef:: + ThreadpoolWithLanesDef (::XMLSchema::unsignedLong const& stacksize__, + ::XMLSchema::boolean const& allow_borrowing__, + ::XMLSchema::boolean const& allow_request_buffering__, + ::XMLSchema::unsignedLong const& max_buffered_requests__, + ::XMLSchema::unsignedLong const& max_request_buffered_size__) + : + ::XSCRT::Type (), + stacksize_ (new ::XMLSchema::unsignedLong (stacksize__)), + allow_borrowing_ (new ::XMLSchema::boolean (allow_borrowing__)), + allow_request_buffering_ (new ::XMLSchema::boolean (allow_request_buffering__)), + max_buffered_requests_ (new ::XMLSchema::unsignedLong (max_buffered_requests__)), + max_request_buffered_size_ (new ::XMLSchema::unsignedLong (max_request_buffered_size__)), + regulator__ () + { + stacksize_->container (this); + allow_borrowing_->container (this); + allow_request_buffering_->container (this); + max_buffered_requests_->container (this); + max_request_buffered_size_->container (this); + } + + ThreadpoolWithLanesDef:: + ThreadpoolWithLanesDef (::CIAO::Config_Handlers::ThreadpoolWithLanesDef const& s) + : + ::XSCRT::Type (), + stacksize_ (new ::XMLSchema::unsignedLong (*s.stacksize_)), + allow_borrowing_ (new ::XMLSchema::boolean (*s.allow_borrowing_)), + allow_request_buffering_ (new ::XMLSchema::boolean (*s.allow_request_buffering_)), + max_buffered_requests_ (new ::XMLSchema::unsignedLong (*s.max_buffered_requests_)), + max_request_buffered_size_ (new ::XMLSchema::unsignedLong (*s.max_request_buffered_size_)), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + { + for (threadpoolLane_const_iterator i (s.threadpoolLane_.begin ());i != s.threadpoolLane_.end ();++i) add_threadpoolLane (*i); + } + + stacksize_->container (this); + allow_borrowing_->container (this); + allow_request_buffering_->container (this); + max_buffered_requests_->container (this); + max_request_buffered_size_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ThreadpoolWithLanesDef& ThreadpoolWithLanesDef:: + operator= (::CIAO::Config_Handlers::ThreadpoolWithLanesDef const& s) + { + threadpoolLane_.clear (); + { + for (threadpoolLane_const_iterator i (s.threadpoolLane_.begin ());i != s.threadpoolLane_.end ();++i) add_threadpoolLane (*i); + } + + stacksize (s.stacksize ()); + + allow_borrowing (s.allow_borrowing ()); + + allow_request_buffering (s.allow_request_buffering ()); + + max_buffered_requests (s.max_buffered_requests ()); + + max_request_buffered_size (s.max_request_buffered_size ()); + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ThreadpoolWithLanesDef + // + ThreadpoolWithLanesDef::threadpoolLane_iterator ThreadpoolWithLanesDef:: + begin_threadpoolLane () + { + return threadpoolLane_.begin (); + } + + ThreadpoolWithLanesDef::threadpoolLane_iterator ThreadpoolWithLanesDef:: + end_threadpoolLane () + { + return threadpoolLane_.end (); + } + + ThreadpoolWithLanesDef::threadpoolLane_const_iterator ThreadpoolWithLanesDef:: + begin_threadpoolLane () const + { + return threadpoolLane_.begin (); + } + + ThreadpoolWithLanesDef::threadpoolLane_const_iterator ThreadpoolWithLanesDef:: + end_threadpoolLane () const + { + return threadpoolLane_.end (); + } + + void ThreadpoolWithLanesDef:: + add_threadpoolLane (::CIAO::Config_Handlers::ThreadpoolLaneDef const& e) + { + threadpoolLane_.push_back (e); + } + + size_t ThreadpoolWithLanesDef:: + count_threadpoolLane(void) const + { + return threadpoolLane_.size (); + } + + // ThreadpoolWithLanesDef + // + ::XMLSchema::unsignedLong const& ThreadpoolWithLanesDef:: + stacksize () const + { + return *stacksize_; + } + + void ThreadpoolWithLanesDef:: + stacksize (::XMLSchema::unsignedLong const& e) + { + *stacksize_ = e; + } + + // ThreadpoolWithLanesDef + // + ::XMLSchema::boolean const& ThreadpoolWithLanesDef:: + allow_borrowing () const + { + return *allow_borrowing_; + } + + void ThreadpoolWithLanesDef:: + allow_borrowing (::XMLSchema::boolean const& e) + { + *allow_borrowing_ = e; + } + + // ThreadpoolWithLanesDef + // + ::XMLSchema::boolean const& ThreadpoolWithLanesDef:: + allow_request_buffering () const + { + return *allow_request_buffering_; + } + + void ThreadpoolWithLanesDef:: + allow_request_buffering (::XMLSchema::boolean const& e) + { + *allow_request_buffering_ = e; + } + + // ThreadpoolWithLanesDef + // + ::XMLSchema::unsignedLong const& ThreadpoolWithLanesDef:: + max_buffered_requests () const + { + return *max_buffered_requests_; + } + + void ThreadpoolWithLanesDef:: + max_buffered_requests (::XMLSchema::unsignedLong const& e) + { + *max_buffered_requests_ = e; + } + + // ThreadpoolWithLanesDef + // + ::XMLSchema::unsignedLong const& ThreadpoolWithLanesDef:: + max_request_buffered_size () const + { + return *max_request_buffered_size_; + } + + void ThreadpoolWithLanesDef:: + max_request_buffered_size (::XMLSchema::unsignedLong const& e) + { + *max_request_buffered_size_ = e; + } + + // ThreadpoolWithLanesDef + // + bool ThreadpoolWithLanesDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ThreadpoolWithLanesDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ThreadpoolWithLanesDef:: + id () + { + return *id_; + } + + void ThreadpoolWithLanesDef:: + 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); + } + } + + + // ThreadpoolLaneDef + // + + ThreadpoolLaneDef:: + ThreadpoolLaneDef (::XMLSchema::unsignedLong const& static_threads__, + ::XMLSchema::unsignedLong const& dynamic_threads__, + ::XMLSchema::int_ const& priority__) + : + ::XSCRT::Type (), + static_threads_ (new ::XMLSchema::unsignedLong (static_threads__)), + dynamic_threads_ (new ::XMLSchema::unsignedLong (dynamic_threads__)), + priority_ (new ::XMLSchema::int_ (priority__)), + regulator__ () + { + static_threads_->container (this); + dynamic_threads_->container (this); + priority_->container (this); + } + + ThreadpoolLaneDef:: + ThreadpoolLaneDef (::CIAO::Config_Handlers::ThreadpoolLaneDef const& s) + : + ::XSCRT::Type (), + static_threads_ (new ::XMLSchema::unsignedLong (*s.static_threads_)), + dynamic_threads_ (new ::XMLSchema::unsignedLong (*s.dynamic_threads_)), + priority_ (new ::XMLSchema::int_ (*s.priority_)), + regulator__ () + { + static_threads_->container (this); + dynamic_threads_->container (this); + priority_->container (this); + } + + ::CIAO::Config_Handlers::ThreadpoolLaneDef& ThreadpoolLaneDef:: + operator= (::CIAO::Config_Handlers::ThreadpoolLaneDef const& s) + { + static_threads (s.static_threads ()); + + dynamic_threads (s.dynamic_threads ()); + + priority (s.priority ()); + + return *this; + } + + + // ThreadpoolLaneDef + // + ::XMLSchema::unsignedLong const& ThreadpoolLaneDef:: + static_threads () const + { + return *static_threads_; + } + + void ThreadpoolLaneDef:: + static_threads (::XMLSchema::unsignedLong const& e) + { + *static_threads_ = e; + } + + // ThreadpoolLaneDef + // + ::XMLSchema::unsignedLong const& ThreadpoolLaneDef:: + dynamic_threads () const + { + return *dynamic_threads_; + } + + void ThreadpoolLaneDef:: + dynamic_threads (::XMLSchema::unsignedLong const& e) + { + *dynamic_threads_ = e; + } + + // ThreadpoolLaneDef + // + ::XMLSchema::int_ const& ThreadpoolLaneDef:: + priority () const + { + return *priority_; + } + + void ThreadpoolLaneDef:: + priority (::XMLSchema::int_ const& e) + { + *priority_ = e; + } + + + // ConnectionBandsDef + // + + ConnectionBandsDef:: + ConnectionBandsDef () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ConnectionBandsDef:: + ConnectionBandsDef (::CIAO::Config_Handlers::ConnectionBandsDef const& s) + : + ::XSCRT::Type (), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + { + for (band_const_iterator i (s.band_.begin ());i != s.band_.end ();++i) add_band (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::ConnectionBandsDef& ConnectionBandsDef:: + operator= (::CIAO::Config_Handlers::ConnectionBandsDef const& s) + { + band_.clear (); + { + for (band_const_iterator i (s.band_.begin ());i != s.band_.end ();++i) add_band (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // ConnectionBandsDef + // + ConnectionBandsDef::band_iterator ConnectionBandsDef:: + begin_band () + { + return band_.begin (); + } + + ConnectionBandsDef::band_iterator ConnectionBandsDef:: + end_band () + { + return band_.end (); + } + + ConnectionBandsDef::band_const_iterator ConnectionBandsDef:: + begin_band () const + { + return band_.begin (); + } + + ConnectionBandsDef::band_const_iterator ConnectionBandsDef:: + end_band () const + { + return band_.end (); + } + + void ConnectionBandsDef:: + add_band (::CIAO::Config_Handlers::PriorityBandDef const& e) + { + band_.push_back (e); + } + + size_t ConnectionBandsDef:: + count_band(void) const + { + return band_.size (); + } + + // ConnectionBandsDef + // + bool ConnectionBandsDef:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& ConnectionBandsDef:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& ConnectionBandsDef:: + id () + { + return *id_; + } + + void ConnectionBandsDef:: + 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); + } + } + + + // PriorityBandDef + // + + PriorityBandDef:: + PriorityBandDef (::XMLSchema::int_ const& low__, + ::XMLSchema::int_ const& high__) + : + ::XSCRT::Type (), + low_ (new ::XMLSchema::int_ (low__)), + high_ (new ::XMLSchema::int_ (high__)), + regulator__ () + { + low_->container (this); + high_->container (this); + } + + PriorityBandDef:: + PriorityBandDef (::CIAO::Config_Handlers::PriorityBandDef const& s) + : + ::XSCRT::Type (), + low_ (new ::XMLSchema::int_ (*s.low_)), + high_ (new ::XMLSchema::int_ (*s.high_)), + regulator__ () + { + low_->container (this); + high_->container (this); + } + + ::CIAO::Config_Handlers::PriorityBandDef& PriorityBandDef:: + operator= (::CIAO::Config_Handlers::PriorityBandDef const& s) + { + low (s.low ()); + + high (s.high ()); + + return *this; + } + + + // PriorityBandDef + // + ::XMLSchema::int_ const& PriorityBandDef:: + low () const + { + return *low_; + } + + void PriorityBandDef:: + low (::XMLSchema::int_ const& e) + { + *low_ = e; + } + + // PriorityBandDef + // + ::XMLSchema::int_ const& PriorityBandDef:: + high () const + { + return *high_; + } + + void PriorityBandDef:: + high (::XMLSchema::int_ const& e) + { + *high_ = e; + } + + + // PolicySet + // + + PolicySet:: + PolicySet () + : + ::XSCRT::Type (), + regulator__ () + { + } + + PolicySet:: + PolicySet (::CIAO::Config_Handlers::PolicySet const& s) + : + ::XSCRT::Type (), + id_ (s.id_.get () ? new ::XMLSchema::ID< ACE_TCHAR > (*s.id_) : 0), + regulator__ () + { + { + for (priorityModel_const_iterator i (s.priorityModel_.begin ());i != s.priorityModel_.end ();++i) add_priorityModel (*i); + } + + { + for (nwpriorityModel_const_iterator i (s.nwpriorityModel_.begin ());i != s.nwpriorityModel_.end ();++i) add_nwpriorityModel (*i); + } + + { + for (cnwpriorityModel_const_iterator i (s.cnwpriorityModel_.begin ());i != s.cnwpriorityModel_.end ();++i) add_cnwpriorityModel (*i); + } + + { + for (threadpool_const_iterator i (s.threadpool_.begin ());i != s.threadpool_.end ();++i) add_threadpool (*i); + } + + { + for (priorityBandedConnection_const_iterator i (s.priorityBandedConnection_.begin ());i != s.priorityBandedConnection_.end ();++i) add_priorityBandedConnection (*i); + } + + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::PolicySet& PolicySet:: + operator= (::CIAO::Config_Handlers::PolicySet const& s) + { + priorityModel_.clear (); + { + for (priorityModel_const_iterator i (s.priorityModel_.begin ());i != s.priorityModel_.end ();++i) add_priorityModel (*i); + } + + nwpriorityModel_.clear (); + { + for (nwpriorityModel_const_iterator i (s.nwpriorityModel_.begin ());i != s.nwpriorityModel_.end ();++i) add_nwpriorityModel (*i); + } + + cnwpriorityModel_.clear (); + { + for (cnwpriorityModel_const_iterator i (s.cnwpriorityModel_.begin ());i != s.cnwpriorityModel_.end ();++i) add_cnwpriorityModel (*i); + } + + threadpool_.clear (); + { + for (threadpool_const_iterator i (s.threadpool_.begin ());i != s.threadpool_.end ();++i) add_threadpool (*i); + } + + priorityBandedConnection_.clear (); + { + for (priorityBandedConnection_const_iterator i (s.priorityBandedConnection_.begin ());i != s.priorityBandedConnection_.end ();++i) add_priorityBandedConnection (*i); + } + + if (s.id_.get ()) id (*(s.id_)); + else id_ = ::std::auto_ptr< ::XMLSchema::ID< ACE_TCHAR > > (0); + + return *this; + } + + + // PolicySet + // + PolicySet::priorityModel_iterator PolicySet:: + begin_priorityModel () + { + return priorityModel_.begin (); + } + + PolicySet::priorityModel_iterator PolicySet:: + end_priorityModel () + { + return priorityModel_.end (); + } + + PolicySet::priorityModel_const_iterator PolicySet:: + begin_priorityModel () const + { + return priorityModel_.begin (); + } + + PolicySet::priorityModel_const_iterator PolicySet:: + end_priorityModel () const + { + return priorityModel_.end (); + } + + void PolicySet:: + add_priorityModel (::CIAO::Config_Handlers::PriorityModelPolicyDef const& e) + { + priorityModel_.push_back (e); + } + + size_t PolicySet:: + count_priorityModel(void) const + { + return priorityModel_.size (); + } + + // PolicySet + // + PolicySet::nwpriorityModel_iterator PolicySet:: + begin_nwpriorityModel () + { + return nwpriorityModel_.begin (); + } + + PolicySet::nwpriorityModel_iterator PolicySet:: + end_nwpriorityModel () + { + return nwpriorityModel_.end (); + } + + PolicySet::nwpriorityModel_const_iterator PolicySet:: + begin_nwpriorityModel () const + { + return nwpriorityModel_.begin (); + } + + PolicySet::nwpriorityModel_const_iterator PolicySet:: + end_nwpriorityModel () const + { + return nwpriorityModel_.end (); + } + + void PolicySet:: + add_nwpriorityModel (::CIAO::Config_Handlers::NWPriorityModelPolicyDef const& e) + { + nwpriorityModel_.push_back (e); + } + + size_t PolicySet:: + count_nwpriorityModel(void) const + { + return nwpriorityModel_.size (); + } + + // PolicySet + // + PolicySet::cnwpriorityModel_iterator PolicySet:: + begin_cnwpriorityModel () + { + return cnwpriorityModel_.begin (); + } + + PolicySet::cnwpriorityModel_iterator PolicySet:: + end_cnwpriorityModel () + { + return cnwpriorityModel_.end (); + } + + PolicySet::cnwpriorityModel_const_iterator PolicySet:: + begin_cnwpriorityModel () const + { + return cnwpriorityModel_.begin (); + } + + PolicySet::cnwpriorityModel_const_iterator PolicySet:: + end_cnwpriorityModel () const + { + return cnwpriorityModel_.end (); + } + + void PolicySet:: + add_cnwpriorityModel (::CIAO::Config_Handlers::CNWPriorityModelPolicyDef const& e) + { + cnwpriorityModel_.push_back (e); + } + + size_t PolicySet:: + count_cnwpriorityModel(void) const + { + return cnwpriorityModel_.size (); + } + + // PolicySet + // + PolicySet::threadpool_iterator PolicySet:: + begin_threadpool () + { + return threadpool_.begin (); + } + + PolicySet::threadpool_iterator PolicySet:: + end_threadpool () + { + return threadpool_.end (); + } + + PolicySet::threadpool_const_iterator PolicySet:: + begin_threadpool () const + { + return threadpool_.begin (); + } + + PolicySet::threadpool_const_iterator PolicySet:: + end_threadpool () const + { + return threadpool_.end (); + } + + void PolicySet:: + add_threadpool (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + threadpool_.push_back (e); + } + + size_t PolicySet:: + count_threadpool(void) const + { + return threadpool_.size (); + } + + // PolicySet + // + PolicySet::priorityBandedConnection_iterator PolicySet:: + begin_priorityBandedConnection () + { + return priorityBandedConnection_.begin (); + } + + PolicySet::priorityBandedConnection_iterator PolicySet:: + end_priorityBandedConnection () + { + return priorityBandedConnection_.end (); + } + + PolicySet::priorityBandedConnection_const_iterator PolicySet:: + begin_priorityBandedConnection () const + { + return priorityBandedConnection_.begin (); + } + + PolicySet::priorityBandedConnection_const_iterator PolicySet:: + end_priorityBandedConnection () const + { + return priorityBandedConnection_.end (); + } + + void PolicySet:: + add_priorityBandedConnection (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + priorityBandedConnection_.push_back (e); + } + + size_t PolicySet:: + count_priorityBandedConnection(void) const + { + return priorityBandedConnection_.size (); + } + + // PolicySet + // + bool PolicySet:: + id_p () const + { + return id_.get () != 0; + } + + ::XMLSchema::ID< ACE_TCHAR > const& PolicySet:: + id () const + { + return *id_; + } + + ::XMLSchema::ID< ACE_TCHAR >& PolicySet:: + id () + { + return *id_; + } + + void PolicySet:: + 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); + } + } + + + // PriorityModel + // + + PriorityModel::Value PriorityModel:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::PriorityModel const& a, ::CIAO::Config_Handlers::PriorityModel const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::PriorityModel const& a, ::CIAO::Config_Handlers::PriorityModel const& b) + { + return a.v_ != b.v_; + } + + PriorityModel:: + PriorityModel (PriorityModel::Value v) + : v_ (v) + { + } + + // NWPriorityModel + // + + NWPriorityModel::Value NWPriorityModel:: + integral () const + { + return v_; + } + + bool + operator== (::CIAO::Config_Handlers::NWPriorityModel const& a, ::CIAO::Config_Handlers::NWPriorityModel const& b) + { + return a.v_ == b.v_; + } + + bool + operator!= (::CIAO::Config_Handlers::NWPriorityModel const& a, ::CIAO::Config_Handlers::NWPriorityModel const& b) + { + return a.v_ != b.v_; + } + + NWPriorityModel:: + NWPriorityModel (NWPriorityModel::Value v) + : v_ (v) + { + } + + // PriorityModelPolicyDef + // + + PriorityModelPolicyDef:: + PriorityModelPolicyDef (::CIAO::Config_Handlers::PriorityModel const& priority_model__) + : + ::XSCRT::Type (), + priority_model_ (new ::CIAO::Config_Handlers::PriorityModel (priority_model__)), + regulator__ () + { + priority_model_->container (this); + } + + PriorityModelPolicyDef:: + PriorityModelPolicyDef (::CIAO::Config_Handlers::PriorityModelPolicyDef const& s) + : + ::XSCRT::Type (), + priority_model_ (new ::CIAO::Config_Handlers::PriorityModel (*s.priority_model_)), + server_priority_ (s.server_priority_.get () ? new ::XMLSchema::int_ (*s.server_priority_) : 0), + regulator__ () + { + priority_model_->container (this); + if (server_priority_.get ()) server_priority_->container (this); + } + + ::CIAO::Config_Handlers::PriorityModelPolicyDef& PriorityModelPolicyDef:: + operator= (::CIAO::Config_Handlers::PriorityModelPolicyDef const& s) + { + priority_model (s.priority_model ()); + + if (s.server_priority_.get ()) server_priority (*(s.server_priority_)); + else server_priority_ = ::std::auto_ptr< ::XMLSchema::int_ > (0); + + return *this; + } + + + // PriorityModelPolicyDef + // + ::CIAO::Config_Handlers::PriorityModel const& PriorityModelPolicyDef:: + priority_model () const + { + return *priority_model_; + } + + void PriorityModelPolicyDef:: + priority_model (::CIAO::Config_Handlers::PriorityModel const& e) + { + *priority_model_ = e; + } + + // PriorityModelPolicyDef + // + bool PriorityModelPolicyDef:: + server_priority_p () const + { + return server_priority_.get () != 0; + } + + ::XMLSchema::int_ const& PriorityModelPolicyDef:: + server_priority () const + { + return *server_priority_; + } + + ::XMLSchema::int_& PriorityModelPolicyDef:: + server_priority () + { + return *server_priority_; + } + + void PriorityModelPolicyDef:: + server_priority (::XMLSchema::int_ const& e) + { + if (server_priority_.get ()) + { + *server_priority_ = e; + } + + else + { + server_priority_ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e)); + server_priority_->container (this); + } + } + + + // NWPriorityModelPolicyDef + // + + NWPriorityModelPolicyDef:: + NWPriorityModelPolicyDef (::CIAO::Config_Handlers::NWPriorityModel const& nw_priority_model__, + ::XMLSchema::long_ const& request_dscp__, + ::XMLSchema::long_ const& reply_dscp__) + : + ::XSCRT::Type (), + nw_priority_model_ (new ::CIAO::Config_Handlers::NWPriorityModel (nw_priority_model__)), + request_dscp_ (new ::XMLSchema::long_ (request_dscp__)), + reply_dscp_ (new ::XMLSchema::long_ (reply_dscp__)), + regulator__ () + { + nw_priority_model_->container (this); + request_dscp_->container (this); + reply_dscp_->container (this); + } + + NWPriorityModelPolicyDef:: + NWPriorityModelPolicyDef (::CIAO::Config_Handlers::NWPriorityModelPolicyDef const& s) + : + ::XSCRT::Type (), + nw_priority_model_ (new ::CIAO::Config_Handlers::NWPriorityModel (*s.nw_priority_model_)), + request_dscp_ (new ::XMLSchema::long_ (*s.request_dscp_)), + reply_dscp_ (new ::XMLSchema::long_ (*s.reply_dscp_)), + regulator__ () + { + nw_priority_model_->container (this); + request_dscp_->container (this); + reply_dscp_->container (this); + } + + ::CIAO::Config_Handlers::NWPriorityModelPolicyDef& NWPriorityModelPolicyDef:: + operator= (::CIAO::Config_Handlers::NWPriorityModelPolicyDef const& s) + { + nw_priority_model (s.nw_priority_model ()); + + request_dscp (s.request_dscp ()); + + reply_dscp (s.reply_dscp ()); + + return *this; + } + + + // NWPriorityModelPolicyDef + // + ::CIAO::Config_Handlers::NWPriorityModel const& NWPriorityModelPolicyDef:: + nw_priority_model () const + { + return *nw_priority_model_; + } + + void NWPriorityModelPolicyDef:: + nw_priority_model (::CIAO::Config_Handlers::NWPriorityModel const& e) + { + *nw_priority_model_ = e; + } + + // NWPriorityModelPolicyDef + // + ::XMLSchema::long_ const& NWPriorityModelPolicyDef:: + request_dscp () const + { + return *request_dscp_; + } + + void NWPriorityModelPolicyDef:: + request_dscp (::XMLSchema::long_ const& e) + { + *request_dscp_ = e; + } + + // NWPriorityModelPolicyDef + // + ::XMLSchema::long_ const& NWPriorityModelPolicyDef:: + reply_dscp () const + { + return *reply_dscp_; + } + + void NWPriorityModelPolicyDef:: + reply_dscp (::XMLSchema::long_ const& e) + { + *reply_dscp_ = e; + } + + + // CNWPriorityModelPolicyDef + // + + CNWPriorityModelPolicyDef:: + CNWPriorityModelPolicyDef (::XMLSchema::long_ const& request_dscp__, + ::XMLSchema::long_ const& reply_dscp__) + : + ::XSCRT::Type (), + request_dscp_ (new ::XMLSchema::long_ (request_dscp__)), + reply_dscp_ (new ::XMLSchema::long_ (reply_dscp__)), + regulator__ () + { + request_dscp_->container (this); + reply_dscp_->container (this); + } + + CNWPriorityModelPolicyDef:: + CNWPriorityModelPolicyDef (::CIAO::Config_Handlers::CNWPriorityModelPolicyDef const& s) + : + ::XSCRT::Type (), + request_dscp_ (new ::XMLSchema::long_ (*s.request_dscp_)), + reply_dscp_ (new ::XMLSchema::long_ (*s.reply_dscp_)), + regulator__ () + { + request_dscp_->container (this); + reply_dscp_->container (this); + } + + ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef& CNWPriorityModelPolicyDef:: + operator= (::CIAO::Config_Handlers::CNWPriorityModelPolicyDef const& s) + { + request_dscp (s.request_dscp ()); + + reply_dscp (s.reply_dscp ()); + + return *this; + } + + + // CNWPriorityModelPolicyDef + // + ::XMLSchema::long_ const& CNWPriorityModelPolicyDef:: + request_dscp () const + { + return *request_dscp_; + } + + void CNWPriorityModelPolicyDef:: + request_dscp (::XMLSchema::long_ const& e) + { + *request_dscp_ = e; + } + + // CNWPriorityModelPolicyDef + // + ::XMLSchema::long_ const& CNWPriorityModelPolicyDef:: + reply_dscp () const + { + return *reply_dscp_; + } + + void CNWPriorityModelPolicyDef:: + reply_dscp (::XMLSchema::long_ const& e) + { + *reply_dscp_ = e; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // ServerResourcesDef + // + + ServerResourcesDef:: + ServerResourcesDef (::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 == "cmdline") + { + ::CIAO::Config_Handlers::ServerCmdlineOptions t (e); + cmdline (t); + } + + else if (n == "svcconf") + { + ::CIAO::Config_Handlers::ACESvcConf t (e); + svcconf (t); + } + + else if (n == "orbConfigs") + { + orbConfigs_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ORBConfigs > (new ::CIAO::Config_Handlers::ORBConfigs (e)); + orbConfigs_->container (this); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // ServerCmdlineOptions + // + + ServerCmdlineOptions:: + ServerCmdlineOptions (::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 == "arg") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_arg (t); + } + + else + { + } + } + } + + // ACESvcConf + // + + ACESvcConf:: + ACESvcConf (::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 == "uri") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + uri (t); + } + + else + { + } + } + } + + // ORBConfigs + // + + ORBConfigs:: + ORBConfigs (::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 == "resources") + { + ::CIAO::Config_Handlers::ORBResources t (e); + resources (t); + } + + else if (n == "policySet") + { + ::CIAO::Config_Handlers::PolicySet t (e); + add_policySet (t); + } + + else + { + } + } + } + + // ORBResources + // + + ORBResources:: + ORBResources (::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 == "threadpool") + { + ::CIAO::Config_Handlers::ThreadpoolDef t (e); + add_threadpool (t); + } + + else if (n == "threadpoolWithLanes") + { + ::CIAO::Config_Handlers::ThreadpoolWithLanesDef t (e); + add_threadpoolWithLanes (t); + } + + else if (n == "connectionBands") + { + ::CIAO::Config_Handlers::ConnectionBandsDef t (e); + add_connectionBands (t); + } + + else + { + } + } + } + + // ThreadpoolDef + // + + ThreadpoolDef:: + ThreadpoolDef (::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 == "stacksize") + { + stacksize_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + stacksize_->container (this); + } + + else if (n == "static_threads") + { + static_threads_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + static_threads_->container (this); + } + + else if (n == "dynamic_threads") + { + dynamic_threads_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + dynamic_threads_->container (this); + } + + else if (n == "default_priority") + { + default_priority_ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e)); + default_priority_->container (this); + } + + else if (n == "allow_request_buffering") + { + allow_request_buffering_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + allow_request_buffering_->container (this); + } + + else if (n == "max_buffered_requests") + { + max_buffered_requests_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + max_buffered_requests_->container (this); + } + + else if (n == "max_request_buffered_size") + { + max_request_buffered_size_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + max_request_buffered_size_->container (this); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // ThreadpoolWithLanesDef + // + + ThreadpoolWithLanesDef:: + ThreadpoolWithLanesDef (::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 == "threadpoolLane") + { + ::CIAO::Config_Handlers::ThreadpoolLaneDef t (e); + add_threadpoolLane (t); + } + + else if (n == "stacksize") + { + stacksize_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + stacksize_->container (this); + } + + else if (n == "allow_borrowing") + { + allow_borrowing_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + allow_borrowing_->container (this); + } + + else if (n == "allow_request_buffering") + { + allow_request_buffering_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e)); + allow_request_buffering_->container (this); + } + + else if (n == "max_buffered_requests") + { + max_buffered_requests_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + max_buffered_requests_->container (this); + } + + else if (n == "max_request_buffered_size") + { + max_request_buffered_size_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + max_request_buffered_size_->container (this); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // ThreadpoolLaneDef + // + + ThreadpoolLaneDef:: + ThreadpoolLaneDef (::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 == "static_threads") + { + static_threads_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + static_threads_->container (this); + } + + else if (n == "dynamic_threads") + { + dynamic_threads_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e)); + dynamic_threads_->container (this); + } + + else if (n == "priority") + { + priority_ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e)); + priority_->container (this); + } + + else + { + } + } + } + + // ConnectionBandsDef + // + + ConnectionBandsDef:: + ConnectionBandsDef (::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 == "band") + { + ::CIAO::Config_Handlers::PriorityBandDef t (e); + add_band (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // PriorityBandDef + // + + PriorityBandDef:: + PriorityBandDef (::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 == "low") + { + low_ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e)); + low_->container (this); + } + + else if (n == "high") + { + high_ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e)); + high_->container (this); + } + + else + { + } + } + } + + // PolicySet + // + + PolicySet:: + PolicySet (::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 == "priorityModel") + { + ::CIAO::Config_Handlers::PriorityModelPolicyDef t (e); + add_priorityModel (t); + } + + else if (n == "nwpriorityModel") + { + ::CIAO::Config_Handlers::NWPriorityModelPolicyDef t (e); + add_nwpriorityModel (t); + } + + else if (n == "cnwpriorityModel") + { + ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef t (e); + add_cnwpriorityModel (t); + } + + else if (n == "threadpool") + { + ::XMLSchema::IDREF< ACE_TCHAR > t (e); + add_threadpool (t); + } + + else if (n == "priorityBandedConnection") + { + ::XMLSchema::IDREF< ACE_TCHAR > t (e); + add_priorityBandedConnection (t); + } + + else + { + } + } + + while (p.more_attributes ()) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a (p.next_attribute ()); + ::std::basic_string< ACE_TCHAR > n (::XSCRT::XML::uq_name (a.name ())); + if (n == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + else + { + } + } + } + + // PriorityModel + // + + PriorityModel:: + PriorityModel (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "SERVER_DECLARED") v_ = SERVER_DECLARED_l; + else if (v == "CLIENT_PROPAGATED") v_ = CLIENT_PROPAGATED_l; + else + { + } + } + + PriorityModel:: + PriorityModel (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "SERVER_DECLARED") v_ = SERVER_DECLARED_l; + else if (v == "CLIENT_PROPAGATED") v_ = CLIENT_PROPAGATED_l; + else + { + } + } + + PriorityModel const PriorityModel::SERVER_DECLARED (PriorityModel::SERVER_DECLARED_l); + PriorityModel const PriorityModel::CLIENT_PROPAGATED (PriorityModel::CLIENT_PROPAGATED_l); + + // NWPriorityModel + // + + NWPriorityModel:: + NWPriorityModel (::XSCRT::XML::Element< ACE_TCHAR > const& e) + : ::XSCRT::Type (e) + { + ::std::basic_string< ACE_TCHAR > v (e.value ()); + + if (v == "SERVER_DECLARED_NWPRIORITY") v_ = SERVER_DECLARED_NWPRIORITY_l; + else if (v == "CLIENT_PROPAGATED_NWPRIORITY") v_ = CLIENT_PROPAGATED_NWPRIORITY_l; + else + { + } + } + + NWPriorityModel:: + NWPriorityModel (::XSCRT::XML::Attribute< ACE_TCHAR > const& a) + : ::XSCRT::Type (a) + { + ::std::basic_string< ACE_TCHAR > v (a.value ()); + + if (v == "SERVER_DECLARED_NWPRIORITY") v_ = SERVER_DECLARED_NWPRIORITY_l; + else if (v == "CLIENT_PROPAGATED_NWPRIORITY") v_ = CLIENT_PROPAGATED_NWPRIORITY_l; + else + { + } + } + + NWPriorityModel const NWPriorityModel::SERVER_DECLARED_NWPRIORITY (NWPriorityModel::SERVER_DECLARED_NWPRIORITY_l); + NWPriorityModel const NWPriorityModel::CLIENT_PROPAGATED_NWPRIORITY (NWPriorityModel::CLIENT_PROPAGATED_NWPRIORITY_l); + + // PriorityModelPolicyDef + // + + PriorityModelPolicyDef:: + PriorityModelPolicyDef (::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 == "priority_model") + { + priority_model_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PriorityModel > (new ::CIAO::Config_Handlers::PriorityModel (e)); + priority_model_->container (this); + } + + 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 == "server_priority") + { + ::XMLSchema::int_ t (a); + server_priority (t); + } + + else + { + } + } + } + + // NWPriorityModelPolicyDef + // + + NWPriorityModelPolicyDef:: + NWPriorityModelPolicyDef (::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 == "nw_priority_model") + { + nw_priority_model_ = ::std::auto_ptr< ::CIAO::Config_Handlers::NWPriorityModel > (new ::CIAO::Config_Handlers::NWPriorityModel (e)); + nw_priority_model_->container (this); + } + + else if (n == "request_dscp") + { + request_dscp_ = ::std::auto_ptr< ::XMLSchema::long_ > (new ::XMLSchema::long_ (e)); + request_dscp_->container (this); + } + + else if (n == "reply_dscp") + { + reply_dscp_ = ::std::auto_ptr< ::XMLSchema::long_ > (new ::XMLSchema::long_ (e)); + reply_dscp_->container (this); + } + + else + { + } + } + } + + // CNWPriorityModelPolicyDef + // + + CNWPriorityModelPolicyDef:: + CNWPriorityModelPolicyDef (::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 == "request_dscp") + { + request_dscp_ = ::std::auto_ptr< ::XMLSchema::long_ > (new ::XMLSchema::long_ (e)); + request_dscp_->container (this); + } + + else if (n == "reply_dscp") + { + reply_dscp_ = ::std::auto_ptr< ::XMLSchema::long_ > (new ::XMLSchema::long_ (e)); + reply_dscp_->container (this); + } + + else + { + } + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + ::CIAO::Config_Handlers::ServerResourcesDef + ServerResources (xercesc::DOMDocument const* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () == "ServerResources") + { + ::CIAO::Config_Handlers::ServerResourcesDef r (e); + 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 ()); + + struct ServerResourcesDefTypeInfoInitializer + { + ServerResourcesDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ServerResourcesDef)); + ::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)); + } + }; + + ServerResourcesDefTypeInfoInitializer ServerResourcesDefTypeInfoInitializer_; + + struct ServerCmdlineOptionsTypeInfoInitializer + { + ServerCmdlineOptionsTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ServerCmdlineOptions)); + ::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)); + } + }; + + ServerCmdlineOptionsTypeInfoInitializer ServerCmdlineOptionsTypeInfoInitializer_; + + struct ACESvcConfTypeInfoInitializer + { + ACESvcConfTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ACESvcConf)); + ::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)); + } + }; + + ACESvcConfTypeInfoInitializer ACESvcConfTypeInfoInitializer_; + + struct ORBConfigsTypeInfoInitializer + { + ORBConfigsTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ORBConfigs)); + ::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)); + } + }; + + ORBConfigsTypeInfoInitializer ORBConfigsTypeInfoInitializer_; + + struct ORBResourcesTypeInfoInitializer + { + ORBResourcesTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ORBResources)); + ::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)); + } + }; + + ORBResourcesTypeInfoInitializer ORBResourcesTypeInfoInitializer_; + + struct ThreadpoolDefTypeInfoInitializer + { + ThreadpoolDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ThreadpoolDef)); + ::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)); + } + }; + + ThreadpoolDefTypeInfoInitializer ThreadpoolDefTypeInfoInitializer_; + + struct ThreadpoolWithLanesDefTypeInfoInitializer + { + ThreadpoolWithLanesDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ThreadpoolWithLanesDef)); + ::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)); + } + }; + + ThreadpoolWithLanesDefTypeInfoInitializer ThreadpoolWithLanesDefTypeInfoInitializer_; + + struct ThreadpoolLaneDefTypeInfoInitializer + { + ThreadpoolLaneDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ThreadpoolLaneDef)); + ::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)); + } + }; + + ThreadpoolLaneDefTypeInfoInitializer ThreadpoolLaneDefTypeInfoInitializer_; + + struct ConnectionBandsDefTypeInfoInitializer + { + ConnectionBandsDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (ConnectionBandsDef)); + ::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)); + } + }; + + ConnectionBandsDefTypeInfoInitializer ConnectionBandsDefTypeInfoInitializer_; + + struct PriorityBandDefTypeInfoInitializer + { + PriorityBandDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PriorityBandDef)); + ::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)); + } + }; + + PriorityBandDefTypeInfoInitializer PriorityBandDefTypeInfoInitializer_; + + struct PolicySetTypeInfoInitializer + { + PolicySetTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PolicySet)); + ::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)); + } + }; + + PolicySetTypeInfoInitializer PolicySetTypeInfoInitializer_; + + struct PriorityModelTypeInfoInitializer + { + PriorityModelTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PriorityModel)); + ::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)); + } + }; + + PriorityModelTypeInfoInitializer PriorityModelTypeInfoInitializer_; + + struct NWPriorityModelTypeInfoInitializer + { + NWPriorityModelTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (NWPriorityModel)); + ::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)); + } + }; + + NWPriorityModelTypeInfoInitializer NWPriorityModelTypeInfoInitializer_; + + struct PriorityModelPolicyDefTypeInfoInitializer + { + PriorityModelPolicyDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (PriorityModelPolicyDef)); + ::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)); + } + }; + + PriorityModelPolicyDefTypeInfoInitializer PriorityModelPolicyDefTypeInfoInitializer_; + + struct NWPriorityModelPolicyDefTypeInfoInitializer + { + NWPriorityModelPolicyDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (NWPriorityModelPolicyDef)); + ::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)); + } + }; + + NWPriorityModelPolicyDefTypeInfoInitializer NWPriorityModelPolicyDefTypeInfoInitializer_; + + struct CNWPriorityModelPolicyDefTypeInfoInitializer + { + CNWPriorityModelPolicyDefTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (CNWPriorityModelPolicyDef)); + ::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)); + } + }; + + CNWPriorityModelPolicyDefTypeInfoInitializer CNWPriorityModelPolicyDefTypeInfoInitializer_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // ServerResourcesDef + // + // + + void ServerResourcesDef:: + traverse (Type& o) + { + pre (o); + if (o.cmdline_p ()) cmdline (o); + else cmdline_none (o); + if (o.svcconf_p ()) svcconf (o); + else svcconf_none (o); + orbConfigs (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ServerResourcesDef:: + traverse (Type const& o) + { + pre (o); + if (o.cmdline_p ()) cmdline (o); + else cmdline_none (o); + if (o.svcconf_p ()) svcconf (o); + else svcconf_none (o); + orbConfigs (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ServerResourcesDef:: + pre (Type&) + { + } + + void ServerResourcesDef:: + pre (Type const&) + { + } + + void ServerResourcesDef:: + cmdline (Type& o) + { + dispatch (o.cmdline ()); + } + + void ServerResourcesDef:: + cmdline (Type const& o) + { + dispatch (o.cmdline ()); + } + + void ServerResourcesDef:: + cmdline_none (Type&) + { + } + + void ServerResourcesDef:: + cmdline_none (Type const&) + { + } + + void ServerResourcesDef:: + svcconf (Type& o) + { + dispatch (o.svcconf ()); + } + + void ServerResourcesDef:: + svcconf (Type const& o) + { + dispatch (o.svcconf ()); + } + + void ServerResourcesDef:: + svcconf_none (Type&) + { + } + + void ServerResourcesDef:: + svcconf_none (Type const&) + { + } + + void ServerResourcesDef:: + orbConfigs (Type& o) + { + dispatch (o.orbConfigs ()); + } + + void ServerResourcesDef:: + orbConfigs (Type const& o) + { + dispatch (o.orbConfigs ()); + } + + void ServerResourcesDef:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ServerResourcesDef:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ServerResourcesDef:: + id_none (Type&) + { + } + + void ServerResourcesDef:: + id_none (Type const&) + { + } + + void ServerResourcesDef:: + post (Type&) + { + } + + void ServerResourcesDef:: + post (Type const&) + { + } + + // ServerCmdlineOptions + // + // + + void ServerCmdlineOptions:: + traverse (Type& o) + { + pre (o); + arg (o); + post (o); + } + + void ServerCmdlineOptions:: + traverse (Type const& o) + { + pre (o); + arg (o); + post (o); + } + + void ServerCmdlineOptions:: + pre (Type&) + { + } + + void ServerCmdlineOptions:: + pre (Type const&) + { + } + + void ServerCmdlineOptions:: + arg (Type& o) + { + // VC6 anathema strikes again + // + ServerCmdlineOptions::Type::arg_iterator b (o.begin_arg()), e (o.end_arg()); + + if (b != e) + { + arg_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) arg_next (o); + } + + arg_post (o); + } + } + + void ServerCmdlineOptions:: + arg (Type const& o) + { + // VC6 anathema strikes again + // + ServerCmdlineOptions::Type::arg_const_iterator b (o.begin_arg()), e (o.end_arg()); + + if (b != e) + { + arg_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) arg_next (o); + } + + arg_post (o); + } + } + + void ServerCmdlineOptions:: + arg_pre (Type&) + { + } + + void ServerCmdlineOptions:: + arg_pre (Type const&) + { + } + + void ServerCmdlineOptions:: + arg_next (Type&) + { + } + + void ServerCmdlineOptions:: + arg_next (Type const&) + { + } + + void ServerCmdlineOptions:: + arg_post (Type&) + { + } + + void ServerCmdlineOptions:: + arg_post (Type const&) + { + } + + void ServerCmdlineOptions:: + post (Type&) + { + } + + void ServerCmdlineOptions:: + post (Type const&) + { + } + + // ACESvcConf + // + // + + void ACESvcConf:: + traverse (Type& o) + { + pre (o); + if (o.uri_p ()) uri (o); + else uri_none (o); + post (o); + } + + void ACESvcConf:: + traverse (Type const& o) + { + pre (o); + if (o.uri_p ()) uri (o); + else uri_none (o); + post (o); + } + + void ACESvcConf:: + pre (Type&) + { + } + + void ACESvcConf:: + pre (Type const&) + { + } + + void ACESvcConf:: + uri (Type& o) + { + dispatch (o.uri ()); + } + + void ACESvcConf:: + uri (Type const& o) + { + dispatch (o.uri ()); + } + + void ACESvcConf:: + uri_none (Type&) + { + } + + void ACESvcConf:: + uri_none (Type const&) + { + } + + void ACESvcConf:: + post (Type&) + { + } + + void ACESvcConf:: + post (Type const&) + { + } + + // ORBConfigs + // + // + + void ORBConfigs:: + traverse (Type& o) + { + pre (o); + if (o.resources_p ()) resources (o); + else resources_none (o); + policySet (o); + post (o); + } + + void ORBConfigs:: + traverse (Type const& o) + { + pre (o); + if (o.resources_p ()) resources (o); + else resources_none (o); + policySet (o); + post (o); + } + + void ORBConfigs:: + pre (Type&) + { + } + + void ORBConfigs:: + pre (Type const&) + { + } + + void ORBConfigs:: + resources (Type& o) + { + dispatch (o.resources ()); + } + + void ORBConfigs:: + resources (Type const& o) + { + dispatch (o.resources ()); + } + + void ORBConfigs:: + resources_none (Type&) + { + } + + void ORBConfigs:: + resources_none (Type const&) + { + } + + void ORBConfigs:: + policySet (Type& o) + { + // VC6 anathema strikes again + // + ORBConfigs::Type::policySet_iterator b (o.begin_policySet()), e (o.end_policySet()); + + if (b != e) + { + policySet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) policySet_next (o); + } + + policySet_post (o); + } + } + + void ORBConfigs:: + policySet (Type const& o) + { + // VC6 anathema strikes again + // + ORBConfigs::Type::policySet_const_iterator b (o.begin_policySet()), e (o.end_policySet()); + + if (b != e) + { + policySet_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) policySet_next (o); + } + + policySet_post (o); + } + } + + void ORBConfigs:: + policySet_pre (Type&) + { + } + + void ORBConfigs:: + policySet_pre (Type const&) + { + } + + void ORBConfigs:: + policySet_next (Type&) + { + } + + void ORBConfigs:: + policySet_next (Type const&) + { + } + + void ORBConfigs:: + policySet_post (Type&) + { + } + + void ORBConfigs:: + policySet_post (Type const&) + { + } + + void ORBConfigs:: + post (Type&) + { + } + + void ORBConfigs:: + post (Type const&) + { + } + + // ORBResources + // + // + + void ORBResources:: + traverse (Type& o) + { + pre (o); + threadpool (o); + threadpoolWithLanes (o); + connectionBands (o); + post (o); + } + + void ORBResources:: + traverse (Type const& o) + { + pre (o); + threadpool (o); + threadpoolWithLanes (o); + connectionBands (o); + post (o); + } + + void ORBResources:: + pre (Type&) + { + } + + void ORBResources:: + pre (Type const&) + { + } + + void ORBResources:: + threadpool (Type& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::threadpool_iterator b (o.begin_threadpool()), e (o.end_threadpool()); + + if (b != e) + { + threadpool_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpool_next (o); + } + + threadpool_post (o); + } + + else threadpool_none (o); + } + + void ORBResources:: + threadpool (Type const& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::threadpool_const_iterator b (o.begin_threadpool()), e (o.end_threadpool()); + + if (b != e) + { + threadpool_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpool_next (o); + } + + threadpool_post (o); + } + + else threadpool_none (o); + } + + void ORBResources:: + threadpool_pre (Type&) + { + } + + void ORBResources:: + threadpool_pre (Type const&) + { + } + + void ORBResources:: + threadpool_next (Type&) + { + } + + void ORBResources:: + threadpool_next (Type const&) + { + } + + void ORBResources:: + threadpool_post (Type&) + { + } + + void ORBResources:: + threadpool_post (Type const&) + { + } + + void ORBResources:: + threadpool_none (Type&) + { + } + + void ORBResources:: + threadpool_none (Type const&) + { + } + + void ORBResources:: + threadpoolWithLanes (Type& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::threadpoolWithLanes_iterator b (o.begin_threadpoolWithLanes()), e (o.end_threadpoolWithLanes()); + + if (b != e) + { + threadpoolWithLanes_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpoolWithLanes_next (o); + } + + threadpoolWithLanes_post (o); + } + + else threadpoolWithLanes_none (o); + } + + void ORBResources:: + threadpoolWithLanes (Type const& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::threadpoolWithLanes_const_iterator b (o.begin_threadpoolWithLanes()), e (o.end_threadpoolWithLanes()); + + if (b != e) + { + threadpoolWithLanes_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpoolWithLanes_next (o); + } + + threadpoolWithLanes_post (o); + } + + else threadpoolWithLanes_none (o); + } + + void ORBResources:: + threadpoolWithLanes_pre (Type&) + { + } + + void ORBResources:: + threadpoolWithLanes_pre (Type const&) + { + } + + void ORBResources:: + threadpoolWithLanes_next (Type&) + { + } + + void ORBResources:: + threadpoolWithLanes_next (Type const&) + { + } + + void ORBResources:: + threadpoolWithLanes_post (Type&) + { + } + + void ORBResources:: + threadpoolWithLanes_post (Type const&) + { + } + + void ORBResources:: + threadpoolWithLanes_none (Type&) + { + } + + void ORBResources:: + threadpoolWithLanes_none (Type const&) + { + } + + void ORBResources:: + connectionBands (Type& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::connectionBands_iterator b (o.begin_connectionBands()), e (o.end_connectionBands()); + + if (b != e) + { + connectionBands_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) connectionBands_next (o); + } + + connectionBands_post (o); + } + + else connectionBands_none (o); + } + + void ORBResources:: + connectionBands (Type const& o) + { + // VC6 anathema strikes again + // + ORBResources::Type::connectionBands_const_iterator b (o.begin_connectionBands()), e (o.end_connectionBands()); + + if (b != e) + { + connectionBands_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) connectionBands_next (o); + } + + connectionBands_post (o); + } + + else connectionBands_none (o); + } + + void ORBResources:: + connectionBands_pre (Type&) + { + } + + void ORBResources:: + connectionBands_pre (Type const&) + { + } + + void ORBResources:: + connectionBands_next (Type&) + { + } + + void ORBResources:: + connectionBands_next (Type const&) + { + } + + void ORBResources:: + connectionBands_post (Type&) + { + } + + void ORBResources:: + connectionBands_post (Type const&) + { + } + + void ORBResources:: + connectionBands_none (Type&) + { + } + + void ORBResources:: + connectionBands_none (Type const&) + { + } + + void ORBResources:: + post (Type&) + { + } + + void ORBResources:: + post (Type const&) + { + } + + // ThreadpoolDef + // + // + + void ThreadpoolDef:: + traverse (Type& o) + { + pre (o); + stacksize (o); + static_threads (o); + dynamic_threads (o); + default_priority (o); + allow_request_buffering (o); + max_buffered_requests (o); + max_request_buffered_size (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ThreadpoolDef:: + traverse (Type const& o) + { + pre (o); + stacksize (o); + static_threads (o); + dynamic_threads (o); + default_priority (o); + allow_request_buffering (o); + max_buffered_requests (o); + max_request_buffered_size (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ThreadpoolDef:: + pre (Type&) + { + } + + void ThreadpoolDef:: + pre (Type const&) + { + } + + void ThreadpoolDef:: + stacksize (Type& o) + { + dispatch (o.stacksize ()); + } + + void ThreadpoolDef:: + stacksize (Type const& o) + { + dispatch (o.stacksize ()); + } + + void ThreadpoolDef:: + static_threads (Type& o) + { + dispatch (o.static_threads ()); + } + + void ThreadpoolDef:: + static_threads (Type const& o) + { + dispatch (o.static_threads ()); + } + + void ThreadpoolDef:: + dynamic_threads (Type& o) + { + dispatch (o.dynamic_threads ()); + } + + void ThreadpoolDef:: + dynamic_threads (Type const& o) + { + dispatch (o.dynamic_threads ()); + } + + void ThreadpoolDef:: + default_priority (Type& o) + { + dispatch (o.default_priority ()); + } + + void ThreadpoolDef:: + default_priority (Type const& o) + { + dispatch (o.default_priority ()); + } + + void ThreadpoolDef:: + allow_request_buffering (Type& o) + { + dispatch (o.allow_request_buffering ()); + } + + void ThreadpoolDef:: + allow_request_buffering (Type const& o) + { + dispatch (o.allow_request_buffering ()); + } + + void ThreadpoolDef:: + max_buffered_requests (Type& o) + { + dispatch (o.max_buffered_requests ()); + } + + void ThreadpoolDef:: + max_buffered_requests (Type const& o) + { + dispatch (o.max_buffered_requests ()); + } + + void ThreadpoolDef:: + max_request_buffered_size (Type& o) + { + dispatch (o.max_request_buffered_size ()); + } + + void ThreadpoolDef:: + max_request_buffered_size (Type const& o) + { + dispatch (o.max_request_buffered_size ()); + } + + void ThreadpoolDef:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ThreadpoolDef:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ThreadpoolDef:: + id_none (Type&) + { + } + + void ThreadpoolDef:: + id_none (Type const&) + { + } + + void ThreadpoolDef:: + post (Type&) + { + } + + void ThreadpoolDef:: + post (Type const&) + { + } + + // ThreadpoolWithLanesDef + // + // + + void ThreadpoolWithLanesDef:: + traverse (Type& o) + { + pre (o); + threadpoolLane (o); + stacksize (o); + allow_borrowing (o); + allow_request_buffering (o); + max_buffered_requests (o); + max_request_buffered_size (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ThreadpoolWithLanesDef:: + traverse (Type const& o) + { + pre (o); + threadpoolLane (o); + stacksize (o); + allow_borrowing (o); + allow_request_buffering (o); + max_buffered_requests (o); + max_request_buffered_size (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ThreadpoolWithLanesDef:: + pre (Type&) + { + } + + void ThreadpoolWithLanesDef:: + pre (Type const&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane (Type& o) + { + // VC6 anathema strikes again + // + ThreadpoolWithLanesDef::Type::threadpoolLane_iterator b (o.begin_threadpoolLane()), e (o.end_threadpoolLane()); + + if (b != e) + { + threadpoolLane_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpoolLane_next (o); + } + + threadpoolLane_post (o); + } + } + + void ThreadpoolWithLanesDef:: + threadpoolLane (Type const& o) + { + // VC6 anathema strikes again + // + ThreadpoolWithLanesDef::Type::threadpoolLane_const_iterator b (o.begin_threadpoolLane()), e (o.end_threadpoolLane()); + + if (b != e) + { + threadpoolLane_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpoolLane_next (o); + } + + threadpoolLane_post (o); + } + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_pre (Type&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_pre (Type const&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_next (Type&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_next (Type const&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_post (Type&) + { + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_post (Type const&) + { + } + + void ThreadpoolWithLanesDef:: + stacksize (Type& o) + { + dispatch (o.stacksize ()); + } + + void ThreadpoolWithLanesDef:: + stacksize (Type const& o) + { + dispatch (o.stacksize ()); + } + + void ThreadpoolWithLanesDef:: + allow_borrowing (Type& o) + { + dispatch (o.allow_borrowing ()); + } + + void ThreadpoolWithLanesDef:: + allow_borrowing (Type const& o) + { + dispatch (o.allow_borrowing ()); + } + + void ThreadpoolWithLanesDef:: + allow_request_buffering (Type& o) + { + dispatch (o.allow_request_buffering ()); + } + + void ThreadpoolWithLanesDef:: + allow_request_buffering (Type const& o) + { + dispatch (o.allow_request_buffering ()); + } + + void ThreadpoolWithLanesDef:: + max_buffered_requests (Type& o) + { + dispatch (o.max_buffered_requests ()); + } + + void ThreadpoolWithLanesDef:: + max_buffered_requests (Type const& o) + { + dispatch (o.max_buffered_requests ()); + } + + void ThreadpoolWithLanesDef:: + max_request_buffered_size (Type& o) + { + dispatch (o.max_request_buffered_size ()); + } + + void ThreadpoolWithLanesDef:: + max_request_buffered_size (Type const& o) + { + dispatch (o.max_request_buffered_size ()); + } + + void ThreadpoolWithLanesDef:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ThreadpoolWithLanesDef:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ThreadpoolWithLanesDef:: + id_none (Type&) + { + } + + void ThreadpoolWithLanesDef:: + id_none (Type const&) + { + } + + void ThreadpoolWithLanesDef:: + post (Type&) + { + } + + void ThreadpoolWithLanesDef:: + post (Type const&) + { + } + + // ThreadpoolLaneDef + // + // + + void ThreadpoolLaneDef:: + traverse (Type& o) + { + pre (o); + static_threads (o); + dynamic_threads (o); + priority (o); + post (o); + } + + void ThreadpoolLaneDef:: + traverse (Type const& o) + { + pre (o); + static_threads (o); + dynamic_threads (o); + priority (o); + post (o); + } + + void ThreadpoolLaneDef:: + pre (Type&) + { + } + + void ThreadpoolLaneDef:: + pre (Type const&) + { + } + + void ThreadpoolLaneDef:: + static_threads (Type& o) + { + dispatch (o.static_threads ()); + } + + void ThreadpoolLaneDef:: + static_threads (Type const& o) + { + dispatch (o.static_threads ()); + } + + void ThreadpoolLaneDef:: + dynamic_threads (Type& o) + { + dispatch (o.dynamic_threads ()); + } + + void ThreadpoolLaneDef:: + dynamic_threads (Type const& o) + { + dispatch (o.dynamic_threads ()); + } + + void ThreadpoolLaneDef:: + priority (Type& o) + { + dispatch (o.priority ()); + } + + void ThreadpoolLaneDef:: + priority (Type const& o) + { + dispatch (o.priority ()); + } + + void ThreadpoolLaneDef:: + post (Type&) + { + } + + void ThreadpoolLaneDef:: + post (Type const&) + { + } + + // ConnectionBandsDef + // + // + + void ConnectionBandsDef:: + traverse (Type& o) + { + pre (o); + band (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ConnectionBandsDef:: + traverse (Type const& o) + { + pre (o); + band (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void ConnectionBandsDef:: + pre (Type&) + { + } + + void ConnectionBandsDef:: + pre (Type const&) + { + } + + void ConnectionBandsDef:: + band (Type& o) + { + // VC6 anathema strikes again + // + ConnectionBandsDef::Type::band_iterator b (o.begin_band()), e (o.end_band()); + + if (b != e) + { + band_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) band_next (o); + } + + band_post (o); + } + } + + void ConnectionBandsDef:: + band (Type const& o) + { + // VC6 anathema strikes again + // + ConnectionBandsDef::Type::band_const_iterator b (o.begin_band()), e (o.end_band()); + + if (b != e) + { + band_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) band_next (o); + } + + band_post (o); + } + } + + void ConnectionBandsDef:: + band_pre (Type&) + { + } + + void ConnectionBandsDef:: + band_pre (Type const&) + { + } + + void ConnectionBandsDef:: + band_next (Type&) + { + } + + void ConnectionBandsDef:: + band_next (Type const&) + { + } + + void ConnectionBandsDef:: + band_post (Type&) + { + } + + void ConnectionBandsDef:: + band_post (Type const&) + { + } + + void ConnectionBandsDef:: + id (Type& o) + { + dispatch (o.id ()); + } + + void ConnectionBandsDef:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void ConnectionBandsDef:: + id_none (Type&) + { + } + + void ConnectionBandsDef:: + id_none (Type const&) + { + } + + void ConnectionBandsDef:: + post (Type&) + { + } + + void ConnectionBandsDef:: + post (Type const&) + { + } + + // PriorityBandDef + // + // + + void PriorityBandDef:: + traverse (Type& o) + { + pre (o); + low (o); + high (o); + post (o); + } + + void PriorityBandDef:: + traverse (Type const& o) + { + pre (o); + low (o); + high (o); + post (o); + } + + void PriorityBandDef:: + pre (Type&) + { + } + + void PriorityBandDef:: + pre (Type const&) + { + } + + void PriorityBandDef:: + low (Type& o) + { + dispatch (o.low ()); + } + + void PriorityBandDef:: + low (Type const& o) + { + dispatch (o.low ()); + } + + void PriorityBandDef:: + high (Type& o) + { + dispatch (o.high ()); + } + + void PriorityBandDef:: + high (Type const& o) + { + dispatch (o.high ()); + } + + void PriorityBandDef:: + post (Type&) + { + } + + void PriorityBandDef:: + post (Type const&) + { + } + + // PolicySet + // + // + + void PolicySet:: + traverse (Type& o) + { + pre (o); + priorityModel (o); + nwpriorityModel (o); + cnwpriorityModel (o); + threadpool (o); + priorityBandedConnection (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void PolicySet:: + traverse (Type const& o) + { + pre (o); + priorityModel (o); + nwpriorityModel (o); + cnwpriorityModel (o); + threadpool (o); + priorityBandedConnection (o); + if (o.id_p ()) id (o); + else id_none (o); + post (o); + } + + void PolicySet:: + pre (Type&) + { + } + + void PolicySet:: + pre (Type const&) + { + } + + void PolicySet:: + priorityModel (Type& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::priorityModel_iterator b (o.begin_priorityModel()), e (o.end_priorityModel()); + + if (b != e) + { + priorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) priorityModel_next (o); + } + + priorityModel_post (o); + } + + else priorityModel_none (o); + } + + void PolicySet:: + priorityModel (Type const& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::priorityModel_const_iterator b (o.begin_priorityModel()), e (o.end_priorityModel()); + + if (b != e) + { + priorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) priorityModel_next (o); + } + + priorityModel_post (o); + } + + else priorityModel_none (o); + } + + void PolicySet:: + priorityModel_pre (Type&) + { + } + + void PolicySet:: + priorityModel_pre (Type const&) + { + } + + void PolicySet:: + priorityModel_next (Type&) + { + } + + void PolicySet:: + priorityModel_next (Type const&) + { + } + + void PolicySet:: + priorityModel_post (Type&) + { + } + + void PolicySet:: + priorityModel_post (Type const&) + { + } + + void PolicySet:: + priorityModel_none (Type&) + { + } + + void PolicySet:: + priorityModel_none (Type const&) + { + } + + void PolicySet:: + nwpriorityModel (Type& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::nwpriorityModel_iterator b (o.begin_nwpriorityModel()), e (o.end_nwpriorityModel()); + + if (b != e) + { + nwpriorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) nwpriorityModel_next (o); + } + + nwpriorityModel_post (o); + } + + else nwpriorityModel_none (o); + } + + void PolicySet:: + nwpriorityModel (Type const& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::nwpriorityModel_const_iterator b (o.begin_nwpriorityModel()), e (o.end_nwpriorityModel()); + + if (b != e) + { + nwpriorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) nwpriorityModel_next (o); + } + + nwpriorityModel_post (o); + } + + else nwpriorityModel_none (o); + } + + void PolicySet:: + nwpriorityModel_pre (Type&) + { + } + + void PolicySet:: + nwpriorityModel_pre (Type const&) + { + } + + void PolicySet:: + nwpriorityModel_next (Type&) + { + } + + void PolicySet:: + nwpriorityModel_next (Type const&) + { + } + + void PolicySet:: + nwpriorityModel_post (Type&) + { + } + + void PolicySet:: + nwpriorityModel_post (Type const&) + { + } + + void PolicySet:: + nwpriorityModel_none (Type&) + { + } + + void PolicySet:: + nwpriorityModel_none (Type const&) + { + } + + void PolicySet:: + cnwpriorityModel (Type& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::cnwpriorityModel_iterator b (o.begin_cnwpriorityModel()), e (o.end_cnwpriorityModel()); + + if (b != e) + { + cnwpriorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) cnwpriorityModel_next (o); + } + + cnwpriorityModel_post (o); + } + + else cnwpriorityModel_none (o); + } + + void PolicySet:: + cnwpriorityModel (Type const& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::cnwpriorityModel_const_iterator b (o.begin_cnwpriorityModel()), e (o.end_cnwpriorityModel()); + + if (b != e) + { + cnwpriorityModel_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) cnwpriorityModel_next (o); + } + + cnwpriorityModel_post (o); + } + + else cnwpriorityModel_none (o); + } + + void PolicySet:: + cnwpriorityModel_pre (Type&) + { + } + + void PolicySet:: + cnwpriorityModel_pre (Type const&) + { + } + + void PolicySet:: + cnwpriorityModel_next (Type&) + { + } + + void PolicySet:: + cnwpriorityModel_next (Type const&) + { + } + + void PolicySet:: + cnwpriorityModel_post (Type&) + { + } + + void PolicySet:: + cnwpriorityModel_post (Type const&) + { + } + + void PolicySet:: + cnwpriorityModel_none (Type&) + { + } + + void PolicySet:: + cnwpriorityModel_none (Type const&) + { + } + + void PolicySet:: + threadpool (Type& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::threadpool_iterator b (o.begin_threadpool()), e (o.end_threadpool()); + + if (b != e) + { + threadpool_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpool_next (o); + } + + threadpool_post (o); + } + + else threadpool_none (o); + } + + void PolicySet:: + threadpool (Type const& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::threadpool_const_iterator b (o.begin_threadpool()), e (o.end_threadpool()); + + if (b != e) + { + threadpool_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) threadpool_next (o); + } + + threadpool_post (o); + } + + else threadpool_none (o); + } + + void PolicySet:: + threadpool_pre (Type&) + { + } + + void PolicySet:: + threadpool_pre (Type const&) + { + } + + void PolicySet:: + threadpool_next (Type&) + { + } + + void PolicySet:: + threadpool_next (Type const&) + { + } + + void PolicySet:: + threadpool_post (Type&) + { + } + + void PolicySet:: + threadpool_post (Type const&) + { + } + + void PolicySet:: + threadpool_none (Type&) + { + } + + void PolicySet:: + threadpool_none (Type const&) + { + } + + void PolicySet:: + priorityBandedConnection (Type& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::priorityBandedConnection_iterator b (o.begin_priorityBandedConnection()), e (o.end_priorityBandedConnection()); + + if (b != e) + { + priorityBandedConnection_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) priorityBandedConnection_next (o); + } + + priorityBandedConnection_post (o); + } + + else priorityBandedConnection_none (o); + } + + void PolicySet:: + priorityBandedConnection (Type const& o) + { + // VC6 anathema strikes again + // + PolicySet::Type::priorityBandedConnection_const_iterator b (o.begin_priorityBandedConnection()), e (o.end_priorityBandedConnection()); + + if (b != e) + { + priorityBandedConnection_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) priorityBandedConnection_next (o); + } + + priorityBandedConnection_post (o); + } + + else priorityBandedConnection_none (o); + } + + void PolicySet:: + priorityBandedConnection_pre (Type&) + { + } + + void PolicySet:: + priorityBandedConnection_pre (Type const&) + { + } + + void PolicySet:: + priorityBandedConnection_next (Type&) + { + } + + void PolicySet:: + priorityBandedConnection_next (Type const&) + { + } + + void PolicySet:: + priorityBandedConnection_post (Type&) + { + } + + void PolicySet:: + priorityBandedConnection_post (Type const&) + { + } + + void PolicySet:: + priorityBandedConnection_none (Type&) + { + } + + void PolicySet:: + priorityBandedConnection_none (Type const&) + { + } + + void PolicySet:: + id (Type& o) + { + dispatch (o.id ()); + } + + void PolicySet:: + id (Type const& o) + { + dispatch (o.id ()); + } + + void PolicySet:: + id_none (Type&) + { + } + + void PolicySet:: + id_none (Type const&) + { + } + + void PolicySet:: + post (Type&) + { + } + + void PolicySet:: + post (Type const&) + { + } + + // PriorityModelPolicyDef + // + // + + void PriorityModelPolicyDef:: + traverse (Type& o) + { + pre (o); + priority_model (o); + if (o.server_priority_p ()) server_priority (o); + else server_priority_none (o); + post (o); + } + + void PriorityModelPolicyDef:: + traverse (Type const& o) + { + pre (o); + priority_model (o); + if (o.server_priority_p ()) server_priority (o); + else server_priority_none (o); + post (o); + } + + void PriorityModelPolicyDef:: + pre (Type&) + { + } + + void PriorityModelPolicyDef:: + pre (Type const&) + { + } + + void PriorityModelPolicyDef:: + priority_model (Type& o) + { + dispatch (o.priority_model ()); + } + + void PriorityModelPolicyDef:: + priority_model (Type const& o) + { + dispatch (o.priority_model ()); + } + + void PriorityModelPolicyDef:: + server_priority (Type& o) + { + dispatch (o.server_priority ()); + } + + void PriorityModelPolicyDef:: + server_priority (Type const& o) + { + dispatch (o.server_priority ()); + } + + void PriorityModelPolicyDef:: + server_priority_none (Type&) + { + } + + void PriorityModelPolicyDef:: + server_priority_none (Type const&) + { + } + + void PriorityModelPolicyDef:: + post (Type&) + { + } + + void PriorityModelPolicyDef:: + post (Type const&) + { + } + + // NWPriorityModelPolicyDef + // + // + + void NWPriorityModelPolicyDef:: + traverse (Type& o) + { + pre (o); + nw_priority_model (o); + request_dscp (o); + reply_dscp (o); + post (o); + } + + void NWPriorityModelPolicyDef:: + traverse (Type const& o) + { + pre (o); + nw_priority_model (o); + request_dscp (o); + reply_dscp (o); + post (o); + } + + void NWPriorityModelPolicyDef:: + pre (Type&) + { + } + + void NWPriorityModelPolicyDef:: + pre (Type const&) + { + } + + void NWPriorityModelPolicyDef:: + nw_priority_model (Type& o) + { + dispatch (o.nw_priority_model ()); + } + + void NWPriorityModelPolicyDef:: + nw_priority_model (Type const& o) + { + dispatch (o.nw_priority_model ()); + } + + void NWPriorityModelPolicyDef:: + request_dscp (Type& o) + { + dispatch (o.request_dscp ()); + } + + void NWPriorityModelPolicyDef:: + request_dscp (Type const& o) + { + dispatch (o.request_dscp ()); + } + + void NWPriorityModelPolicyDef:: + reply_dscp (Type& o) + { + dispatch (o.reply_dscp ()); + } + + void NWPriorityModelPolicyDef:: + reply_dscp (Type const& o) + { + dispatch (o.reply_dscp ()); + } + + void NWPriorityModelPolicyDef:: + post (Type&) + { + } + + void NWPriorityModelPolicyDef:: + post (Type const&) + { + } + + // CNWPriorityModelPolicyDef + // + // + + void CNWPriorityModelPolicyDef:: + traverse (Type& o) + { + pre (o); + request_dscp (o); + reply_dscp (o); + post (o); + } + + void CNWPriorityModelPolicyDef:: + traverse (Type const& o) + { + pre (o); + request_dscp (o); + reply_dscp (o); + post (o); + } + + void CNWPriorityModelPolicyDef:: + pre (Type&) + { + } + + void CNWPriorityModelPolicyDef:: + pre (Type const&) + { + } + + void CNWPriorityModelPolicyDef:: + request_dscp (Type& o) + { + dispatch (o.request_dscp ()); + } + + void CNWPriorityModelPolicyDef:: + request_dscp (Type const& o) + { + dispatch (o.request_dscp ()); + } + + void CNWPriorityModelPolicyDef:: + reply_dscp (Type& o) + { + dispatch (o.reply_dscp ()); + } + + void CNWPriorityModelPolicyDef:: + reply_dscp (Type const& o) + { + dispatch (o.reply_dscp ()); + } + + void CNWPriorityModelPolicyDef:: + post (Type&) + { + } + + void CNWPriorityModelPolicyDef:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // ServerResourcesDef + // + // + + ServerResourcesDef:: + ServerResourcesDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ServerResourcesDef:: + ServerResourcesDef () + { + } + + void ServerResourcesDef:: + traverse (Type const& o) + { + Traversal::ServerResourcesDef::traverse (o); + } + + void ServerResourcesDef:: + cmdline (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("cmdline", top_ ())); + Traversal::ServerResourcesDef::cmdline (o); + pop_ (); + } + + void ServerResourcesDef:: + svcconf (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("svcconf", top_ ())); + Traversal::ServerResourcesDef::svcconf (o); + pop_ (); + } + + void ServerResourcesDef:: + orbConfigs (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("orbConfigs", top_ ())); + Traversal::ServerResourcesDef::orbConfigs (o); + pop_ (); + } + + void ServerResourcesDef:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ServerResourcesDef::id (o); + attr_ (0); + } + + // ServerCmdlineOptions + // + // + + ServerCmdlineOptions:: + ServerCmdlineOptions (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ServerCmdlineOptions:: + ServerCmdlineOptions () + { + } + + void ServerCmdlineOptions:: + traverse (Type const& o) + { + Traversal::ServerCmdlineOptions::traverse (o); + } + + void ServerCmdlineOptions:: + arg_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("arg", top_ ())); + } + + void ServerCmdlineOptions:: + arg_next (Type const& o) + { + arg_post (o); + arg_pre (o); + } + + void ServerCmdlineOptions:: + arg_post (Type const&) + { + pop_ (); + } + + // ACESvcConf + // + // + + ACESvcConf:: + ACESvcConf (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ACESvcConf:: + ACESvcConf () + { + } + + void ACESvcConf:: + traverse (Type const& o) + { + Traversal::ACESvcConf::traverse (o); + } + + void ACESvcConf:: + uri (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("uri", top_ ())); + Traversal::ACESvcConf::uri (o); + pop_ (); + } + + // ORBConfigs + // + // + + ORBConfigs:: + ORBConfigs (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ORBConfigs:: + ORBConfigs () + { + } + + void ORBConfigs:: + traverse (Type const& o) + { + Traversal::ORBConfigs::traverse (o); + } + + void ORBConfigs:: + resources (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resources", top_ ())); + Traversal::ORBConfigs::resources (o); + pop_ (); + } + + void ORBConfigs:: + policySet_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("policySet", top_ ())); + } + + void ORBConfigs:: + policySet_next (Type const& o) + { + policySet_post (o); + policySet_pre (o); + } + + void ORBConfigs:: + policySet_post (Type const&) + { + pop_ (); + } + + // ORBResources + // + // + + ORBResources:: + ORBResources (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ORBResources:: + ORBResources () + { + } + + void ORBResources:: + traverse (Type const& o) + { + Traversal::ORBResources::traverse (o); + } + + void ORBResources:: + threadpool_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("threadpool", top_ ())); + } + + void ORBResources:: + threadpool_next (Type const& o) + { + threadpool_post (o); + threadpool_pre (o); + } + + void ORBResources:: + threadpool_post (Type const&) + { + pop_ (); + } + + void ORBResources:: + threadpoolWithLanes_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("threadpoolWithLanes", top_ ())); + } + + void ORBResources:: + threadpoolWithLanes_next (Type const& o) + { + threadpoolWithLanes_post (o); + threadpoolWithLanes_pre (o); + } + + void ORBResources:: + threadpoolWithLanes_post (Type const&) + { + pop_ (); + } + + void ORBResources:: + connectionBands_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("connectionBands", top_ ())); + } + + void ORBResources:: + connectionBands_next (Type const& o) + { + connectionBands_post (o); + connectionBands_pre (o); + } + + void ORBResources:: + connectionBands_post (Type const&) + { + pop_ (); + } + + // ThreadpoolDef + // + // + + ThreadpoolDef:: + ThreadpoolDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ThreadpoolDef:: + ThreadpoolDef () + { + } + + void ThreadpoolDef:: + traverse (Type const& o) + { + Traversal::ThreadpoolDef::traverse (o); + } + + void ThreadpoolDef:: + stacksize (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("stacksize", top_ ())); + Traversal::ThreadpoolDef::stacksize (o); + pop_ (); + } + + void ThreadpoolDef:: + static_threads (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("static_threads", top_ ())); + Traversal::ThreadpoolDef::static_threads (o); + pop_ (); + } + + void ThreadpoolDef:: + dynamic_threads (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("dynamic_threads", top_ ())); + Traversal::ThreadpoolDef::dynamic_threads (o); + pop_ (); + } + + void ThreadpoolDef:: + default_priority (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("default_priority", top_ ())); + Traversal::ThreadpoolDef::default_priority (o); + pop_ (); + } + + void ThreadpoolDef:: + allow_request_buffering (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("allow_request_buffering", top_ ())); + Traversal::ThreadpoolDef::allow_request_buffering (o); + pop_ (); + } + + void ThreadpoolDef:: + max_buffered_requests (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("max_buffered_requests", top_ ())); + Traversal::ThreadpoolDef::max_buffered_requests (o); + pop_ (); + } + + void ThreadpoolDef:: + max_request_buffered_size (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("max_request_buffered_size", top_ ())); + Traversal::ThreadpoolDef::max_request_buffered_size (o); + pop_ (); + } + + void ThreadpoolDef:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ThreadpoolDef::id (o); + attr_ (0); + } + + // ThreadpoolWithLanesDef + // + // + + ThreadpoolWithLanesDef:: + ThreadpoolWithLanesDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ThreadpoolWithLanesDef:: + ThreadpoolWithLanesDef () + { + } + + void ThreadpoolWithLanesDef:: + traverse (Type const& o) + { + Traversal::ThreadpoolWithLanesDef::traverse (o); + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("threadpoolLane", top_ ())); + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_next (Type const& o) + { + threadpoolLane_post (o); + threadpoolLane_pre (o); + } + + void ThreadpoolWithLanesDef:: + threadpoolLane_post (Type const&) + { + pop_ (); + } + + void ThreadpoolWithLanesDef:: + stacksize (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("stacksize", top_ ())); + Traversal::ThreadpoolWithLanesDef::stacksize (o); + pop_ (); + } + + void ThreadpoolWithLanesDef:: + allow_borrowing (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("allow_borrowing", top_ ())); + Traversal::ThreadpoolWithLanesDef::allow_borrowing (o); + pop_ (); + } + + void ThreadpoolWithLanesDef:: + allow_request_buffering (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("allow_request_buffering", top_ ())); + Traversal::ThreadpoolWithLanesDef::allow_request_buffering (o); + pop_ (); + } + + void ThreadpoolWithLanesDef:: + max_buffered_requests (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("max_buffered_requests", top_ ())); + Traversal::ThreadpoolWithLanesDef::max_buffered_requests (o); + pop_ (); + } + + void ThreadpoolWithLanesDef:: + max_request_buffered_size (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("max_request_buffered_size", top_ ())); + Traversal::ThreadpoolWithLanesDef::max_request_buffered_size (o); + pop_ (); + } + + void ThreadpoolWithLanesDef:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ThreadpoolWithLanesDef::id (o); + attr_ (0); + } + + // ThreadpoolLaneDef + // + // + + ThreadpoolLaneDef:: + ThreadpoolLaneDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ThreadpoolLaneDef:: + ThreadpoolLaneDef () + { + } + + void ThreadpoolLaneDef:: + traverse (Type const& o) + { + Traversal::ThreadpoolLaneDef::traverse (o); + } + + void ThreadpoolLaneDef:: + static_threads (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("static_threads", top_ ())); + Traversal::ThreadpoolLaneDef::static_threads (o); + pop_ (); + } + + void ThreadpoolLaneDef:: + dynamic_threads (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("dynamic_threads", top_ ())); + Traversal::ThreadpoolLaneDef::dynamic_threads (o); + pop_ (); + } + + void ThreadpoolLaneDef:: + priority (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("priority", top_ ())); + Traversal::ThreadpoolLaneDef::priority (o); + pop_ (); + } + + // ConnectionBandsDef + // + // + + ConnectionBandsDef:: + ConnectionBandsDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + ConnectionBandsDef:: + ConnectionBandsDef () + { + } + + void ConnectionBandsDef:: + traverse (Type const& o) + { + Traversal::ConnectionBandsDef::traverse (o); + } + + void ConnectionBandsDef:: + band_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("band", top_ ())); + } + + void ConnectionBandsDef:: + band_next (Type const& o) + { + band_post (o); + band_pre (o); + } + + void ConnectionBandsDef:: + band_post (Type const&) + { + pop_ (); + } + + void ConnectionBandsDef:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::ConnectionBandsDef::id (o); + attr_ (0); + } + + // PriorityBandDef + // + // + + PriorityBandDef:: + PriorityBandDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PriorityBandDef:: + PriorityBandDef () + { + } + + void PriorityBandDef:: + traverse (Type const& o) + { + Traversal::PriorityBandDef::traverse (o); + } + + void PriorityBandDef:: + low (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("low", top_ ())); + Traversal::PriorityBandDef::low (o); + pop_ (); + } + + void PriorityBandDef:: + high (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("high", top_ ())); + Traversal::PriorityBandDef::high (o); + pop_ (); + } + + // PolicySet + // + // + + PolicySet:: + PolicySet (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PolicySet:: + PolicySet () + { + } + + void PolicySet:: + traverse (Type const& o) + { + Traversal::PolicySet::traverse (o); + } + + void PolicySet:: + priorityModel_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("priorityModel", top_ ())); + } + + void PolicySet:: + priorityModel_next (Type const& o) + { + priorityModel_post (o); + priorityModel_pre (o); + } + + void PolicySet:: + priorityModel_post (Type const&) + { + pop_ (); + } + + void PolicySet:: + nwpriorityModel_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("nwpriorityModel", top_ ())); + } + + void PolicySet:: + nwpriorityModel_next (Type const& o) + { + nwpriorityModel_post (o); + nwpriorityModel_pre (o); + } + + void PolicySet:: + nwpriorityModel_post (Type const&) + { + pop_ (); + } + + void PolicySet:: + cnwpriorityModel_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("cnwpriorityModel", top_ ())); + } + + void PolicySet:: + cnwpriorityModel_next (Type const& o) + { + cnwpriorityModel_post (o); + cnwpriorityModel_pre (o); + } + + void PolicySet:: + cnwpriorityModel_post (Type const&) + { + pop_ (); + } + + void PolicySet:: + threadpool_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("threadpool", top_ ())); + } + + void PolicySet:: + threadpool_next (Type const& o) + { + threadpool_post (o); + threadpool_pre (o); + } + + void PolicySet:: + threadpool_post (Type const&) + { + pop_ (); + } + + void PolicySet:: + priorityBandedConnection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("priorityBandedConnection", top_ ())); + } + + void PolicySet:: + priorityBandedConnection_next (Type const& o) + { + priorityBandedConnection_post (o); + priorityBandedConnection_pre (o); + } + + void PolicySet:: + priorityBandedConnection_post (Type const&) + { + pop_ (); + } + + void PolicySet:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", top_ ()); + attr_ (&a); + Traversal::PolicySet::id (o); + attr_ (0); + } + + // PriorityModel + // + // + + PriorityModel:: + PriorityModel (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PriorityModel:: + PriorityModel () + { + } + + void PriorityModel:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::PriorityModel::SERVER_DECLARED) s = "SERVER_DECLARED"; + else if (o == ::CIAO::Config_Handlers::PriorityModel::CLIENT_PROPAGATED) s = "CLIENT_PROPAGATED"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // NWPriorityModel + // + // + + NWPriorityModel:: + NWPriorityModel (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + NWPriorityModel:: + NWPriorityModel () + { + } + + void NWPriorityModel:: + traverse (Type const& o) + { + ::std::basic_string< ACE_TCHAR > s; + + if (o == ::CIAO::Config_Handlers::NWPriorityModel::SERVER_DECLARED_NWPRIORITY) s = "SERVER_DECLARED_NWPRIORITY"; + else if (o == ::CIAO::Config_Handlers::NWPriorityModel::CLIENT_PROPAGATED_NWPRIORITY) s = "CLIENT_PROPAGATED_NWPRIORITY"; + else + { + } + + if (::XSCRT::XML::Attribute< ACE_TCHAR >* a = attr_ ()) + { + a->value (s); + } + + else + { + top_().value (s); + } + } + + // PriorityModelPolicyDef + // + // + + PriorityModelPolicyDef:: + PriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + PriorityModelPolicyDef:: + PriorityModelPolicyDef () + { + } + + void PriorityModelPolicyDef:: + traverse (Type const& o) + { + Traversal::PriorityModelPolicyDef::traverse (o); + } + + void PriorityModelPolicyDef:: + priority_model (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("priority_model", top_ ())); + Traversal::PriorityModelPolicyDef::priority_model (o); + pop_ (); + } + + void PriorityModelPolicyDef:: + server_priority (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("server_priority", "", top_ ()); + attr_ (&a); + Traversal::PriorityModelPolicyDef::server_priority (o); + attr_ (0); + } + + // NWPriorityModelPolicyDef + // + // + + NWPriorityModelPolicyDef:: + NWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + NWPriorityModelPolicyDef:: + NWPriorityModelPolicyDef () + { + } + + void NWPriorityModelPolicyDef:: + traverse (Type const& o) + { + Traversal::NWPriorityModelPolicyDef::traverse (o); + } + + void NWPriorityModelPolicyDef:: + nw_priority_model (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("nw_priority_model", top_ ())); + Traversal::NWPriorityModelPolicyDef::nw_priority_model (o); + pop_ (); + } + + void NWPriorityModelPolicyDef:: + request_dscp (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("request_dscp", top_ ())); + Traversal::NWPriorityModelPolicyDef::request_dscp (o); + pop_ (); + } + + void NWPriorityModelPolicyDef:: + reply_dscp (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("reply_dscp", top_ ())); + Traversal::NWPriorityModelPolicyDef::reply_dscp (o); + pop_ (); + } + + // CNWPriorityModelPolicyDef + // + // + + CNWPriorityModelPolicyDef:: + CNWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >& e) + : ::XSCRT::Writer< ACE_TCHAR > (e) + { + } + + CNWPriorityModelPolicyDef:: + CNWPriorityModelPolicyDef () + { + } + + void CNWPriorityModelPolicyDef:: + traverse (Type const& o) + { + Traversal::CNWPriorityModelPolicyDef::traverse (o); + } + + void CNWPriorityModelPolicyDef:: + request_dscp (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("request_dscp", top_ ())); + Traversal::CNWPriorityModelPolicyDef::request_dscp (o); + pop_ (); + } + + void CNWPriorityModelPolicyDef:: + reply_dscp (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("reply_dscp", top_ ())); + Traversal::CNWPriorityModelPolicyDef::reply_dscp (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + void + ServerResources (::CIAO::Config_Handlers::ServerResourcesDef const& s, xercesc::DOMDocument* d) + { + ::XSCRT::XML::Element< ACE_TCHAR > e (d->getDocumentElement ()); + if (e.name () != "ServerResources") + { + throw 1; + } + + struct W : virtual ::CIAO::Config_Handlers::Writer::ServerResourcesDef, + virtual ::CIAO::Config_Handlers::Writer::ServerCmdlineOptions, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::string< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ACESvcConf, + virtual ::CIAO::Config_Handlers::Writer::ORBConfigs, + virtual ::CIAO::Config_Handlers::Writer::ORBResources, + virtual ::CIAO::Config_Handlers::Writer::ThreadpoolDef, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::unsignedLong, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::int_, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::boolean, ACE_TCHAR >, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::ID< ACE_TCHAR >, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::ThreadpoolWithLanesDef, + virtual ::CIAO::Config_Handlers::Writer::ThreadpoolLaneDef, + virtual ::CIAO::Config_Handlers::Writer::ConnectionBandsDef, + virtual ::CIAO::Config_Handlers::Writer::PriorityBandDef, + virtual ::CIAO::Config_Handlers::Writer::PolicySet, + virtual ::CIAO::Config_Handlers::Writer::PriorityModelPolicyDef, + virtual ::CIAO::Config_Handlers::Writer::PriorityModel, + virtual ::CIAO::Config_Handlers::Writer::NWPriorityModelPolicyDef, + virtual ::CIAO::Config_Handlers::Writer::NWPriorityModel, + virtual ::XMLSchema::Writer::FundamentalType< ::XMLSchema::long_, ACE_TCHAR >, + virtual ::CIAO::Config_Handlers::Writer::CNWPriorityModelPolicyDef, + 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/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.hpp b/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.hpp new file mode 100644 index 00000000000..a5a4cd9c951 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CIAOServerResources.hpp @@ -0,0 +1,2940 @@ +/* $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 CIAOSERVER_RESOURCES_HPP +#define CIAOSERVER_RESOURCES_HPP + +#include "RT_CCM_Handlers_Export.h" +// Forward declarations. +// +namespace CIAO +{ + namespace Config_Handlers + { + class ServerResourcesDef; + class ServerCmdlineOptions; + class ACESvcConf; + class ORBConfigs; + class ORBResources; + class ThreadpoolDef; + class ThreadpoolWithLanesDef; + class ThreadpoolLaneDef; + class ConnectionBandsDef; + class PriorityBandDef; + class PolicySet; + class PriorityModel; + class NWPriorityModel; + class PriorityModelPolicyDef; + class NWPriorityModelPolicyDef; + class CNWPriorityModelPolicyDef; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class RT_CCM_Handlers_Export ServerResourcesDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // cmdline + // + public: + bool cmdline_p () const; + ::CIAO::Config_Handlers::ServerCmdlineOptions const& cmdline () const; + void cmdline (::CIAO::Config_Handlers::ServerCmdlineOptions const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ServerCmdlineOptions > cmdline_; + + // svcconf + // + public: + bool svcconf_p () const; + ::CIAO::Config_Handlers::ACESvcConf const& svcconf () const; + void svcconf (::CIAO::Config_Handlers::ACESvcConf const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ACESvcConf > svcconf_; + + // orbConfigs + // + public: + ::CIAO::Config_Handlers::ORBConfigs const& orbConfigs () const; + void orbConfigs (::CIAO::Config_Handlers::ORBConfigs const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ORBConfigs > orbConfigs_; + + // 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: + ServerResourcesDef (::CIAO::Config_Handlers::ORBConfigs const& orbConfigs__); + + ServerResourcesDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + ServerResourcesDef (ServerResourcesDef const& s); + + ServerResourcesDef& + operator= (ServerResourcesDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ServerCmdlineOptions : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // arg + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator arg_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::const_iterator arg_const_iterator; + arg_iterator begin_arg (); + arg_iterator end_arg (); + arg_const_iterator begin_arg () const; + arg_const_iterator end_arg () const; + void add_arg (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_arg (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > arg_; + + public: + ServerCmdlineOptions (); + + ServerCmdlineOptions (::XSCRT::XML::Element< ACE_TCHAR > const&); + ServerCmdlineOptions (ServerCmdlineOptions const& s); + + ServerCmdlineOptions& + operator= (ServerCmdlineOptions const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ACESvcConf : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // uri + // + public: + bool uri_p () const; + ::XMLSchema::string< ACE_TCHAR > const& uri () const; + void uri (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > uri_; + + public: + ACESvcConf (); + + ACESvcConf (::XSCRT::XML::Element< ACE_TCHAR > const&); + ACESvcConf (ACESvcConf const& s); + + ACESvcConf& + operator= (ACESvcConf const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ORBConfigs : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // resources + // + public: + bool resources_p () const; + ::CIAO::Config_Handlers::ORBResources const& resources () const; + void resources (::CIAO::Config_Handlers::ORBResources const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::ORBResources > resources_; + + // policySet + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PolicySet >::iterator policySet_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PolicySet >::const_iterator policySet_const_iterator; + policySet_iterator begin_policySet (); + policySet_iterator end_policySet (); + policySet_const_iterator begin_policySet () const; + policySet_const_iterator end_policySet () const; + void add_policySet (::CIAO::Config_Handlers::PolicySet const& ); + size_t count_policySet (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PolicySet > policySet_; + + public: + ORBConfigs (); + + ORBConfigs (::XSCRT::XML::Element< ACE_TCHAR > const&); + ORBConfigs (ORBConfigs const& s); + + ORBConfigs& + operator= (ORBConfigs const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ORBResources : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // threadpool + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolDef >::iterator threadpool_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolDef >::const_iterator threadpool_const_iterator; + threadpool_iterator begin_threadpool (); + threadpool_iterator end_threadpool (); + threadpool_const_iterator begin_threadpool () const; + threadpool_const_iterator end_threadpool () const; + void add_threadpool (::CIAO::Config_Handlers::ThreadpoolDef const& ); + size_t count_threadpool (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ThreadpoolDef > threadpool_; + + // threadpoolWithLanes + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolWithLanesDef >::iterator threadpoolWithLanes_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolWithLanesDef >::const_iterator threadpoolWithLanes_const_iterator; + threadpoolWithLanes_iterator begin_threadpoolWithLanes (); + threadpoolWithLanes_iterator end_threadpoolWithLanes (); + threadpoolWithLanes_const_iterator begin_threadpoolWithLanes () const; + threadpoolWithLanes_const_iterator end_threadpoolWithLanes () const; + void add_threadpoolWithLanes (::CIAO::Config_Handlers::ThreadpoolWithLanesDef const& ); + size_t count_threadpoolWithLanes (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ThreadpoolWithLanesDef > threadpoolWithLanes_; + + // connectionBands + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ConnectionBandsDef >::iterator connectionBands_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ConnectionBandsDef >::const_iterator connectionBands_const_iterator; + connectionBands_iterator begin_connectionBands (); + connectionBands_iterator end_connectionBands (); + connectionBands_const_iterator begin_connectionBands () const; + connectionBands_const_iterator end_connectionBands () const; + void add_connectionBands (::CIAO::Config_Handlers::ConnectionBandsDef const& ); + size_t count_connectionBands (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ConnectionBandsDef > connectionBands_; + + public: + ORBResources (); + + ORBResources (::XSCRT::XML::Element< ACE_TCHAR > const&); + ORBResources (ORBResources const& s); + + ORBResources& + operator= (ORBResources const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ThreadpoolDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // stacksize + // + public: + ::XMLSchema::unsignedLong const& stacksize () const; + void stacksize (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > stacksize_; + + // static_threads + // + public: + ::XMLSchema::unsignedLong const& static_threads () const; + void static_threads (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > static_threads_; + + // dynamic_threads + // + public: + ::XMLSchema::unsignedLong const& dynamic_threads () const; + void dynamic_threads (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > dynamic_threads_; + + // default_priority + // + public: + ::XMLSchema::int_ const& default_priority () const; + void default_priority (::XMLSchema::int_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::int_ > default_priority_; + + // allow_request_buffering + // + public: + ::XMLSchema::boolean const& allow_request_buffering () const; + void allow_request_buffering (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > allow_request_buffering_; + + // max_buffered_requests + // + public: + ::XMLSchema::unsignedLong const& max_buffered_requests () const; + void max_buffered_requests (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > max_buffered_requests_; + + // max_request_buffered_size + // + public: + ::XMLSchema::unsignedLong const& max_request_buffered_size () const; + void max_request_buffered_size (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > max_request_buffered_size_; + + // 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: + ThreadpoolDef (::XMLSchema::unsignedLong const& stacksize__, + ::XMLSchema::unsignedLong const& static_threads__, + ::XMLSchema::unsignedLong const& dynamic_threads__, + ::XMLSchema::int_ const& default_priority__, + ::XMLSchema::boolean const& allow_request_buffering__, + ::XMLSchema::unsignedLong const& max_buffered_requests__, + ::XMLSchema::unsignedLong const& max_request_buffered_size__); + + ThreadpoolDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + ThreadpoolDef (ThreadpoolDef const& s); + + ThreadpoolDef& + operator= (ThreadpoolDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ThreadpoolWithLanesDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // threadpoolLane + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolLaneDef >::iterator threadpoolLane_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ThreadpoolLaneDef >::const_iterator threadpoolLane_const_iterator; + threadpoolLane_iterator begin_threadpoolLane (); + threadpoolLane_iterator end_threadpoolLane (); + threadpoolLane_const_iterator begin_threadpoolLane () const; + threadpoolLane_const_iterator end_threadpoolLane () const; + void add_threadpoolLane (::CIAO::Config_Handlers::ThreadpoolLaneDef const& ); + size_t count_threadpoolLane (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ThreadpoolLaneDef > threadpoolLane_; + + // stacksize + // + public: + ::XMLSchema::unsignedLong const& stacksize () const; + void stacksize (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > stacksize_; + + // allow_borrowing + // + public: + ::XMLSchema::boolean const& allow_borrowing () const; + void allow_borrowing (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > allow_borrowing_; + + // allow_request_buffering + // + public: + ::XMLSchema::boolean const& allow_request_buffering () const; + void allow_request_buffering (::XMLSchema::boolean const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::boolean > allow_request_buffering_; + + // max_buffered_requests + // + public: + ::XMLSchema::unsignedLong const& max_buffered_requests () const; + void max_buffered_requests (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > max_buffered_requests_; + + // max_request_buffered_size + // + public: + ::XMLSchema::unsignedLong const& max_request_buffered_size () const; + void max_request_buffered_size (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > max_request_buffered_size_; + + // 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: + ThreadpoolWithLanesDef (::XMLSchema::unsignedLong const& stacksize__, + ::XMLSchema::boolean const& allow_borrowing__, + ::XMLSchema::boolean const& allow_request_buffering__, + ::XMLSchema::unsignedLong const& max_buffered_requests__, + ::XMLSchema::unsignedLong const& max_request_buffered_size__); + + ThreadpoolWithLanesDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + ThreadpoolWithLanesDef (ThreadpoolWithLanesDef const& s); + + ThreadpoolWithLanesDef& + operator= (ThreadpoolWithLanesDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ThreadpoolLaneDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // static_threads + // + public: + ::XMLSchema::unsignedLong const& static_threads () const; + void static_threads (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > static_threads_; + + // dynamic_threads + // + public: + ::XMLSchema::unsignedLong const& dynamic_threads () const; + void dynamic_threads (::XMLSchema::unsignedLong const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::unsignedLong > dynamic_threads_; + + // priority + // + public: + ::XMLSchema::int_ const& priority () const; + void priority (::XMLSchema::int_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::int_ > priority_; + + public: + ThreadpoolLaneDef (::XMLSchema::unsignedLong const& static_threads__, + ::XMLSchema::unsignedLong const& dynamic_threads__, + ::XMLSchema::int_ const& priority__); + + ThreadpoolLaneDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + ThreadpoolLaneDef (ThreadpoolLaneDef const& s); + + ThreadpoolLaneDef& + operator= (ThreadpoolLaneDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export ConnectionBandsDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // band + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PriorityBandDef >::iterator band_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PriorityBandDef >::const_iterator band_const_iterator; + band_iterator begin_band (); + band_iterator end_band (); + band_const_iterator begin_band () const; + band_const_iterator end_band () const; + void add_band (::CIAO::Config_Handlers::PriorityBandDef const& ); + size_t count_band (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PriorityBandDef > band_; + + // 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: + ConnectionBandsDef (); + + ConnectionBandsDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + ConnectionBandsDef (ConnectionBandsDef const& s); + + ConnectionBandsDef& + operator= (ConnectionBandsDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export PriorityBandDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // low + // + public: + ::XMLSchema::int_ const& low () const; + void low (::XMLSchema::int_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::int_ > low_; + + // high + // + public: + ::XMLSchema::int_ const& high () const; + void high (::XMLSchema::int_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::int_ > high_; + + public: + PriorityBandDef (::XMLSchema::int_ const& low__, + ::XMLSchema::int_ const& high__); + + PriorityBandDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + PriorityBandDef (PriorityBandDef const& s); + + PriorityBandDef& + operator= (PriorityBandDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export PolicySet : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // priorityModel + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PriorityModelPolicyDef >::iterator priorityModel_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PriorityModelPolicyDef >::const_iterator priorityModel_const_iterator; + priorityModel_iterator begin_priorityModel (); + priorityModel_iterator end_priorityModel (); + priorityModel_const_iterator begin_priorityModel () const; + priorityModel_const_iterator end_priorityModel () const; + void add_priorityModel (::CIAO::Config_Handlers::PriorityModelPolicyDef const& ); + size_t count_priorityModel (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PriorityModelPolicyDef > priorityModel_; + + // nwpriorityModel + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::NWPriorityModelPolicyDef >::iterator nwpriorityModel_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::NWPriorityModelPolicyDef >::const_iterator nwpriorityModel_const_iterator; + nwpriorityModel_iterator begin_nwpriorityModel (); + nwpriorityModel_iterator end_nwpriorityModel (); + nwpriorityModel_const_iterator begin_nwpriorityModel () const; + nwpriorityModel_const_iterator end_nwpriorityModel () const; + void add_nwpriorityModel (::CIAO::Config_Handlers::NWPriorityModelPolicyDef const& ); + size_t count_nwpriorityModel (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::NWPriorityModelPolicyDef > nwpriorityModel_; + + // cnwpriorityModel + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef >::iterator cnwpriorityModel_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef >::const_iterator cnwpriorityModel_const_iterator; + cnwpriorityModel_iterator begin_cnwpriorityModel (); + cnwpriorityModel_iterator end_cnwpriorityModel (); + cnwpriorityModel_const_iterator begin_cnwpriorityModel () const; + cnwpriorityModel_const_iterator end_cnwpriorityModel () const; + void add_cnwpriorityModel (::CIAO::Config_Handlers::CNWPriorityModelPolicyDef const& ); + size_t count_cnwpriorityModel (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef > cnwpriorityModel_; + + // threadpool + // + public: + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::iterator threadpool_iterator; + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::const_iterator threadpool_const_iterator; + threadpool_iterator begin_threadpool (); + threadpool_iterator end_threadpool (); + threadpool_const_iterator begin_threadpool () const; + threadpool_const_iterator end_threadpool () const; + void add_threadpool (::XMLSchema::IDREF< ACE_TCHAR > const& ); + size_t count_threadpool (void) const; + + protected: + ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > > threadpool_; + + // priorityBandedConnection + // + public: + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::iterator priorityBandedConnection_iterator; + typedef ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > >::const_iterator priorityBandedConnection_const_iterator; + priorityBandedConnection_iterator begin_priorityBandedConnection (); + priorityBandedConnection_iterator end_priorityBandedConnection (); + priorityBandedConnection_const_iterator begin_priorityBandedConnection () const; + priorityBandedConnection_const_iterator end_priorityBandedConnection () const; + void add_priorityBandedConnection (::XMLSchema::IDREF< ACE_TCHAR > const& ); + size_t count_priorityBandedConnection (void) const; + + protected: + ::std::list< ::XMLSchema::IDREF< ACE_TCHAR > > priorityBandedConnection_; + + // 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: + PolicySet (); + + PolicySet (::XSCRT::XML::Element< ACE_TCHAR > const&); + PolicySet (PolicySet const& s); + + PolicySet& + operator= (PolicySet const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export PriorityModel : public ::XSCRT::Type + { + public: + PriorityModel (::XSCRT::XML::Element< ACE_TCHAR > const&); + PriorityModel (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static PriorityModel const SERVER_DECLARED; + static PriorityModel const CLIENT_PROPAGATED; + + enum Value + { + SERVER_DECLARED_l, CLIENT_PROPAGATED_l + }; + + + Value + integral () const; + + friend bool RT_CCM_Handlers_Export + operator== (PriorityModel const& a, PriorityModel const& b); + + friend bool RT_CCM_Handlers_Export + operator!= (PriorityModel const& a, PriorityModel const& b); + + private: + PriorityModel (Value v); + + Value v_; + }; + + bool RT_CCM_Handlers_Export operator== (PriorityModel const &a, PriorityModel const &b); + + bool RT_CCM_Handlers_Export operator!= (PriorityModel const &a, PriorityModel const &b); + + + class RT_CCM_Handlers_Export NWPriorityModel : public ::XSCRT::Type + { + public: + NWPriorityModel (::XSCRT::XML::Element< ACE_TCHAR > const&); + NWPriorityModel (::XSCRT::XML::Attribute< ACE_TCHAR > const&); + + static NWPriorityModel const SERVER_DECLARED_NWPRIORITY; + static NWPriorityModel const CLIENT_PROPAGATED_NWPRIORITY; + + enum Value + { + SERVER_DECLARED_NWPRIORITY_l, CLIENT_PROPAGATED_NWPRIORITY_l + }; + + + Value + integral () const; + + friend bool RT_CCM_Handlers_Export + operator== (NWPriorityModel const& a, NWPriorityModel const& b); + + friend bool RT_CCM_Handlers_Export + operator!= (NWPriorityModel const& a, NWPriorityModel const& b); + + private: + NWPriorityModel (Value v); + + Value v_; + }; + + bool RT_CCM_Handlers_Export operator== (NWPriorityModel const &a, NWPriorityModel const &b); + + bool RT_CCM_Handlers_Export operator!= (NWPriorityModel const &a, NWPriorityModel const &b); + + + class RT_CCM_Handlers_Export PriorityModelPolicyDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // priority_model + // + public: + ::CIAO::Config_Handlers::PriorityModel const& priority_model () const; + void priority_model (::CIAO::Config_Handlers::PriorityModel const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::PriorityModel > priority_model_; + + // server_priority + // + public: + bool server_priority_p () const; + ::XMLSchema::int_ const& server_priority () const; + ::XMLSchema::int_& server_priority (); + void server_priority (::XMLSchema::int_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::int_ > server_priority_; + + public: + PriorityModelPolicyDef (::CIAO::Config_Handlers::PriorityModel const& priority_model__); + + PriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + PriorityModelPolicyDef (PriorityModelPolicyDef const& s); + + PriorityModelPolicyDef& + operator= (PriorityModelPolicyDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export NWPriorityModelPolicyDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // nw_priority_model + // + public: + ::CIAO::Config_Handlers::NWPriorityModel const& nw_priority_model () const; + void nw_priority_model (::CIAO::Config_Handlers::NWPriorityModel const& ); + + protected: + ::std::auto_ptr< ::CIAO::Config_Handlers::NWPriorityModel > nw_priority_model_; + + // request_dscp + // + public: + ::XMLSchema::long_ const& request_dscp () const; + void request_dscp (::XMLSchema::long_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::long_ > request_dscp_; + + // reply_dscp + // + public: + ::XMLSchema::long_ const& reply_dscp () const; + void reply_dscp (::XMLSchema::long_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::long_ > reply_dscp_; + + public: + NWPriorityModelPolicyDef (::CIAO::Config_Handlers::NWPriorityModel const& nw_priority_model__, + ::XMLSchema::long_ const& request_dscp__, + ::XMLSchema::long_ const& reply_dscp__); + + NWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + NWPriorityModelPolicyDef (NWPriorityModelPolicyDef const& s); + + NWPriorityModelPolicyDef& + operator= (NWPriorityModelPolicyDef const& s); + + private: + char regulator__; + }; + + + class RT_CCM_Handlers_Export CNWPriorityModelPolicyDef : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // request_dscp + // + public: + ::XMLSchema::long_ const& request_dscp () const; + void request_dscp (::XMLSchema::long_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::long_ > request_dscp_; + + // reply_dscp + // + public: + ::XMLSchema::long_ const& reply_dscp () const; + void reply_dscp (::XMLSchema::long_ const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::long_ > reply_dscp_; + + public: + CNWPriorityModelPolicyDef (::XMLSchema::long_ const& request_dscp__, + ::XMLSchema::long_ const& reply_dscp__); + + CNWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR > const&); + CNWPriorityModelPolicyDef (CNWPriorityModelPolicyDef const& s); + + CNWPriorityModelPolicyDef& + operator= (CNWPriorityModelPolicyDef const& s); + + private: + char regulator__; + }; + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + RT_CCM_Handlers_Export + ::CIAO::Config_Handlers::ServerResourcesDef + ServerResources (xercesc::DOMDocument const*); + } +} + +#include "XMLSchema/Traversal.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + struct RT_CCM_Handlers_Export ServerResourcesDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ServerResourcesDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + cmdline (Type&); + + virtual void + cmdline (Type const&); + + virtual void + cmdline_none (Type&); + + virtual void + cmdline_none (Type const&); + + virtual void + svcconf (Type&); + + virtual void + svcconf (Type const&); + + virtual void + svcconf_none (Type&); + + virtual void + svcconf_none (Type const&); + + virtual void + orbConfigs (Type&); + + virtual void + orbConfigs (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 RT_CCM_Handlers_Export ServerCmdlineOptions : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ServerCmdlineOptions > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + arg (Type&); + + virtual void + arg (Type const&); + + virtual void + arg_pre (Type&); + + virtual void + arg_pre (Type const&); + + virtual void + arg_next (Type&); + + virtual void + arg_next (Type const&); + + virtual void + arg_post (Type&); + + virtual void + arg_post (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export ACESvcConf : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ACESvcConf > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + uri (Type&); + + virtual void + uri (Type const&); + + virtual void + uri_none (Type&); + + virtual void + uri_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export ORBConfigs : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ORBConfigs > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + resources (Type&); + + virtual void + resources (Type const&); + + virtual void + resources_none (Type&); + + virtual void + resources_none (Type const&); + + virtual void + policySet (Type&); + + virtual void + policySet (Type const&); + + virtual void + policySet_pre (Type&); + + virtual void + policySet_pre (Type const&); + + virtual void + policySet_next (Type&); + + virtual void + policySet_next (Type const&); + + virtual void + policySet_post (Type&); + + virtual void + policySet_post (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export ORBResources : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ORBResources > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + threadpool (Type&); + + virtual void + threadpool (Type const&); + + virtual void + threadpool_pre (Type&); + + virtual void + threadpool_pre (Type const&); + + virtual void + threadpool_next (Type&); + + virtual void + threadpool_next (Type const&); + + virtual void + threadpool_post (Type&); + + virtual void + threadpool_post (Type const&); + + virtual void + threadpool_none (Type&); + + virtual void + threadpool_none (Type const&); + + virtual void + threadpoolWithLanes (Type&); + + virtual void + threadpoolWithLanes (Type const&); + + virtual void + threadpoolWithLanes_pre (Type&); + + virtual void + threadpoolWithLanes_pre (Type const&); + + virtual void + threadpoolWithLanes_next (Type&); + + virtual void + threadpoolWithLanes_next (Type const&); + + virtual void + threadpoolWithLanes_post (Type&); + + virtual void + threadpoolWithLanes_post (Type const&); + + virtual void + threadpoolWithLanes_none (Type&); + + virtual void + threadpoolWithLanes_none (Type const&); + + virtual void + connectionBands (Type&); + + virtual void + connectionBands (Type const&); + + virtual void + connectionBands_pre (Type&); + + virtual void + connectionBands_pre (Type const&); + + virtual void + connectionBands_next (Type&); + + virtual void + connectionBands_next (Type const&); + + virtual void + connectionBands_post (Type&); + + virtual void + connectionBands_post (Type const&); + + virtual void + connectionBands_none (Type&); + + virtual void + connectionBands_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export ThreadpoolDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ThreadpoolDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + stacksize (Type&); + + virtual void + stacksize (Type const&); + + virtual void + static_threads (Type&); + + virtual void + static_threads (Type const&); + + virtual void + dynamic_threads (Type&); + + virtual void + dynamic_threads (Type const&); + + virtual void + default_priority (Type&); + + virtual void + default_priority (Type const&); + + virtual void + allow_request_buffering (Type&); + + virtual void + allow_request_buffering (Type const&); + + virtual void + max_buffered_requests (Type&); + + virtual void + max_buffered_requests (Type const&); + + virtual void + max_request_buffered_size (Type&); + + virtual void + max_request_buffered_size (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 RT_CCM_Handlers_Export ThreadpoolWithLanesDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ThreadpoolWithLanesDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + threadpoolLane (Type&); + + virtual void + threadpoolLane (Type const&); + + virtual void + threadpoolLane_pre (Type&); + + virtual void + threadpoolLane_pre (Type const&); + + virtual void + threadpoolLane_next (Type&); + + virtual void + threadpoolLane_next (Type const&); + + virtual void + threadpoolLane_post (Type&); + + virtual void + threadpoolLane_post (Type const&); + + virtual void + stacksize (Type&); + + virtual void + stacksize (Type const&); + + virtual void + allow_borrowing (Type&); + + virtual void + allow_borrowing (Type const&); + + virtual void + allow_request_buffering (Type&); + + virtual void + allow_request_buffering (Type const&); + + virtual void + max_buffered_requests (Type&); + + virtual void + max_buffered_requests (Type const&); + + virtual void + max_request_buffered_size (Type&); + + virtual void + max_request_buffered_size (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 RT_CCM_Handlers_Export ThreadpoolLaneDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ThreadpoolLaneDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + static_threads (Type&); + + virtual void + static_threads (Type const&); + + virtual void + dynamic_threads (Type&); + + virtual void + dynamic_threads (Type const&); + + virtual void + priority (Type&); + + virtual void + priority (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export ConnectionBandsDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::ConnectionBandsDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + band (Type&); + + virtual void + band (Type const&); + + virtual void + band_pre (Type&); + + virtual void + band_pre (Type const&); + + virtual void + band_next (Type&); + + virtual void + band_next (Type const&); + + virtual void + band_post (Type&); + + virtual void + band_post (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 RT_CCM_Handlers_Export PriorityBandDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PriorityBandDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + low (Type&); + + virtual void + low (Type const&); + + virtual void + high (Type&); + + virtual void + high (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export PolicySet : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PolicySet > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + priorityModel (Type&); + + virtual void + priorityModel (Type const&); + + virtual void + priorityModel_pre (Type&); + + virtual void + priorityModel_pre (Type const&); + + virtual void + priorityModel_next (Type&); + + virtual void + priorityModel_next (Type const&); + + virtual void + priorityModel_post (Type&); + + virtual void + priorityModel_post (Type const&); + + virtual void + priorityModel_none (Type&); + + virtual void + priorityModel_none (Type const&); + + virtual void + nwpriorityModel (Type&); + + virtual void + nwpriorityModel (Type const&); + + virtual void + nwpriorityModel_pre (Type&); + + virtual void + nwpriorityModel_pre (Type const&); + + virtual void + nwpriorityModel_next (Type&); + + virtual void + nwpriorityModel_next (Type const&); + + virtual void + nwpriorityModel_post (Type&); + + virtual void + nwpriorityModel_post (Type const&); + + virtual void + nwpriorityModel_none (Type&); + + virtual void + nwpriorityModel_none (Type const&); + + virtual void + cnwpriorityModel (Type&); + + virtual void + cnwpriorityModel (Type const&); + + virtual void + cnwpriorityModel_pre (Type&); + + virtual void + cnwpriorityModel_pre (Type const&); + + virtual void + cnwpriorityModel_next (Type&); + + virtual void + cnwpriorityModel_next (Type const&); + + virtual void + cnwpriorityModel_post (Type&); + + virtual void + cnwpriorityModel_post (Type const&); + + virtual void + cnwpriorityModel_none (Type&); + + virtual void + cnwpriorityModel_none (Type const&); + + virtual void + threadpool (Type&); + + virtual void + threadpool (Type const&); + + virtual void + threadpool_pre (Type&); + + virtual void + threadpool_pre (Type const&); + + virtual void + threadpool_next (Type&); + + virtual void + threadpool_next (Type const&); + + virtual void + threadpool_post (Type&); + + virtual void + threadpool_post (Type const&); + + virtual void + threadpool_none (Type&); + + virtual void + threadpool_none (Type const&); + + virtual void + priorityBandedConnection (Type&); + + virtual void + priorityBandedConnection (Type const&); + + virtual void + priorityBandedConnection_pre (Type&); + + virtual void + priorityBandedConnection_pre (Type const&); + + virtual void + priorityBandedConnection_next (Type&); + + virtual void + priorityBandedConnection_next (Type const&); + + virtual void + priorityBandedConnection_post (Type&); + + virtual void + priorityBandedConnection_post (Type const&); + + virtual void + priorityBandedConnection_none (Type&); + + virtual void + priorityBandedConnection_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::PriorityModel > + PriorityModel; + + typedef + ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::NWPriorityModel > + NWPriorityModel; + + struct RT_CCM_Handlers_Export PriorityModelPolicyDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::PriorityModelPolicyDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + priority_model (Type&); + + virtual void + priority_model (Type const&); + + virtual void + server_priority (Type&); + + virtual void + server_priority (Type const&); + + virtual void + server_priority_none (Type&); + + virtual void + server_priority_none (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export NWPriorityModelPolicyDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::NWPriorityModelPolicyDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + nw_priority_model (Type&); + + virtual void + nw_priority_model (Type const&); + + virtual void + request_dscp (Type&); + + virtual void + request_dscp (Type const&); + + virtual void + reply_dscp (Type&); + + virtual void + reply_dscp (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + + struct RT_CCM_Handlers_Export CNWPriorityModelPolicyDef : ::XMLSchema::Traversal::Traverser< ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef > + { + virtual void + traverse (Type&); + + virtual void + traverse (Type const&); + + virtual void + pre (Type&); + + virtual void + pre (Type const&); + + virtual void + request_dscp (Type&); + + virtual void + request_dscp (Type const&); + + virtual void + reply_dscp (Type&); + + virtual void + reply_dscp (Type const&); + + virtual void + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + struct ServerResourcesDef : Traversal::ServerResourcesDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ServerResourcesDef Type; + ServerResourcesDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + cmdline (Type &o) + { + + this->cmdline (const_cast <Type const &> (o)); + } + + + virtual void + cmdline (Type const&); + + virtual void + svcconf (Type &o) + { + + this->svcconf (const_cast <Type const &> (o)); + } + + + virtual void + svcconf (Type const&); + + virtual void + orbConfigs (Type &o) + { + + this->orbConfigs (const_cast <Type const &> (o)); + } + + + virtual void + orbConfigs (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + ServerResourcesDef (); + }; + + struct ServerCmdlineOptions : Traversal::ServerCmdlineOptions, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ServerCmdlineOptions Type; + ServerCmdlineOptions (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + arg_pre (Type &o) + { + + this->arg_pre (const_cast <Type const &> (o)); + } + + + virtual void + arg_pre (Type const&); + + virtual void + arg_next (Type &o) + { + + this->arg_next (const_cast <Type const &> (o)); + } + + + virtual void + arg_next (Type const&); + + virtual void + arg_post (Type &o) + { + + this->arg_post (const_cast <Type const &> (o)); + } + + + virtual void + arg_post (Type const&); + + protected: + ServerCmdlineOptions (); + }; + + struct ACESvcConf : Traversal::ACESvcConf, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ACESvcConf Type; + ACESvcConf (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + uri (Type &o) + { + + this->uri (const_cast <Type const &> (o)); + } + + + virtual void + uri (Type const&); + + protected: + ACESvcConf (); + }; + + struct ORBConfigs : Traversal::ORBConfigs, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ORBConfigs Type; + ORBConfigs (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + resources (Type &o) + { + + this->resources (const_cast <Type const &> (o)); + } + + + virtual void + resources (Type const&); + + virtual void + policySet_pre (Type &o) + { + + this->policySet_pre (const_cast <Type const &> (o)); + } + + + virtual void + policySet_pre (Type const&); + + virtual void + policySet_next (Type &o) + { + + this->policySet_next (const_cast <Type const &> (o)); + } + + + virtual void + policySet_next (Type const&); + + virtual void + policySet_post (Type &o) + { + + this->policySet_post (const_cast <Type const &> (o)); + } + + + virtual void + policySet_post (Type const&); + + protected: + ORBConfigs (); + }; + + struct ORBResources : Traversal::ORBResources, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ORBResources Type; + ORBResources (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + threadpool_pre (Type &o) + { + + this->threadpool_pre (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_pre (Type const&); + + virtual void + threadpool_next (Type &o) + { + + this->threadpool_next (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_next (Type const&); + + virtual void + threadpool_post (Type &o) + { + + this->threadpool_post (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_post (Type const&); + + virtual void + threadpoolWithLanes_pre (Type &o) + { + + this->threadpoolWithLanes_pre (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolWithLanes_pre (Type const&); + + virtual void + threadpoolWithLanes_next (Type &o) + { + + this->threadpoolWithLanes_next (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolWithLanes_next (Type const&); + + virtual void + threadpoolWithLanes_post (Type &o) + { + + this->threadpoolWithLanes_post (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolWithLanes_post (Type const&); + + virtual void + connectionBands_pre (Type &o) + { + + this->connectionBands_pre (const_cast <Type const &> (o)); + } + + + virtual void + connectionBands_pre (Type const&); + + virtual void + connectionBands_next (Type &o) + { + + this->connectionBands_next (const_cast <Type const &> (o)); + } + + + virtual void + connectionBands_next (Type const&); + + virtual void + connectionBands_post (Type &o) + { + + this->connectionBands_post (const_cast <Type const &> (o)); + } + + + virtual void + connectionBands_post (Type const&); + + protected: + ORBResources (); + }; + + struct ThreadpoolDef : Traversal::ThreadpoolDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ThreadpoolDef Type; + ThreadpoolDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + stacksize (Type &o) + { + + this->stacksize (const_cast <Type const &> (o)); + } + + + virtual void + stacksize (Type const&); + + virtual void + static_threads (Type &o) + { + + this->static_threads (const_cast <Type const &> (o)); + } + + + virtual void + static_threads (Type const&); + + virtual void + dynamic_threads (Type &o) + { + + this->dynamic_threads (const_cast <Type const &> (o)); + } + + + virtual void + dynamic_threads (Type const&); + + virtual void + default_priority (Type &o) + { + + this->default_priority (const_cast <Type const &> (o)); + } + + + virtual void + default_priority (Type const&); + + virtual void + allow_request_buffering (Type &o) + { + + this->allow_request_buffering (const_cast <Type const &> (o)); + } + + + virtual void + allow_request_buffering (Type const&); + + virtual void + max_buffered_requests (Type &o) + { + + this->max_buffered_requests (const_cast <Type const &> (o)); + } + + + virtual void + max_buffered_requests (Type const&); + + virtual void + max_request_buffered_size (Type &o) + { + + this->max_request_buffered_size (const_cast <Type const &> (o)); + } + + + virtual void + max_request_buffered_size (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + ThreadpoolDef (); + }; + + struct ThreadpoolWithLanesDef : Traversal::ThreadpoolWithLanesDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ThreadpoolWithLanesDef Type; + ThreadpoolWithLanesDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + threadpoolLane_pre (Type &o) + { + + this->threadpoolLane_pre (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolLane_pre (Type const&); + + virtual void + threadpoolLane_next (Type &o) + { + + this->threadpoolLane_next (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolLane_next (Type const&); + + virtual void + threadpoolLane_post (Type &o) + { + + this->threadpoolLane_post (const_cast <Type const &> (o)); + } + + + virtual void + threadpoolLane_post (Type const&); + + virtual void + stacksize (Type &o) + { + + this->stacksize (const_cast <Type const &> (o)); + } + + + virtual void + stacksize (Type const&); + + virtual void + allow_borrowing (Type &o) + { + + this->allow_borrowing (const_cast <Type const &> (o)); + } + + + virtual void + allow_borrowing (Type const&); + + virtual void + allow_request_buffering (Type &o) + { + + this->allow_request_buffering (const_cast <Type const &> (o)); + } + + + virtual void + allow_request_buffering (Type const&); + + virtual void + max_buffered_requests (Type &o) + { + + this->max_buffered_requests (const_cast <Type const &> (o)); + } + + + virtual void + max_buffered_requests (Type const&); + + virtual void + max_request_buffered_size (Type &o) + { + + this->max_request_buffered_size (const_cast <Type const &> (o)); + } + + + virtual void + max_request_buffered_size (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + ThreadpoolWithLanesDef (); + }; + + struct ThreadpoolLaneDef : Traversal::ThreadpoolLaneDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ThreadpoolLaneDef Type; + ThreadpoolLaneDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + static_threads (Type &o) + { + + this->static_threads (const_cast <Type const &> (o)); + } + + + virtual void + static_threads (Type const&); + + virtual void + dynamic_threads (Type &o) + { + + this->dynamic_threads (const_cast <Type const &> (o)); + } + + + virtual void + dynamic_threads (Type const&); + + virtual void + priority (Type &o) + { + + this->priority (const_cast <Type const &> (o)); + } + + + virtual void + priority (Type const&); + + protected: + ThreadpoolLaneDef (); + }; + + struct ConnectionBandsDef : Traversal::ConnectionBandsDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::ConnectionBandsDef Type; + ConnectionBandsDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + band_pre (Type &o) + { + + this->band_pre (const_cast <Type const &> (o)); + } + + + virtual void + band_pre (Type const&); + + virtual void + band_next (Type &o) + { + + this->band_next (const_cast <Type const &> (o)); + } + + + virtual void + band_next (Type const&); + + virtual void + band_post (Type &o) + { + + this->band_post (const_cast <Type const &> (o)); + } + + + virtual void + band_post (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + ConnectionBandsDef (); + }; + + struct PriorityBandDef : Traversal::PriorityBandDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PriorityBandDef Type; + PriorityBandDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + low (Type &o) + { + + this->low (const_cast <Type const &> (o)); + } + + + virtual void + low (Type const&); + + virtual void + high (Type &o) + { + + this->high (const_cast <Type const &> (o)); + } + + + virtual void + high (Type const&); + + protected: + PriorityBandDef (); + }; + + struct PolicySet : Traversal::PolicySet, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PolicySet Type; + PolicySet (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + priorityModel_pre (Type &o) + { + + this->priorityModel_pre (const_cast <Type const &> (o)); + } + + + virtual void + priorityModel_pre (Type const&); + + virtual void + priorityModel_next (Type &o) + { + + this->priorityModel_next (const_cast <Type const &> (o)); + } + + + virtual void + priorityModel_next (Type const&); + + virtual void + priorityModel_post (Type &o) + { + + this->priorityModel_post (const_cast <Type const &> (o)); + } + + + virtual void + priorityModel_post (Type const&); + + virtual void + nwpriorityModel_pre (Type &o) + { + + this->nwpriorityModel_pre (const_cast <Type const &> (o)); + } + + + virtual void + nwpriorityModel_pre (Type const&); + + virtual void + nwpriorityModel_next (Type &o) + { + + this->nwpriorityModel_next (const_cast <Type const &> (o)); + } + + + virtual void + nwpriorityModel_next (Type const&); + + virtual void + nwpriorityModel_post (Type &o) + { + + this->nwpriorityModel_post (const_cast <Type const &> (o)); + } + + + virtual void + nwpriorityModel_post (Type const&); + + virtual void + cnwpriorityModel_pre (Type &o) + { + + this->cnwpriorityModel_pre (const_cast <Type const &> (o)); + } + + + virtual void + cnwpriorityModel_pre (Type const&); + + virtual void + cnwpriorityModel_next (Type &o) + { + + this->cnwpriorityModel_next (const_cast <Type const &> (o)); + } + + + virtual void + cnwpriorityModel_next (Type const&); + + virtual void + cnwpriorityModel_post (Type &o) + { + + this->cnwpriorityModel_post (const_cast <Type const &> (o)); + } + + + virtual void + cnwpriorityModel_post (Type const&); + + virtual void + threadpool_pre (Type &o) + { + + this->threadpool_pre (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_pre (Type const&); + + virtual void + threadpool_next (Type &o) + { + + this->threadpool_next (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_next (Type const&); + + virtual void + threadpool_post (Type &o) + { + + this->threadpool_post (const_cast <Type const &> (o)); + } + + + virtual void + threadpool_post (Type const&); + + virtual void + priorityBandedConnection_pre (Type &o) + { + + this->priorityBandedConnection_pre (const_cast <Type const &> (o)); + } + + + virtual void + priorityBandedConnection_pre (Type const&); + + virtual void + priorityBandedConnection_next (Type &o) + { + + this->priorityBandedConnection_next (const_cast <Type const &> (o)); + } + + + virtual void + priorityBandedConnection_next (Type const&); + + virtual void + priorityBandedConnection_post (Type &o) + { + + this->priorityBandedConnection_post (const_cast <Type const &> (o)); + } + + + virtual void + priorityBandedConnection_post (Type const&); + + virtual void + id (Type &o) + { + + this->id (const_cast <Type const &> (o)); + } + + + virtual void + id (Type const&); + + protected: + PolicySet (); + }; + + struct PriorityModel : Traversal::PriorityModel, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + PriorityModel (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + PriorityModel (); + }; + + struct NWPriorityModel : Traversal::NWPriorityModel, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + NWPriorityModel (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + this->traverse (const_cast <Type const &> (o)); + } + + virtual void + traverse (Type const&); + + protected: + NWPriorityModel (); + }; + + struct PriorityModelPolicyDef : Traversal::PriorityModelPolicyDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::PriorityModelPolicyDef Type; + PriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + priority_model (Type &o) + { + + this->priority_model (const_cast <Type const &> (o)); + } + + + virtual void + priority_model (Type const&); + + virtual void + server_priority (Type &o) + { + + this->server_priority (const_cast <Type const &> (o)); + } + + + virtual void + server_priority (Type const&); + + protected: + PriorityModelPolicyDef (); + }; + + struct NWPriorityModelPolicyDef : Traversal::NWPriorityModelPolicyDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::NWPriorityModelPolicyDef Type; + NWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + nw_priority_model (Type &o) + { + + this->nw_priority_model (const_cast <Type const &> (o)); + } + + + virtual void + nw_priority_model (Type const&); + + virtual void + request_dscp (Type &o) + { + + this->request_dscp (const_cast <Type const &> (o)); + } + + + virtual void + request_dscp (Type const&); + + virtual void + reply_dscp (Type &o) + { + + this->reply_dscp (const_cast <Type const &> (o)); + } + + + virtual void + reply_dscp (Type const&); + + protected: + NWPriorityModelPolicyDef (); + }; + + struct CNWPriorityModelPolicyDef : Traversal::CNWPriorityModelPolicyDef, + virtual ::XSCRT::Writer< ACE_TCHAR > + { + typedef ::CIAO::Config_Handlers::CNWPriorityModelPolicyDef Type; + CNWPriorityModelPolicyDef (::XSCRT::XML::Element< ACE_TCHAR >&); + + virtual void + traverse (Type &o) + { + + this->traverse (const_cast <Type const &> (o)); + } + + + virtual void + traverse (Type const&); + + virtual void + request_dscp (Type &o) + { + + this->request_dscp (const_cast <Type const &> (o)); + } + + + virtual void + request_dscp (Type const&); + + virtual void + reply_dscp (Type &o) + { + + this->reply_dscp (const_cast <Type const &> (o)); + } + + + virtual void + reply_dscp (Type const&); + + protected: + CNWPriorityModelPolicyDef (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + RT_CCM_Handlers_Export + void + ServerResources (::CIAO::Config_Handlers::ServerResourcesDef const&, xercesc::DOMDocument*); + } +} + +#endif // CIAOSERVER_RESOURCES_HPP diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.cpp new file mode 100644 index 00000000000..39e2d72bbbf --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.cpp @@ -0,0 +1,44 @@ +// $Id$Exp + +#include "CLA_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool CLA_Handler::commandline_arguments (const ServerResourcesDef &src, + ::CIAO::DAnCE::CommandlineArgs &dest) + { + ServerCmdlineOptions sco = src.cmdline(); + + for(ServerCmdlineOptions::arg_iterator loc = sco.begin_arg(); + loc != sco.end_arg(); + loc++) + { + CORBA::ULong len = dest.length(); + + dest.length(len+1); + + dest[len] = CORBA::string_dup (loc->c_str ()); + } + + return true; + } + + ServerCmdlineOptions + CLA_Handler::commandline_argument (const CIAO::DAnCE::CommandlineArgs &src) + { + ServerCmdlineOptions co; + + for (CORBA::ULong i = 0; + i < src.length (); + ++i) + { + co.add_arg (src[i].in ()); + } + + return co; + } + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.h new file mode 100644 index 00000000000..e8676b54772 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CLA_Handler.h @@ -0,0 +1,52 @@ +//======================================================= +/* @file CLA_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ +//======================================================= + +#ifndef CIAO_CONFIG_HANDLERS_CLA_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CLA_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + + class ServerResourcesDef; + class ServerCmdlineOptions; + + /* + * class CLA_Handler + * This is a brief Handler class for <CommandlineArg> + */ + + class RT_CCM_Handlers_Export CLA_Handler + { + public: + static bool + commandline_arguments ( + const ServerResourcesDef &src, + ::CIAO::DAnCE::CommandlineArgs &dest); + + static ServerCmdlineOptions + commandline_argument (const ::CIAO::DAnCE::CommandlineArgs &src); + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CLA_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.cpp new file mode 100755 index 00000000000..acc74ca8c99 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.cpp @@ -0,0 +1,93 @@ +// $Id$ + +#include "CNPM_Handler.h" +#include "CIAOServerResources.hpp" +#include "ace/Auto_Ptr.h" + +#define IPDSFIELD_DSCP_DEFAULT 0x00 +#define IPDSFIELD_DSCP_CS1 0x08 +#define IPDSFIELD_DSCP_CS2 0x10 +#define IPDSFIELD_DSCP_CS3 0x18 +#define IPDSFIELD_DSCP_CS4 0x20 +#define IPDSFIELD_DSCP_CS5 0x28 +#define IPDSFIELD_DSCP_CS6 0x30 +#define IPDSFIELD_DSCP_CS7 0x38 +#define IPDSFIELD_DSCP_AF11 0x0A +#define IPDSFIELD_DSCP_AF12 0x0C +#define IPDSFIELD_DSCP_AF13 0x0E +#define IPDSFIELD_DSCP_AF21 0x12 +#define IPDSFIELD_DSCP_AF22 0x14 +#define IPDSFIELD_DSCP_AF23 0x16 +#define IPDSFIELD_DSCP_AF31 0x1A +#define IPDSFIELD_DSCP_AF32 0x1C +#define IPDSFIELD_DSCP_AF33 0x1E +#define IPDSFIELD_DSCP_AF41 0x22 +#define IPDSFIELD_DSCP_AF42 0x24 +#define IPDSFIELD_DSCP_AF43 0x26 +#define IPDSFIELD_ECT_MASK 0x02 +#define IPDSFIELD_CE_MASK 0x01 +#define IPDSFIELD_DSCP_EF 0x2E + +static int const dscp[] = +{ + IPDSFIELD_DSCP_DEFAULT , + IPDSFIELD_DSCP_CS1 , + IPDSFIELD_DSCP_CS2 , + IPDSFIELD_DSCP_CS3 , + IPDSFIELD_DSCP_CS4 , + IPDSFIELD_DSCP_CS5 , + IPDSFIELD_DSCP_CS6 , + IPDSFIELD_DSCP_CS7 , + IPDSFIELD_DSCP_AF11 , + IPDSFIELD_DSCP_AF12 , + IPDSFIELD_DSCP_AF13 , + IPDSFIELD_DSCP_AF21 , + IPDSFIELD_DSCP_AF22 , + IPDSFIELD_DSCP_AF23 , + IPDSFIELD_DSCP_AF31 , + IPDSFIELD_DSCP_AF32 , + IPDSFIELD_DSCP_AF33 , + IPDSFIELD_DSCP_AF41 , + IPDSFIELD_DSCP_AF42 , + IPDSFIELD_DSCP_AF43 , + IPDSFIELD_DSCP_EF +}; + + +namespace CIAO +{ + namespace Config_Handlers + { + + bool + CNPM_Handler::cnw_priority_pd (const CNWPriorityModelPolicyDef &src, + ::CIAO::DAnCE::CNWPriorityModelPolicyDef &dest) + { + int request_array_slot = 7; + long d = dscp[request_array_slot]; + + int a = static_cast <ACE_INT16> (d); + long b = static_cast <ACE_INT32> (a); + long c = static_cast <ACE_INT32> (a); + + ACE_DEBUG ((LM_DEBUG, "numbers are %d %X %X\n", a, b, c)); + + dest.request_dscp = + static_cast <ACE_INT32> (src.request_dscp ()); + dest.reply_dscp = + static_cast <ACE_INT32> (src.reply_dscp ()); + + return true; + } + + CNWPriorityModelPolicyDef + CNPM_Handler::cnw_priority_pd ( + const ::CIAO::DAnCE::CNWPriorityModelPolicyDef&) + { + auto_ptr <CNWPriorityModelPolicyDef> pmd; + pmd.reset (new CNWPriorityModelPolicyDef (0, 0)); + return *pmd; + } + } +} + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.h new file mode 100755 index 00000000000..39da8b2fae4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/CNPM_Handler.h @@ -0,0 +1,45 @@ +/** + * @file CNPM_Handler.h + * + * $Id$ + */ + + +#ifndef CIAO_CONFIG_HANDLERS_CNPM_HANDLER_H +#define CIAO_CONFIG_HANDLERS_CNPM_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class CNWPriorityModelPolicyDef; + + /** + * @class CNPM_Handler + * @brief Handler class for client NetworkPriorityModelPolicyDefs + */ + + class RT_CCM_Handlers_Export CNPM_Handler + { + public: + static bool cnw_priority_pd (const CNWPriorityModelPolicyDef &src, + ::CIAO::DAnCE::CNWPriorityModelPolicyDef &dest); + + static CNWPriorityModelPolicyDef cnw_priority_pd ( + const ::CIAO::DAnCE::CNWPriorityModelPolicyDef &src); + }; + } + +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_CNPM_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.cpp new file mode 100755 index 00000000000..d530b2169e2 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.cpp @@ -0,0 +1,131 @@ +// $Id$ + +#include "NPM_Handler.h" +#include "CIAOServerResources.hpp" +#include "ace/Auto_Ptr.h" + +#define IPDSFIELD_DSCP_DEFAULT 0x00 +#define IPDSFIELD_DSCP_CS1 0x08 +#define IPDSFIELD_DSCP_CS2 0x10 +#define IPDSFIELD_DSCP_CS3 0x18 +#define IPDSFIELD_DSCP_CS4 0x20 +#define IPDSFIELD_DSCP_CS5 0x28 +#define IPDSFIELD_DSCP_CS6 0x30 +#define IPDSFIELD_DSCP_CS7 0x38 +#define IPDSFIELD_DSCP_AF11 0x0A +#define IPDSFIELD_DSCP_AF12 0x0C +#define IPDSFIELD_DSCP_AF13 0x0E +#define IPDSFIELD_DSCP_AF21 0x12 +#define IPDSFIELD_DSCP_AF22 0x14 +#define IPDSFIELD_DSCP_AF23 0x16 +#define IPDSFIELD_DSCP_AF31 0x1A +#define IPDSFIELD_DSCP_AF32 0x1C +#define IPDSFIELD_DSCP_AF33 0x1E +#define IPDSFIELD_DSCP_AF41 0x22 +#define IPDSFIELD_DSCP_AF42 0x24 +#define IPDSFIELD_DSCP_AF43 0x26 +#define IPDSFIELD_ECT_MASK 0x02 +#define IPDSFIELD_CE_MASK 0x01 +#define IPDSFIELD_DSCP_EF 0x2E + +static int const dscp[] = +{ + IPDSFIELD_DSCP_DEFAULT , + IPDSFIELD_DSCP_CS1 , + IPDSFIELD_DSCP_CS2 , + IPDSFIELD_DSCP_CS3 , + IPDSFIELD_DSCP_CS4 , + IPDSFIELD_DSCP_CS5 , + IPDSFIELD_DSCP_CS6 , + IPDSFIELD_DSCP_CS7 , + IPDSFIELD_DSCP_AF11 , + IPDSFIELD_DSCP_AF12 , + IPDSFIELD_DSCP_AF13 , + IPDSFIELD_DSCP_AF21 , + IPDSFIELD_DSCP_AF22 , + IPDSFIELD_DSCP_AF23 , + IPDSFIELD_DSCP_AF31 , + IPDSFIELD_DSCP_AF32 , + IPDSFIELD_DSCP_AF33 , + IPDSFIELD_DSCP_AF41 , + IPDSFIELD_DSCP_AF42 , + IPDSFIELD_DSCP_AF43 , + IPDSFIELD_DSCP_EF +}; + + +namespace CIAO +{ + namespace Config_Handlers + { + + bool + NPM_Handler::nw_priority_model_pd (const NWPriorityModelPolicyDef &src, + ::CIAO::DAnCE::NWPriorityModelPolicyDef &dest) + { + switch (src.nw_priority_model ().integral ()) + { + case NWPriorityModel::SERVER_DECLARED_NWPRIORITY_l: + dest.nw_priority_model = ::CIAO::DAnCE::SERVER_DECLARED_NWPRIORITY; + break; + + case NWPriorityModel::CLIENT_PROPAGATED_NWPRIORITY_l: + dest.nw_priority_model = ::CIAO::DAnCE::CLIENT_PROPAGATED_NWPRIORITY; + break; + + default: + ACE_ERROR ((LM_ERROR, + "Unknown priority model passed to priority_model_pd\n")); + return false; + } + + int request_array_slot = 7; + long d = dscp[request_array_slot]; + + int a = static_cast <ACE_INT16> (d); + long b = static_cast <ACE_INT32> (a); + long c = static_cast <ACE_INT32> (a); + + ACE_DEBUG ((LM_DEBUG, "numbers are %d %X %X\n", a, b, c)); + + dest.request_dscp = + static_cast <ACE_INT32> (src.request_dscp ()); + dest.reply_dscp = + static_cast <ACE_INT32> (src.reply_dscp ()); + + return true; + } + + + NWPriorityModelPolicyDef + NPM_Handler::nw_priority_model_pd ( + const ::CIAO::DAnCE::NWPriorityModelPolicyDef &src) + { + auto_ptr <NWPriorityModelPolicyDef> pmd; + + switch (src.nw_priority_model) + { + case ::CIAO::DAnCE::CLIENT_PROPAGATED_NWPRIORITY: + pmd.reset (new NWPriorityModelPolicyDef +(NWPriorityModel::CLIENT_PROPAGATED_NWPRIORITY, 0, 0)); + break; + + case ::CIAO::DAnCE::SERVER_DECLARED_NWPRIORITY: + pmd.reset (new NWPriorityModelPolicyDef +(NWPriorityModel::SERVER_DECLARED_NWPRIORITY, 0, 0)); + break; + + default: + ACE_ERROR ((LM_ERROR, + "Invalid priority model given to nw_priority_model_pd\n")); + throw 1; + } + + return *pmd; + } + + + } + +} + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.h new file mode 100755 index 00000000000..bde507ba189 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/NPM_Handler.h @@ -0,0 +1,45 @@ +/** + * @file NPM_Handler.h + * + * $Id$ + */ + + +#ifndef CIAO_CONFIG_HANDLERS_NPM_HANDLER_H +#define CIAO_CONFIG_HANDLERS_NPM_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class NWPriorityModelPolicyDef; + + /** + * @class NPM_Handler + * @brief Handler class for NetworkPriorityModelPolicyDefs + */ + + class RT_CCM_Handlers_Export NPM_Handler + { + public: + static bool nw_priority_model_pd (const NWPriorityModelPolicyDef &src, + ::CIAO::DAnCE::NWPriorityModelPolicyDef &dest); + + static NWPriorityModelPolicyDef nw_priority_model_pd ( + const ::CIAO::DAnCE::NWPriorityModelPolicyDef &src); + }; + } + +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_NPM_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.cpp new file mode 100644 index 00000000000..41c45ee7c96 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.cpp @@ -0,0 +1,51 @@ +// $Id$ + +#include "OC_Handler.h" +#include "OR_Handler.h" +#include "PS_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + + bool OC_Handler::orb_config ( + const ORBConfigs &src, + ::CIAO::DAnCE::ORBConfigs &dest) + { + if (src.resources_p ()) + OR_Handler::orb_resources (src.resources (), dest.orb_resources); + + CORBA::ULong pos (dest.policy_set.length ()); + + dest.policy_set.length (pos + src.count_policySet ()); + + for (ORBConfigs::policySet_const_iterator i = src.begin_policySet (); + i != src.end_policySet (); + ++i) + { + PS_Handler::policy_set (*i, dest.policy_set[pos++]); + } + + return true; + } + + + ORBConfigs OC_Handler::orb_config ( + const ::CIAO::DAnCE::ORBConfigs &src) + { + ORBConfigs oc; + + oc.resources(OR_Handler::orb_resources (src.orb_resources)); + + size_t len = src.policy_set.length(); + for(size_t i = 0; i < len; i++) + { + oc.add_policySet (PS_Handler::policy_set (src.policy_set [i])); + } + + return oc; + } + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.h new file mode 100644 index 00000000000..abcd2c0a3c5 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/OC_Handler.h @@ -0,0 +1,50 @@ +//============================================ +/* + * @file OC_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu> + * @author Will Otte <wotte@dre.vanderbilt.edu> + + * $Id$ + */ +//============================================ + +#ifndef CIAO_CONFIG_HANDLERS_OC_HANDLER_H +#define CIAO_CONFIG_HANDLERS_OC_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class ORBConfigs; + + /* + * @class OC_Handler + * + * @brief Handler class for <ORBConfigs> + */ + + class RT_CCM_Handlers_Export OC_Handler + { + public: + static bool orb_config (const ORBConfigs &src, + ::CIAO::DAnCE::ORBConfigs &dest); + + static ORBConfigs orb_config (const ::CIAO::DAnCE::ORBConfigs &src); + + }; + } +} + +#include /**/ "ace/post.h" +#endif /* OC_HANDLER_H */ + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.cpp new file mode 100644 index 00000000000..c4719fd5621 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.cpp @@ -0,0 +1,91 @@ +// $Id$ + +#include "OR_Handler.h" +#include "TP_Handler.h" +#include "TPL_Handler.h" +#include "CB_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool OR_Handler::orb_resources (const ORBResources &src, + ::CIAO::DAnCE::ORBResources &dest) + { + // We know that there should be only one. + dest.length (1); + + // Set the length of the threadpools + CORBA::ULong pos (dest[0].threadpool_list.length ()); + dest[0].threadpool_list.length (pos + src.count_threadpool ()); + + for (ORBResources::threadpool_const_iterator i = src.begin_threadpool (); + i != src.end_threadpool (); + ++i) + { + TP_Handler::thread_pool (*i, + dest[0].threadpool_list[pos++]); + } + + pos = dest[0].threadpool_with_lanes_list.length (); + dest[0].threadpool_with_lanes_list.length (pos + src.count_threadpoolWithLanes ()); + + for (ORBResources::threadpoolWithLanes_const_iterator j = src.begin_threadpoolWithLanes(); + j != src.end_threadpoolWithLanes(); + j++) + { + TPL_Handler::threadpool_with_lanes (*j, + dest[0].threadpool_with_lanes_list [pos++]); + } + + pos = dest[0].connection_bands_list.length (); + dest[0].connection_bands_list.length (pos + src.count_connectionBands ()); + + for (ORBResources::connectionBands_const_iterator k = src.begin_connectionBands(); + k != src.end_connectionBands(); + k++) + { + CB_Handler::connection_band (*k, + dest[0].connection_bands_list[pos++]); + } + return true; + } + + ORBResources OR_Handler::orb_resources (const ::CIAO::DAnCE::ORBResources &src) + throw (OR_Handler::No_Resource) + { + if (src.length () == 0 || + src[0].threadpool_list.length () == 0 || + src[0].threadpool_with_lanes_list.length () == 0 || + src[0].connection_bands_list.length () == 0) + { + throw No_Resource (); + } + + size_t len; //For checking the length of sequences + + ORBResources ores; + + len = src[0].threadpool_list.length(); + for(size_t i = 0; i < len; ++i) + { + ores.add_threadpool (TP_Handler::thread_pool (src[0].threadpool_list[i])); + } + + len = src[0].threadpool_with_lanes_list.length(); + for(size_t j = 0; j < len; ++j) + { + ores.add_threadpoolWithLanes(TPL_Handler::threadpool_with_lanes (src[0].threadpool_with_lanes_list[j])); + } + + len = src[0].connection_bands_list.length(); + for(size_t k = 0; k < len; k++) + { + ores.add_connectionBands (CB_Handler::connection_band (src[0].connection_bands_list[k])); + } + + return ores; + } + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.h new file mode 100644 index 00000000000..5209aea7da4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/OR_Handler.h @@ -0,0 +1,54 @@ +//========================================================= +/* + * @file OR_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ +//========================================================= + +#ifndef CIAO_CONFIG_HANDLERS_OR_HANDLER_H +#define CIAO_CONFIG_HANDLERS_OR_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" +#include "RT_CCM_Handlers_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class ORBResources; + + /* Class description + * @class OR_Handler + * @function A brief Handler class for the <ORBResource> member + */ + + class RT_CCM_Handlers_Export OR_Handler + { + public: + + static bool orb_resources (const ORBResources &src, + ::CIAO::DAnCE::ORBResources &dest); + + class No_Resource {}; + + static ORBResources orb_resources (const ::CIAO::DAnCE::ORBResources &src) + throw (No_Resource); + + + }; + } +} + +#include /**/ "ace/post.h" + +#endif /* CIAO_CONFIG_HANDLERS_OR_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.cpp new file mode 100644 index 00000000000..088a426505c --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.cpp @@ -0,0 +1,73 @@ +// $Id$ + +#include "PM_Handler.h" +#include "CIAOServerResources.hpp" +#include "ace/Auto_Ptr.h" + +namespace CIAO +{ + namespace Config_Handlers + { + + bool + PM_Handler::priority_model_pd (const PriorityModelPolicyDef &src, + ::CIAO::DAnCE::PriorityModelPolicyDef &dest) + { + switch (src.priority_model ().integral ()) + { + case PriorityModel::SERVER_DECLARED_l: + dest.priority_model = ::CIAO::DAnCE::SERVER_DECLARED; + break; + + case PriorityModel::CLIENT_PROPAGATED_l: + dest.priority_model = ::CIAO::DAnCE::CLIENT_PROPAGATED; + break; + + default: + ACE_ERROR ((LM_ERROR, + "Unknown priority model passed to priority_model_pd\n")); + return false; + } + + if (src.server_priority_p ()) + dest.server_priority = static_cast < ACE_INT32 > (src.server_priority ()); + else + dest.server_priority = 0; + + return true; + } + + + PriorityModelPolicyDef + PM_Handler::priority_model_pd (const ::CIAO::DAnCE::PriorityModelPolicyDef &src) + { + auto_ptr <PriorityModelPolicyDef> pmd; + + switch (src.priority_model) + { + case ::CIAO::DAnCE::CLIENT_PROPAGATED: + pmd.reset (new PriorityModelPolicyDef (PriorityModel::CLIENT_PROPAGATED)); + break; + + case ::CIAO::DAnCE::SERVER_DECLARED: + pmd.reset (new PriorityModelPolicyDef (PriorityModel::SERVER_DECLARED)); + break; + + default: + ACE_ERROR ((LM_ERROR, + "Invalid priority model given to priority_model_pd\n")); + throw 1; + } + + pmd->server_priority (XMLSchema::int_ (src.server_priority)); + + return *pmd; + } + + + } + + + +} + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.h new file mode 100644 index 00000000000..2063eec449a --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/PM_Handler.h @@ -0,0 +1,45 @@ +/** + * @file PM_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + + +#ifndef CIAO_CONFIG_HANDLERS_PM_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PM_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class PriorityModelPolicyDef; + + /** + * @class PS_Handler + * @brief Handler class for PriorityModelPolicyDefs + */ + + class RT_CCM_Handlers_Export PM_Handler + { + public: + static bool priority_model_pd (const PriorityModelPolicyDef &src, + ::CIAO::DAnCE::PriorityModelPolicyDef &dest); + + static PriorityModelPolicyDef priority_model_pd (const ::CIAO::DAnCE::PriorityModelPolicyDef &src); + }; + } + +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFI_HANDLERS_PM_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.cpp new file mode 100644 index 00000000000..16a2f71f40a --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.cpp @@ -0,0 +1,152 @@ +// $Id$ + +#include "PS_Handler.h" +#include "PM_Handler.h" +#include "NPM_Handler.h" +#include "CNPM_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool + PS_Handler::policy_set (const PolicySet &src, + ::CIAO::DAnCE::PolicySet &dest) + { + if (src.id_p ()) + dest.Id = CORBA::string_dup (src.id ().c_str ()); + + // Make room for all of the policies + CORBA::ULong len (dest.policies.length ()); + dest.policies.length (len + + src.count_priorityModel () + + src.count_nwpriorityModel () + + src.count_cnwpriorityModel () + + src.count_threadpool () + + src.count_priorityBandedConnection ()); + + for (PolicySet::priorityModel_const_iterator i = src.begin_priorityModel (); + i != src.end_priorityModel (); + ++i) + { + ::CIAO::DAnCE::PriorityModelPolicyDef pmd; + + PM_Handler::priority_model_pd (*i, pmd); + + dest.policies[len++].PriorityModelDef (pmd); + } + + for (PolicySet::nwpriorityModel_const_iterator i = + src.begin_nwpriorityModel (); + i != src.end_nwpriorityModel (); + ++i) + { + ::CIAO::DAnCE::NWPriorityModelPolicyDef npmd; + + NPM_Handler::nw_priority_model_pd (*i, npmd); + + dest.policies[len++].NWPriorityModelDef (npmd); + } + + for (PolicySet::cnwpriorityModel_const_iterator i = + src.begin_cnwpriorityModel (); + i != src.end_cnwpriorityModel (); + ++i) + { + ::CIAO::DAnCE::CNWPriorityModelPolicyDef cnpmd; + + CNPM_Handler::cnw_priority_pd (*i, cnpmd); + + dest.policies[len++].CNWPriorityModelDef (cnpmd); + } + + for (PolicySet::threadpool_const_iterator i = src.begin_threadpool (); + i != src.end_threadpool (); + ++i) + { + ::CIAO::DAnCE::ThreadpoolPolicyDef tpd; + + tpd.Id = CORBA::string_dup (i->id ().c_str ()); + + dest.policies[len++].ThreadpoolDef (tpd); + } + + + for (PolicySet::priorityBandedConnection_const_iterator i = src.begin_priorityBandedConnection (); + i != src.end_priorityBandedConnection (); + ++i) + { + ::CIAO::DAnCE::PriorityBandedConnectionPolicyDef pbc; + + pbc.Id = CORBA::string_dup (i->id ().c_str ()); + + dest.policies[len++].PriorityBandedConnectionDef (pbc); + } + return true; + } + + PolicySet + PS_Handler::policy_set (const ::CIAO::DAnCE::PolicySet &src) + { + PolicySet ps; + + if (src.Id.in ()) + ps.id (src.Id.in ()); + + for (CORBA::ULong i = 0; + i < src.policies.length (); + ++i) + { + ACE_DEBUG ((LM_ERROR, + "Attempting switch for i = %d\n", + i)); + + switch (src.policies[i]._d ()) + { + case ::CIAO::DAnCE::PRIORITY_MODEL_POLICY_TYPE: + ps.add_priorityModel ( + PM_Handler::priority_model_pd ( + src.policies[i].PriorityModelDef ())); + break; + + case ::CIAO::DAnCE::NETWORK_PRIORITY_TYPE: + ps.add_nwpriorityModel ( + NPM_Handler::nw_priority_model_pd ( + src.policies[i].NWPriorityModelDef ())); + break; + + case ::CIAO::DAnCE::CLIENT_NETWORK_PRIORITY_TYPE: + ps.add_cnwpriorityModel ( + CNPM_Handler::cnw_priority_pd ( + src.policies[i].CNWPriorityModelDef ())); + break; + + case ::CIAO::DAnCE::THREADPOOL_POLICY_TYPE: + ps.add_threadpool (src.policies[i].ThreadpoolDef ().Id.in ()); + break; + + case ::CIAO::DAnCE::PRIORITY_BANDED_CONNECTION_POLICY_TYPE: + ps.add_priorityBandedConnection ( + src.policies[i].PriorityBandedConnectionDef ().Id.in ()); + break; + + case 0: + ACE_ERROR ((LM_ERROR, + "Skipping invalid policy.\n")); + break; + + default: + ACE_ERROR ((LM_ERROR, + "Bad policy stored in policy_set: %i\n", + src.policies[i]._d ())); + throw 1; + } + } + + return ps; + } + + } + +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.h new file mode 100644 index 00000000000..5c3cb4ae996 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/PS_Handler.h @@ -0,0 +1,45 @@ +/** + * @file PS_Handler.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ + + +#ifndef CIAO_CONFIG_HANDLERS_PS_HANDLER_H +#define CIAO_CONFIG_HANDLERS_PS_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class PolicySet; + + /** + * @class PS_Handler + * @brief Handler class for PolicySets + */ + + class RT_CCM_Handlers_Export PS_Handler + { + public: + static bool policy_set (const PolicySet &src, + ::CIAO::DAnCE::PolicySet &dest); + + static PolicySet policy_set (const ::CIAO::DAnCE::PolicySet &src); + }; + + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFI_HANDLERS_PS_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/RT-CCM-Handlers.mpc b/CIAO/tools/Config_Handlers/RT-CCM/RT-CCM-Handlers.mpc new file mode 100644 index 00000000000..90e67000c6a --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/RT-CCM-Handlers.mpc @@ -0,0 +1,61 @@ +//$Id$ + +project (RT_CCM_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 RT_CCM_Handlers_Export + xscflags += --cxx-namespace-regex <%quote%>%.*vanderbilt.*%CIAO/Config_Handlers%<%quote%> + xscflags += --cxx-export-header RT_CCM_Handlers_Export.h + xscflags += --search-path "$(CIAO_ROOT)/docs/schema" + + custom_only = 1 + + XSC_Files { + gendir = . + $(CIAO_ROOT)/docs/schema/CIAOServerResources.xsd + } +} + +project (RT_CCM_Config_Handlers) : acelib, ciao_deployment_stub, ciao_config_handlers_base { + sharedname = RT_CCM_Config_Handlers + dynamicflags = RT_CCM_HANDLERS_BUILD_DLL + macros += XML_USE_PTHREADS + includes += $(CIAO_ROOT)/tools/Config_Handlers + includes += $(CIAO_ROOT)/ciao + + after += RT_CCM_XML_Generation + + Source_Files { + CIAOServerResources.cpp + CLA_Handler.cpp + OC_Handler.cpp + OR_Handler.cpp + PM_Handler.cpp + PS_Handler.cpp + CNPM_Handler.cpp + NPM_Handler.cpp + SRD_Handler.cpp + TP_Handler.cpp + TPL_Handler.cpp + CB_Handler.cpp + } + + Header_Files { + } +} + +//project (RT-CCM_Config_Handlers_Tests) : ciao_component_dnc, xerces { +// requires += dummy_label +// exename = rt-ccm-test +// after += RT-CCM-Handlers +// dynamicflags = CONFIG_HANDLERS_BUILD_DLL +// macros += XML_USE_PTHREADS +// includes += $(CIAO_ROOT)/tools/Config_Handlers +// libs += CIAO_DnC_Server TAO_IFR_Client RT_CCM_Config_Handlers CIAO_XML_Utils + +// Source_Files { +// test.cpp +// } +//} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/RT_CCM_Handlers_Export.h b/CIAO/tools/Config_Handlers/RT-CCM/RT_CCM_Handlers_Export.h new file mode 100644 index 00000000000..fdba117ae61 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/RT_CCM_Handlers_Export.h @@ -0,0 +1,54 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl RT_CCM_Handlers +// ------------------------------ +#ifndef RT_CCM_HANDLERS_EXPORT_H +#define RT_CCM_HANDLERS_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (RT_CCM_HANDLERS_HAS_DLL) +# define RT_CCM_HANDLERS_HAS_DLL 1 +#endif /* ! RT_CCM_HANDLERS_HAS_DLL */ + +#if defined (RT_CCM_HANDLERS_HAS_DLL) && (RT_CCM_HANDLERS_HAS_DLL == 1) +# if defined (RT_CCM_HANDLERS_BUILD_DLL) +# define RT_CCM_Handlers_Export ACE_Proper_Export_Flag +# define RT_CCM_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define RT_CCM_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* RT_CCM_HANDLERS_BUILD_DLL */ +# define RT_CCM_Handlers_Export ACE_Proper_Import_Flag +# define RT_CCM_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define RT_CCM_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* RT_CCM_HANDLERS_BUILD_DLL */ +#else /* RT_CCM_HANDLERS_HAS_DLL == 1 */ +# define RT_CCM_Handlers_Export +# define RT_CCM_HANDLERS_SINGLETON_DECLARATION(T) +# define RT_CCM_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* RT_CCM_HANDLERS_HAS_DLL == 1 */ + +// Set RT_CCM_HANDLERS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (RT_CCM_HANDLERS_NTRACE) +# if (ACE_NTRACE == 1) +# define RT_CCM_HANDLERS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define RT_CCM_HANDLERS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !RT_CCM_HANDLERS_NTRACE */ + +#if (RT_CCM_HANDLERS_NTRACE == 1) +# define RT_CCM_HANDLERS_TRACE(X) +#else /* (RT_CCM_HANDLERS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define RT_CCM_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (RT_CCM_HANDLERS_NTRACE == 1) */ + +#endif /* RT_CCM_HANDLERS_EXPORT_H */ + +// End of auto generated file. diff --git a/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.cpp new file mode 100644 index 00000000000..000768090f5 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.cpp @@ -0,0 +1,162 @@ +// $Id$ +#include "Utils/XML_Helper.h" +#include "SRD_Handler.h" +#include "CIAOServerResources.hpp" +#include "CLA_Handler.h" +#include "OC_Handler.h" + +namespace CIAO +{ + namespace Config_Handlers + { + SRD_Handler::SRD_Handler (const ACE_TCHAR *file) : + idl_srd_(0), + srd_ (0), + retval_ (false) + { + XML_Helper helper; + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + helper.create_dom (file); + + if (!dom) + throw SRD_Handler::NoSRD (); + + this->srd_.reset (new ServerResourcesDef + (ServerResources (dom))); + + if (!this->build_srd ()) + throw NoSRD (); + } + + SRD_Handler::SRD_Handler (ServerResourcesDef *srd): + idl_srd_(0), + srd_(srd), + retval_(false) + { + if(!this->build_srd()) + throw NoSRD (); + } + + SRD_Handler::SRD_Handler (::CIAO::DAnCE::ServerResource *srd): + idl_srd_(srd), + srd_(0), + retval_(false) + { + if(!this->build_xsc()) + throw NoSRD (); + } + + SRD_Handler::~SRD_Handler (void) + { + } + + bool + SRD_Handler::build_srd () + { + this->idl_srd_.reset ( new ::CIAO::DAnCE::ServerResource ); + + if(this->srd_->cmdline_p()) + { + this->retval_ = CLA_Handler::commandline_arguments(*this->srd_, + this->idl_srd_->args); + } + + if(this->srd_->svcconf_p()) + { + this->idl_srd_->svcconf = (srd_->svcconf().uri().c_str()); + } + + this->retval_ = OC_Handler::orb_config (this->srd_->orbConfigs (), + this->idl_srd_->orb_config); + + if (this->srd_->id_p ()) + { + this->idl_srd_->Id = srd_->id ().c_str (); + } + + return this->retval_; + } + + bool + SRD_Handler::build_xsc () + { + size_t len; //For checking the length of src data members + + // Load the ORBConfigs and create the XSC structure for SRD + this->srd_.reset (new ServerResourcesDef (OC_Handler::orb_config (this->idl_srd_->orb_config))); + + + //Note: Why did we make the CmdlineOptions a separate class instead of a + // vector of strings??? + + ServerCmdlineOptions sco; + + //First load up the CmdlineArgs if they exist + len = idl_srd_->args.length(); + for(size_t i = 0; i < len; i++) + { + XMLSchema::string < ACE_TCHAR > curr ((this->idl_srd_->args[i])); + sco.add_arg(curr); + } + this->srd_->cmdline (sco); + + //Then a similar thing for the svcconf + XMLSchema::string < ACE_TCHAR > curr (this->idl_srd_->svcconf); + ACESvcConf asc; + asc.uri(curr); + this->srd_->svcconf (asc); + + XMLSchema::string < ACE_TCHAR > id (this->idl_srd_->Id.in ()); + this->srd_->id (id); + + return true; + } + + ::CIAO::DAnCE::ServerResource const * + SRD_Handler::srd_idl () const + throw (SRD_Handler::NoSRD) + { + if(!this->idl_srd_.get()) + throw NoSRD (); + + //else + return this->idl_srd_.get(); + } + + ::CIAO::DAnCE::ServerResource * + SRD_Handler::srd_idl () + throw (SRD_Handler::NoSRD) + { + if(!this->idl_srd_.get()) + throw NoSRD(); + + //else + return this->idl_srd_.release(); + } + + ServerResourcesDef const * + SRD_Handler::srd_xsc () const + throw (SRD_Handler::NoSRD) + { + if(!this->srd_.get()) + throw NoSRD (); + + //else + return this->srd_.get(); + } + + ServerResourcesDef * + SRD_Handler::srd_xsc () + throw (SRD_Handler::NoSRD) + { + if(!this->srd_.get()) + throw NoSRD (); + + //else + return this->srd_.release(); + } + } +} + + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.h new file mode 100644 index 00000000000..e0347fcbb8a --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/SRD_Handler.h @@ -0,0 +1,77 @@ +//====================================== +/** + * @file SRD_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu> + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ +//====================================== + +#ifndef CIAO_CONFIG_HANDLERS_SRD_HANDLER_H +#define CIAO_CONFIG_HANDLERS_SRD_HANDLER_H +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" +#include "ace/Auto_Ptr.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class ServerResourcesDef; + + /* + * @class SRD_Handler + * + * @brief Handler class for <ServerResourcesDef + */ + + class RT_CCM_Handlers_Export SRD_Handler + { + public: + class NoSRD {}; + + SRD_Handler (const ACE_TCHAR *file); + + SRD_Handler(ServerResourcesDef *srd); + + SRD_Handler(::CIAO::DAnCE::ServerResource *srd); + + ~SRD_Handler (void); + + ::CIAO::DAnCE::ServerResource const *srd_idl (void) const + throw (NoSRD); + + ::CIAO::DAnCE::ServerResource *srd_idl (void) + throw (NoSRD); + + ServerResourcesDef const *srd_xsc (void) const + throw (NoSRD); + + ServerResourcesDef *srd_xsc (void) + throw (NoSRD); + + private: + bool build_srd (); + + + bool build_xsc (); + + auto_ptr < ::CIAO::DAnCE::ServerResource > idl_srd_; + + auto_ptr <ServerResourcesDef> srd_; + + bool retval_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /* SRD_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.cpp new file mode 100644 index 00000000000..4d65478d19c --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.cpp @@ -0,0 +1,81 @@ +// $Id$ + +#include "TPL_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool + TPL_Handler::threadpool_with_lanes ( + const ThreadpoolWithLanesDef &src, + ::CIAO::DAnCE::ORS_ThreadpoolWithLanes &dest) + { + if (src.id_p ()) + { + dest.Id = CORBA::string_dup (src.id().c_str ()); + } + + for (ThreadpoolWithLanesDef::threadpoolLane_const_iterator loc = + src.begin_threadpoolLane (); + loc != src.end_threadpoolLane (); + loc++) + { + size_t len = dest.threadpool_lanes.length (); + + dest.threadpool_lanes.length (len + 1); + + dest.threadpool_lanes[len].lane_priority = + static_cast <ACE_INT16> (loc->priority ()); + + dest.threadpool_lanes[len].static_threads = + static_cast <ACE_UINT32> (loc->static_threads ()); + + dest.threadpool_lanes[len].dynamic_threads = + static_cast <ACE_UINT32> (loc->dynamic_threads ()); + } + + dest.stacksize = static_cast <ACE_INT16> (src.stacksize ()); + + dest.allow_borrowing = src.allow_borrowing (); + + dest.allow_request_buffering = src.allow_request_buffering (); + + dest.max_buffered_requests = + static_cast <ACE_UINT32> (src.max_buffered_requests ()); + + dest.max_request_buffer_size = + static_cast <ACE_UINT32> (src.max_request_buffered_size ()); + + return true; + } + + ThreadpoolWithLanesDef TPL_Handler::threadpool_with_lanes ( + const ::CIAO::DAnCE::ORS_ThreadpoolWithLanes &src) + { + ThreadpoolWithLanesDef tpl (XMLSchema::unsignedLong (src.stacksize), + XMLSchema::boolean ((src.allow_borrowing)), + XMLSchema::boolean ((src.allow_request_buffering)), + XMLSchema::unsignedLong ((src.max_buffered_requests)), + XMLSchema::unsignedLong ((src.max_request_buffer_size)) + ); + + //XMLSchema::ID <ACE_TCHAR> id = ((src.Id)); + tpl.id (src.Id.in ()); + + size_t len = src.threadpool_lanes.length (); + for (size_t i = 0; i < len; i++) + { + ThreadpoolLaneDef new_tplane ( + XMLSchema::unsignedLong (src.threadpool_lanes[i].static_threads), + XMLSchema::unsignedLong (src.threadpool_lanes[i].dynamic_threads), + XMLSchema::int_ (src.threadpool_lanes[i].lane_priority)); + + tpl.add_threadpoolLane (new_tplane); + } + + return tpl; + } + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.h new file mode 100644 index 00000000000..dab5646e32b --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/TPL_Handler.h @@ -0,0 +1,48 @@ +//=============================================== +/* + * @file TPL_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu> + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + */ +//=============================================== + +#ifndef CIAO_CONFIG_HANDLERS_TPL_HANDLER_H +#define CIAO_CONFIG_HANDLERS_TPL_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#include "RT_CCM_Handlers_Export.h" + +namespace CIAO +{ + namespace Config_Handlers + { + class ThreadpoolWithLanesDef; + + /* + * @class TPL_Handler + * A brief Handler class for <ThreadpoolWithLanesDef> + */ + + class RT_CCM_Handlers_Export TPL_Handler + { + public: + + static bool threadpool_with_lanes ( + const ThreadpoolWithLanesDef &src, + ::CIAO::DAnCE::ORS_ThreadpoolWithLanes &dest); + + static ThreadpoolWithLanesDef threadpool_with_lanes ( + const ::CIAO::DAnCE::ORS_ThreadpoolWithLanes &src); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* TPL_HANDLER_H */ + diff --git a/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.cpp b/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.cpp new file mode 100644 index 00000000000..3def524a0bb --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.cpp @@ -0,0 +1,57 @@ +// $Id$Exp lseibert + +#include "TP_Handler.h" +#include "CIAOServerResources.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + bool TP_Handler::thread_pool (const ThreadpoolDef &src, + ::CIAO::DAnCE::ORS_Threadpool &dest) + { + dest.Id = CORBA::String_var (src.id ().c_str ()); + + dest.stacksize = + static_cast <ACE_UINT32> (src.stacksize ()); + + dest.static_threads = + static_cast <ACE_UINT32> (src.static_threads( )); + + dest.dynamic_threads = + static_cast <ACE_UINT32> (src.dynamic_threads()); + + dest.default_priority = + static_cast <ACE_INT16> (src.default_priority ()); + + dest.allow_request_buffering = src.allow_request_buffering (); + + dest.max_buffered_requests = + static_cast <ACE_UINT32> (src.max_buffered_requests ()); + + dest.max_request_buffer_size = + static_cast <ACE_UINT32> (src.max_request_buffered_size ()); + + return true; + } + + ThreadpoolDef + TP_Handler::thread_pool (const ::CIAO::DAnCE::ORS_Threadpool &src) + { + ThreadpoolDef tp (XMLSchema::unsignedLong (src.stacksize), + XMLSchema::unsignedLong (src.static_threads), + XMLSchema::unsignedLong (src.dynamic_threads), + XMLSchema::int_ (src.default_priority), + XMLSchema::boolean (src.allow_request_buffering), + XMLSchema::unsignedLong (src.max_buffered_requests), + XMLSchema::unsignedLong (src.max_request_buffer_size)); + + if (src.Id.in () == 0) + { + tp.id (src.Id.in ()); + } + + return tp; + } + } +} diff --git a/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.h b/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.h new file mode 100644 index 00000000000..34172995405 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/TP_Handler.h @@ -0,0 +1,46 @@ +//============================================== +/* + * @file TP_Handler.h + * + * @author Lucas Seibert <lseibert@dre.vanderbilt.edu> + * @author Will Otte <wotte@dre.vanderbilt.edu> + * $Id$ + */ +//============================================== + +#ifndef CIAO_CONFIG_HANDLERS_TP_HANDLER_H +#define CIAO_CONFIG_HANDLERS_TP_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "RT_CCM_Handlers_Export.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +namespace CIAO +{ + namespace Config_Handlers + { + class ThreadpoolDef; + + /* + * @class TP_Handler + * A brief Handler class for <ThreadpoolDef> + */ + + class RT_CCM_Handlers_Export TP_Handler + { + public: + static bool thread_pool (const ThreadpoolDef &src, + ::CIAO::DAnCE::ORS_Threadpool &dest); + + static ThreadpoolDef thread_pool (const ::CIAO::DAnCE::ORS_Threadpool &src); + }; + } +} + +#include /**/ "ace/post.h" +#endif /* TP_HANDLER_H */ diff --git a/CIAO/tools/Config_Handlers/RT-CCM/input.csr b/CIAO/tools/Config_Handlers/RT-CCM/input.csr new file mode 100644 index 00000000000..3a44faf9754 --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/input.csr @@ -0,0 +1,70 @@ + +<CIAO:ServerResources + xmlns:CIAO="http://www.dre.vanderbilt.edu/ServerResources" + xmlns:xmi="http://www.omg.org/XMI" + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://www.dre.vanderbilt.edu/ServerResources CIAOServerResources.xsd"> + + <cmdline> + <arg> -ORBDebugLevel 10 -ORBEndpoint corbaloc://foo/bar</arg> + </cmdline> + + <svcconf> + <uri> + svcconf.uri + </uri> + </svcconf> + + <orbConfigs> + <resources> + <threadpool id="threadpool-1"> + <stacksize>100</stacksize> + <static_threads>50</static_threads> + <dynamic_threads>25</dynamic_threads> + <default_priority>5</default_priority> + <allow_request_buffering>true</allow_request_buffering> + <max_buffered_requests>10</max_buffered_requests> + <max_request_buffered_size>20</max_request_buffered_size> + </threadpool> + + <threadpoolWithLanes id="threadpool-2"> + <threadpoolLane> + <static_threads>50</static_threads> + <dynamic_threads>25</dynamic_threads> + <priority>36</priority> + </threadpoolLane> + <stacksize>100</stacksize> + <allow_borrowing>true</allow_borrowing> + <allow_request_buffering>true</allow_request_buffering> + <max_buffered_requests>10</max_buffered_requests> + <max_request_buffered_size>20</max_request_buffered_size> + </threadpoolWithLanes> + + <connectionBands id="cb-1"> + <band> + <low>0</low> + <high>10</high> + </band> + <band> + <low>11</low> + <high>20</high> + </band> + </connectionBands> + </resources> + + <policySet> + <priorityModel server_priority="10"> + <priority_model>SERVER_DECLARED</priority_model> + </priorityModel> + <priorityModel> + <priority_model>CLIENT_PROPAGATED</priority_model> + </priorityModel> + + <threadpool>threadpool-1</threadpool> + <threadpool>threadpool-2</threadpool> + + <priorityBandedConnection>cb-1</priorityBandedConnection> + + </policySet> + </orbConfigs> +</CIAO:ServerResources> diff --git a/CIAO/tools/Config_Handlers/RT-CCM/test.cpp b/CIAO/tools/Config_Handlers/RT-CCM/test.cpp new file mode 100644 index 00000000000..1a951c8983b --- /dev/null +++ b/CIAO/tools/Config_Handlers/RT-CCM/test.cpp @@ -0,0 +1,89 @@ +// $Id$ + +#include <iostream> + +#include "CIAOServerResources.hpp" +#include "SRD_Handler.h" +#include "ciao/ServerResourcesC.h" + +#include "ace/Get_Opt.h" +#include "XML_Helper.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; +} + +using namespace CIAO::Config_Handlers; + +int main (int argc, char *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); + + //Create an XML_Helper for all the file work + XML_Helper the_helper; + + if (xercesc::DOMDocument *doc = the_helper.create_dom (input_file)) + { + //Read in the XSC type structure from the DOMDocument + ServerResourcesDef srd = ServerResources (doc); + + // Convert XSC to idl datatype + SRD_Handler srd_handler (&srd); + + std::cout << "Instance document import succeeded. Dumping contents to file\n"; + + CIAO::DAnCE::ServerResource *sr (srd_handler.srd_idl ()); + + SRD_Handler reverse_handler (sr); + + xercesc::DOMDocument *the_xsc (the_helper.create_dom ("CIAO:ServerResources", + "http://www.dre.vanderbilt.edu/ServerResources")); + + std::cout << "NS:" + << std::string (xercesc::XMLString::transcode (the_xsc->getDocumentElement ()->getNamespaceURI ())) << std::endl + << std::string (xercesc::XMLString::transcode (the_xsc->getDocumentElement ()->getPrefix ())) << std::endl + << std::string (xercesc::XMLString::transcode (the_xsc->getDocumentElement ()->getLocalName ())) << std::endl + << std::endl; + + ServerResources (*reverse_handler.srd_xsc (), the_xsc); + + // write out the result + the_helper.write_DOM (the_xsc, "output.srd"); + } + + std::cout << "Test completed!"; + + return 0; + +} diff --git a/CIAO/tools/Config_Handlers/Req_Handler.cpp b/CIAO/tools/Config_Handlers/Req_Handler.cpp new file mode 100644 index 00000000000..76d0d5b7791 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Req_Handler.cpp @@ -0,0 +1,57 @@ +// $Id$ + +#include "Req_Handler.h" +#include "Property_Handler.h" +#include "DAnCE/Deployment/DeploymentC.h" +#include "ciao/CIAO_common.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 = desc.name ().c_str (); + toconfig.resourceType = 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< char > name ((src.name)); + XMLSchema::string< char > res ((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/CIAO/tools/Config_Handlers/Req_Handler.h b/CIAO/tools/Config_Handlers/Req_Handler.h new file mode 100644 index 00000000000..18eba6744af --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/STD_CID_Handler.cpp b/CIAO/tools/Config_Handlers/STD_CID_Handler.cpp new file mode 100644 index 00000000000..607c964d700 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/STD_CID_Handler.h b/CIAO/tools/Config_Handlers/STD_CID_Handler.h new file mode 100644 index 00000000000..475c1c1b471 --- /dev/null +++ b/CIAO/tools/Config_Handlers/STD_CID_Handler.h @@ -0,0 +1,79 @@ +//================================================ +/** + * @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 "Utils/XML_Helper.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 (XML_Helper *xml_helper) + :xml_helper_ (xml_helper) + { + } + + /// 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) + { + } + + XML_Helper *xml_helper_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_CID_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp b/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp new file mode 100644 index 00000000000..1ad0d109fa5 --- /dev/null +++ b/CIAO/tools/Config_Handlers/STD_CPD_Handler.cpp @@ -0,0 +1,57 @@ +// $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" + +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 (!this->xml_helper_->is_initialized ()) + return false; + + // parse the .cid (ComponentImplementationDescription) file + // that <referencedImplementation> links to + xercesc::DOMDocument* dom = + this->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 (this->xml_helper_); + + 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/CIAO/tools/Config_Handlers/STD_CPD_Handler.h b/CIAO/tools/Config_Handlers/STD_CPD_Handler.h new file mode 100644 index 00000000000..654fb0155ca --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/STD_IAD_Handler.cpp b/CIAO/tools/Config_Handlers/STD_IAD_Handler.cpp new file mode 100644 index 00000000000..020396582d3 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/STD_IAD_Handler.h b/CIAO/tools/Config_Handlers/STD_IAD_Handler.h new file mode 100644 index 00000000000..3523526f5be --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/STD_PCD_Handler.cpp b/CIAO/tools/Config_Handlers/STD_PCD_Handler.cpp new file mode 100644 index 00000000000..6bef6636238 --- /dev/null +++ b/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 (!this->xml_helper_->is_initialized ()) + return false; + + // parse the .cpd (ComponentPackageDescription) file + // that <basePackage> links to + xercesc::DOMDocument* dom = + this->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 (this->xml_helper_); + + cpd_handler.component_package_descr (cpc, + idl_cpc); + + toconfig.basePackage.length (1); + toconfig.basePackage [0] = idl_cpc; + + return true; + } + } +} diff --git a/CIAO/tools/Config_Handlers/STD_PCD_Handler.h b/CIAO/tools/Config_Handlers/STD_PCD_Handler.h new file mode 100644 index 00000000000..ba53f6736da --- /dev/null +++ b/CIAO/tools/Config_Handlers/STD_PCD_Handler.h @@ -0,0 +1,78 @@ +//================================================ +/** + * @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 "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 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 (XML_Helper *xml_helper) + :xml_helper_ (xml_helper) + { + } + + /// 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 () + :xml_helper_ (0) + { + } + + XML_Helper *xml_helper_; + }; + } +} + +#include /**/ "ace/post.h" +#endif /* CIAO_CONFIG_HANDLERS_STD_PCD_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/STD_PC_Intf.cpp b/CIAO/tools/Config_Handlers/STD_PC_Intf.cpp new file mode 100644 index 00000000000..e265295d040 --- /dev/null +++ b/CIAO/tools/Config_Handlers/STD_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/CIAO_common.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/CIAO/tools/Config_Handlers/STD_PC_Intf.h b/CIAO/tools/Config_Handlers/STD_PC_Intf.h new file mode 100644 index 00000000000..2e07e1922eb --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp b/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp new file mode 100644 index 00000000000..d01f0d7f6f4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.cpp @@ -0,0 +1,118 @@ +//$Id$ + +#include "SatisfierProperty_Handler.h" +#include "Any_Handler.h" +#include "Basic_Deployment_Data.hpp" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/CIAO_common.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 = 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, "Unknown SatisfierPropertyKind\n")); + throw 1; + + } + + toconfig.dynamic = desc.dynamic (); + + Any_Handler::extract_into_any (desc.value (), + toconfig.value); + } + + SatisfierProperty + SatisfierProperty_Handler::get_sat_property ( + const Deployment::SatisfierProperty& src) + { + CIAO_TRACE("SatisfierProperty_Handler::get_sat_property - reverse"); + + ::XMLSchema::string< ACE_TCHAR > name ((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 ("Invalid SatisfierPropertyKind"); + } + + bool dynamic = src.dynamic; + + Any value (Any_Handler::get_any (src.value)); + + return SatisfierProperty (name, *spk, dynamic, value); + } + + } +} diff --git a/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.h b/CIAO/tools/Config_Handlers/SatisfierProperty_Handler.h new file mode 100644 index 00000000000..c48dc353766 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/Utils/CIAO_XML_Utils_Export.h b/CIAO/tools/Config_Handlers/Utils/CIAO_XML_Utils_Export.h new file mode 100644 index 00000000000..f4f3ec3a1cd --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/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/CIAO/tools/Config_Handlers/Utils/Exceptions.h b/CIAO/tools/Config_Handlers/Utils/Exceptions.h new file mode 100644 index 00000000000..dadb7ed615d --- /dev/null +++ b/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::string &reason) + : reason_ (reason) + { + } + + std::string reason_; + }; + + struct Plan_Error + { + Plan_Error (const std::string &reason) + : reason_ (reason) + { + } + + std::string reason_; + }; + + } +} + + + + diff --git a/CIAO/tools/Config_Handlers/Utils/Functors.h b/CIAO/tools/Config_Handlers/Utils/Functors.h new file mode 100644 index 00000000000..6856a0defec --- /dev/null +++ b/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 Source &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 ::XMLSchema::string<ACE_TCHAR> &src) + { + dest_[pos_++] = 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/CIAO/tools/Config_Handlers/Utils/Utils.mpc b/CIAO/tools/Config_Handlers/Utils/Utils.mpc new file mode 100644 index 00000000000..704c856d752 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/Utils.mpc @@ -0,0 +1,15 @@ +// $Id$ + +project (CIAO_XML_Utils) : acelib, xerces { + includes += $(CIAO_ROOT)/tools/Config_Handlers + sharedname += CIAO_XML_Utils + dynamicflags = CIAO_XML_UTILS_BUILD_DLL + macros += XML_USE_PTHREADS + + Source_Files { + XML_Schema_Resolver.cpp + XML_Error_Handler.cpp + XML_Helper.cpp + XercesString.cpp + } +} diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.cpp b/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.cpp new file mode 100644 index 00000000000..beae7bce56c --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.cpp @@ -0,0 +1,72 @@ +// $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 "XercesString.h" + +using xercesc::XMLString; + +namespace CIAO +{ + namespace Config_Handlers + { + XML_Error_Handler::XML_Error_Handler (void) + : errors_ (false) + { + } + + XML_Error_Handler::~XML_Error_Handler() + { + } + + + bool + XML_Error_Handler::handleError (const DOMError& domError) + { + this->errors_ = true; + + if (domError.getSeverity() == DOMError::DOM_SEVERITY_WARNING) + ACE_DEBUG ((LM_DEBUG, + "(%P|%t), Warning ")); + else if (domError.getSeverity() == DOMError::DOM_SEVERITY_ERROR) + ACE_DEBUG ((LM_DEBUG, + "(%P|%t), Error ")); + else + ACE_DEBUG ((LM_DEBUG, + "(%P|%t), Fatal Error ")); + char *msg = + XMLString::transcode (domError.getMessage ()); + + ACE_Auto_Basic_Array_Ptr<char> cleanup_msg (msg); + + char *file = + XMLString::transcode (domError.getLocation ()->getURI ()); + + ACE_Auto_Basic_Array_Ptr<char> cleanup_file (file); + + ACE_DEBUG ((LM_DEBUG, + "%s at line %d and column %d in file %s\n", + msg, + domError.getLocation ()->getLineNumber (), + domError.getLocation ()->getColumnNumber (), + file)); + + return true; + } + + void + XML_Error_Handler::resetErrors (void) + { + this->errors_ = false; + } + + bool + XML_Error_Handler::getErrors (void) const + { + return this->errors_; + } + } +} diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.h b/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.h new file mode 100644 index 00000000000..1b338de6773 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Error_Handler.h @@ -0,0 +1,65 @@ +//============================================================== +/** + * @file XML_Error_Handler.h + * + * $Id$ + * + * @brief Error handler for Xerces + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//================================================================ +#ifndef CIAO_CONFIG_HANLDERS_ERROR_HANDLER_H +#define CIAO_CONFIG_HANLDERS_ERROR_HANDLER_H + +#include /**/ "ace/pre.h" + +#include "CIAO_XML_Utils_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include <xercesc/dom/DOMErrorHandler.hpp> + +using xercesc::DOMErrorHandler; +using xercesc::DOMError; + +namespace CIAO +{ + namespace Config_Handlers + { + /** + * @class XML_Error_Hander + * + * @brief Error handler for XERCES + * + */ + class XML_Error_Handler + : public DOMErrorHandler + { + public: + + XML_Error_Handler (void); + + ~XML_Error_Handler (void); + + bool handleError (const DOMError& domError); + + void resetErrors (void); + + 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_CONFIG_HANLDERS_ERROR_HANDLER_H*/ diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Helper.cpp b/CIAO/tools/Config_Handlers/Utils/XML_Helper.cpp new file mode 100644 index 00000000000..fc9fd07f809 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Helper.cpp @@ -0,0 +1,240 @@ +//$Id$ +#include "XML_Helper.h" +#include "ace/Auto_Ptr.h" +#include "ace/Log_Msg.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 "XercesString.h" + +namespace CIAO +{ + namespace Config_Handlers + { + 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; + + XML_Helper::XML_Helper (void) + : initialized_ (false) + { + this->init_parser (); + } + + XML_Helper::~XML_Helper (void) + { + this->terminate_parser (); + } + + bool + XML_Helper::is_initialized (void) const + { + return this->initialized_ == true; + } + + void + XML_Helper::init_parser (void) + { + if (this->initialized_) + return; + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) 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; + } + + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper::create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns) + { + if (root == 0 || ns == 0) + return 0; + + return this->impl_->createDocument (XStr (ns), + XStr (root), + 0); + } + + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper::create_dom (const ACE_TCHAR *url) + { + + if (url == 0) + return impl_->createDocument( + XStr ("http://www.omg.org/DeploymentPlan"), + XStr ("deploymentPlan"), + 0); + + try + { + + // Create a DOMBuilder + DOMBuilder* parser = + impl_->createDOMBuilder (DOMImplementationLS::MODE_SYNCHRONOUS, + 0); + + // Discard comment nodes in the document + parser->setFeature (XMLUni::fgDOMComments, false); + + // Disable datatype normalization. The XML 1.0 attribute value + // normalization always occurs though. + 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. + parser->setFeature (XMLUni::fgDOMEntities, false); + + // Perform Namespace processing. + parser->setFeature (XMLUni::fgDOMNamespaces, true); + + // Perform Validation + parser->setFeature (XMLUni::fgDOMValidation, true); + + // Do not include ignorable whitespace in the DOM tree. + parser->setFeature (XMLUni::fgDOMWhitespaceInElementContent, false); + + // Enable the parser's schema support. + parser->setFeature (XMLUni::fgXercesSchema, 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. + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, true); + + // The parser will treat validation error as fatal and will exit. + parser->setFeature (XMLUni::fgXercesValidationErrorAsFatal, true); + + XML_Error_Handler handler; + + parser->setErrorHandler (&handler); + + CIAO_Schema_Resolver resolver; + + parser->setEntityResolver (&resolver); + + DOMDocument* doc = parser->parseURI (url); + + if (handler.getErrors ()) + throw 0; + + return doc; + } + 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 0; + } + + return 0; + } + + void + XML_Helper::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; + } + + bool XML_Helper::write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file) + { + bool retn; + XERCES_CPP_NAMESPACE::DOMWriter *writer = impl_->createDOMWriter(); + + if (writer->canSetFeature (XMLUni::fgDOMWRTFormatPrettyPrint, + true)) + writer->setFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true); + + xercesc::XMLFormatTarget* ft (new xercesc::LocalFileFormatTarget(file)); + retn = writer->writeNode(ft, *doc); + delete writer; + delete ft; + return retn; + } + } +} +#if defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION) +template ACE_Singleton< CIAO::Config_Handlers::XML_Helper, ACE_Null_Mutex> * +ACE_Singleton<CIAO::Config_Handlers::XML_Helper, ACE_Null_Mutex>::singleton_; +#endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */ + + diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Helper.h b/CIAO/tools/Config_Handlers/Utils/XML_Helper.h new file mode 100644 index 00000000000..03b2f89bc28 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Helper.h @@ -0,0 +1,95 @@ +// $Id$ +//============================================================ +/** + * @file XML_Helper.h + * + * @brief Some helper functions for XML + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//============================================================ +#ifndef CIAO_CONFIG_HANDLERS_XML_HELPER_H +#define CIAO_CONFIG_HANDLERS_XML_HELPER_H +#include /**/ "ace/pre.h" + +#include "CIAO_XML_Utils_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ +#include "ace/Singleton.h" +#include "ace/Null_Mutex.h" + +#include "xercesc/util/XercesDefs.hpp" + +namespace XERCES_CPP_NAMESPACE +{ + class DOMDocument; + class DOMWriter; + class DOMImplementation; +} + + +namespace CIAO +{ + namespace Config_Handlers + { + /** + * @class XML_Helper + * + * @brief Helper class for some routine XML stuff. + */ + class CIAO_XML_Utils_Export XML_Helper + { + public: + XML_Helper (void); + + ~XML_Helper (void); + + /// Create a DOM tree + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *uri); + + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns); + + //Writes out a DOMDocument to an XML file + bool write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file); + + 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_; + }; + + + } +} + +CIAO_XML_UTILS_SINGLETON_DECLARE (ACE_Singleton, + CIAO::Config_Handlers::XML_Helper, + ACE_Null_Mutex) +namespace CIAO +{ + namespace Config_Handlers + { + typedef ACE_Singleton < XML_Helper, ACE_Null_Mutex > XML_Helper_Singleton; + } +} + + +#define XML_HELPER CIAO::Config_Handlers::XML_Helper_Singleton::instance () + + +#include /**/ "ace/post.h" +#endif/*CIAO_CONFIG_HANDLERS_XML_HELPER_H*/ diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.cpp b/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.cpp new file mode 100644 index 00000000000..269e95ab425 --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.cpp @@ -0,0 +1,55 @@ +// $Id$ +#include "XML_Schema_Resolver.h" +#include "XercesString.h" +#include "ace/Env_Value_T.h" +#include <xercesc/framework/LocalFileInputSource.hpp> +#include <xercesc/framework/Wrapper4InputSource.hpp> + +using xercesc::Wrapper4InputSource; +using xercesc::LocalFileInputSource; + + +namespace CIAO +{ + namespace Config_Handlers + { + CIAO_Schema_Resolver::CIAO_Schema_Resolver (void) + { + this->base_path_ = this->resolve_from_environment (); + } + + CIAO_Schema_Resolver::CIAO_Schema_Resolver (const char *path) + { + if (path == 0) + this->base_path_ = this->resolve_from_environment (); + else + this->base_path_ = path; + } + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + DOMInputSource * + CIAO_Schema_Resolver::resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId, + const XMLCh *const baseURI) + { + ACE_UNUSED_ARG (baseURI); + ACE_UNUSED_ARG (publicId); + + XStr path (this->base_path_.c_str ()); + path.append (systemId); + + // Ownership of these objects is given to other people. + return new Wrapper4InputSource (new LocalFileInputSource (path)); + } + + std::string + CIAO_Schema_Resolver::resolve_from_environment (void) + { + ACE_Env_Value <const char *> path ("CIAO_ROOT", ""); + + std::string retval (path); + return retval += "/docs/schema/"; + } + } +} diff --git a/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.h b/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.h new file mode 100644 index 00000000000..f4573fe20cc --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XML_Schema_Resolver.h @@ -0,0 +1,66 @@ +/** + * @file XML_Schema_Resolver.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + * + * Resolves schema locations. + */ + +#ifndef CIAO_CONFIG_HANDLERS_XML_SCHEAM_RESOLVER_H +#define CIAO_CONFIG_HANDLERS_XML_SCHEAM_RESOLVER_H +#include /**/ "ace/pre.h" + +#include "CIAO_XML_Utils_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include <xercesc/dom/DOMEntityResolver.hpp> +#include <xercesc/dom/DOMInputSource.hpp> + +#include <string> + +using xercesc::DOMEntityResolver; +using xercesc::DOMInputSource; + +namespace CIAO +{ + namespace Config_Handlers + { + /** + * @class CIAO_Schema_Resolver + * @brief Resolves schema locations for CIAO. + */ + class CIAO_Schema_Resolver + : public virtual DOMEntityResolver + { + public: + /// This constructor locates the schema in the default location + /// from CIAO_ROOT/docs/schema. + CIAO_Schema_Resolver (void); + + /// If this constructor is passed a nonempty string, it locates + /// the schema in that path, otherwise its behavior is the same + /// as the default constructor. + CIAO_Schema_Resolver (const char *path); + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + virtual DOMInputSource * resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId, + const XMLCh *const baseURI); + + private: + std::string resolve_from_environment (void); + + std::string base_path_; + }; + } +} + + +#include /**/ "ace/post.h" + +#endif /* CIAO_CONFIG_HANDLERS_XML_SCHEAM_RESOLVER_H */ diff --git a/CIAO/tools/Config_Handlers/Utils/XercesString.cpp b/CIAO/tools/Config_Handlers/Utils/XercesString.cpp new file mode 100644 index 00000000000..6f034163e4b --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XercesString.cpp @@ -0,0 +1,144 @@ +// $Id$ + +#include <ostream> +#include <algorithm> + +#include "XercesString.h" +using xercesc::XMLString; + +namespace CIAO +{ +namespace Config_Handlers +{ + + XStr::XStr (const char* str) + : _wstr(0) + { + _wstr = XMLString::transcode(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 != NULL; + 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]; + } + + 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/CIAO/tools/Config_Handlers/Utils/XercesString.h b/CIAO/tools/Config_Handlers/Utils/XercesString.h new file mode 100644 index 00000000000..e7f0059086b --- /dev/null +++ b/CIAO/tools/Config_Handlers/Utils/XercesString.h @@ -0,0 +1,73 @@ +// $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> + +#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 "CIAO_XML_Utils_Export.h" +namespace CIAO +{ +namespace Config_Handlers +{ + + class CIAO_XML_Utils_Export XStr + { + public: + XStr() : _wstr(0L) { }; + + XStr (const char* 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; }; + + 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/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp b/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp new file mode 100644 index 00000000000..b435bb4370f --- /dev/null +++ b/CIAO/tools/Config_Handlers/XMLSchema/Traversal.hpp @@ -0,0 +1,72 @@ +// 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> > + { + }; + } +} + +#include <XMLSchema/Traversal.ipp> +#include <XMLSchema/Traversal.tpp> + +#endif // XMLSCHEMA_TRAVERSAL_HPP diff --git a/CIAO/tools/Config_Handlers/XMLSchema/Traversal.ipp b/CIAO/tools/Config_Handlers/XMLSchema/Traversal.ipp new file mode 100644 index 00000000000..a5c614182a3 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/Traversal.tpp b/CIAO/tools/Config_Handlers/XMLSchema/Traversal.tpp new file mode 100644 index 00000000000..d79c13630fb --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.hpp b/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.hpp new file mode 100644 index 00000000000..e4fa52dbb9c --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.ipp b/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.ipp new file mode 100644 index 00000000000..5b9422f38c8 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp b/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp new file mode 100644 index 00000000000..6ead5b8f7b2 --- /dev/null +++ b/CIAO/tools/Config_Handlers/XMLSchema/TypeInfo.tpp @@ -0,0 +1,97 @@ +// 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<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/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp b/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp new file mode 100644 index 00000000000..a23d7f2cdd9 --- /dev/null +++ b/CIAO/tools/Config_Handlers/XMLSchema/Types.hpp @@ -0,0 +1,574 @@ +// 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: + + //@@ 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> + 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 (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: + 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_; + }; +} + +#include "XMLSchema/Types.ipp" +#include "XMLSchema/Types.tpp" + +#endif // XMLSCHEMA_TYPES_HPP diff --git a/CIAO/tools/Config_Handlers/XMLSchema/Types.ipp b/CIAO/tools/Config_Handlers/XMLSchema/Types.ipp new file mode 100644 index 00000000000..6b749260f55 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/Types.tpp b/CIAO/tools/Config_Handlers/XMLSchema/Types.tpp new file mode 100644 index 00000000000..4a8bddcf597 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/Writer.hpp b/CIAO/tools/Config_Handlers/XMLSchema/Writer.hpp new file mode 100644 index 00000000000..4a0c1603efa --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/Writer.ipp b/CIAO/tools/Config_Handlers/XMLSchema/Writer.ipp new file mode 100644 index 00000000000..2b7c9a4b939 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XMLSchema/Writer.tpp b/CIAO/tools/Config_Handlers/XMLSchema/Writer.tpp new file mode 100644 index 00000000000..6c57de04d81 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XML_File_Intf.cpp b/CIAO/tools/Config_Handlers/XML_File_Intf.cpp new file mode 100644 index 00000000000..53e8ac1e801 --- /dev/null +++ b/CIAO/tools/Config_Handlers/XML_File_Intf.cpp @@ -0,0 +1,65 @@ +// $Id$ + +#include "XML_File_Intf.h" +#include "Utils/XML_Helper.h" +#include "Deployment.hpp" +#include "DP_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "ciao/CIAO_common.h" + + +namespace CIAO +{ + namespace Config_Handlers + { + XML_File_Intf::XML_File_Intf (const char *file) + { + if (!this->read_process_file (file)) + throw; + } + + bool + XML_File_Intf::read_process_file (const char *file) + { + CIAO_TRACE("XML_File_Intf::read_process_file"); + + XML_Helper helper; + + if (!helper.is_initialized ()) + return false; + + XERCES_CPP_NAMESPACE::DOMDocument *dom = + helper.create_dom (file); + + if (!dom) + return false; + + DeploymentPlan dp = + deploymentPlan (dom); + + + DP_Handler dp_handler (dp); + + this->idl_dp_.reset (dp_handler.plan ()); + + if (this->idl_dp_.get ()) + return true; + + return false; + } + + ::Deployment::DeploymentPlan const * + XML_File_Intf::get_plan (void) const + { + CIAO_TRACE("get_plan"); + return this->idl_dp_.get (); + } + + ::Deployment::DeploymentPlan * + XML_File_Intf::get_plan (void) + { + CIAO_TRACE("XML_File_Intf::get_plan"); + return this->idl_dp_.release (); + } + } +} diff --git a/CIAO/tools/Config_Handlers/XML_File_Intf.h b/CIAO/tools/Config_Handlers/XML_File_Intf.h new file mode 100644 index 00000000000..9f5869b20fb --- /dev/null +++ b/CIAO/tools/Config_Handlers/XML_File_Intf.h @@ -0,0 +1,51 @@ +//============================================================== +/** +* @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" + + +namespace Deployment +{ +struct DeploymentPlan ; +} + +namespace CIAO +{ +namespace Config_Handlers +{ +class Config_Handlers_Export XML_File_Intf +{ +public: +XML_File_Intf (const char *file); + +::Deployment::DeploymentPlan const *get_plan (void) const; +::Deployment::DeploymentPlan *get_plan (void); + +protected: + +bool read_process_file (const char *file); + +private: +ACE_Auto_Ptr< ::Deployment::DeploymentPlan> idl_dp_; +}; +} +} +#include /**/ "ace/post.h" +#endif /*CIAO_CONFIG_XML_FILE_INTF_H*/ diff --git a/CIAO/tools/Config_Handlers/XSCRT/Elements.hpp b/CIAO/tools/Config_Handlers/XSCRT/Elements.hpp new file mode 100644 index 00000000000..7c2b1c58d34 --- /dev/null +++ b/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 <iostream> //@@ tmp + +#include "XSCRT/Parser.hpp" + +namespace XSCRT +{ + struct IdentityProvider + { + virtual ~IdentityProvider (void) {} + + virtual bool before (IdentityProvider const&) const = 0; + }; + + class Type + { + public: + virtual ~Type () + { + } + + protected: + Type () + : 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; + } + + + private: + 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: + 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__ == 0x564)) || \ + (defined (__SUNPRO_CC) && (__SUNPRO_CC <= 0x570))) + + // Stuff for broken 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_; + }; + +#else + + // 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); + } + +#endif + + + // Specialization for bool. + // + // + +#if !defined (_MSC_VER) || (_MSC_VER >= 1300) + + 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"); + } + +#else + + template <> + class FundamentalType<bool> : public Type + { + public: + FundamentalType () + { + } + + template<typename C> + FundamentalType (XML::Element<C> const& e) + { + x_ = (e.value ()[0] == 't') || (e.value ()[0] == '1'); + } + + template<typename C> + FundamentalType (XML::Attribute<C> const& a) + { + x_ = (a.value ()[0] == 't') || (a.value ()[0] == '1'); + } + + FundamentalType (bool const& x) + : x_ (x) + { + } + + FundamentalType& + operator= (bool const& x) + { + x_ = x; + return *this; + } + + public: + operator bool const& () const + { + return x_; + } + + operator bool& () + { + return x_; + } + + protected: + bool x_; + }; + +#endif + +} + +#include "XSCRT/Elements.ipp" +#include "XSCRT/Elements.tpp" + +#endif // XSCRT_ELEMENTS_HPP diff --git a/CIAO/tools/Config_Handlers/XSCRT/Elements.ipp b/CIAO/tools/Config_Handlers/XSCRT/Elements.ipp new file mode 100644 index 00000000000..414f03eb031 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Elements.tpp b/CIAO/tools/Config_Handlers/XSCRT/Elements.tpp new file mode 100644 index 00000000000..7539a36d75f --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp b/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp new file mode 100644 index 00000000000..e2ab4b64956 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp b/CIAO/tools/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp new file mode 100644 index 00000000000..6c4fba2cf88 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Parser.hpp b/CIAO/tools/Config_Handlers/XSCRT/Parser.hpp new file mode 100644 index 00000000000..5fa1e827f8d --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Parser.ipp b/CIAO/tools/Config_Handlers/XSCRT/Parser.ipp new file mode 100644 index 00000000000..f7de09602ae --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Parser.tpp b/CIAO/tools/Config_Handlers/XSCRT/Parser.tpp new file mode 100644 index 00000000000..75b9f48eb1f --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp b/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp new file mode 100644 index 00000000000..f66b6be1ab6 --- /dev/null +++ b/CIAO/tools/Config_Handlers/XSCRT/Traversal.hpp @@ -0,0 +1,275 @@ +// 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 <iostream> +// using std::wcerr; +// using std::endl; + +#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; + + /*@@ VC6 + template <typename X> + friend class DispatcherBase; + */ + }; + + + // + // + // + 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/CIAO/tools/Config_Handlers/XSCRT/Traversal.ipp b/CIAO/tools/Config_Handlers/XSCRT/Traversal.ipp new file mode 100644 index 00000000000..bc2a462334a --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Traversal.tpp b/CIAO/tools/Config_Handlers/XSCRT/Traversal.tpp new file mode 100644 index 00000000000..b798178621b --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Writer.hpp b/CIAO/tools/Config_Handlers/XSCRT/Writer.hpp new file mode 100644 index 00000000000..6fdd82f6f3e --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Writer.ipp b/CIAO/tools/Config_Handlers/XSCRT/Writer.ipp new file mode 100644 index 00000000000..caa9fc99235 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/Writer.tpp b/CIAO/tools/Config_Handlers/XSCRT/Writer.tpp new file mode 100644 index 00000000000..8593004687f --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/XML.hpp b/CIAO/tools/Config_Handlers/XSCRT/XML.hpp new file mode 100644 index 00000000000..1f11533e2bb --- /dev/null +++ b/CIAO/tools/Config_Handlers/XSCRT/XML.hpp @@ -0,0 +1,490 @@ +// 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 *> + { + enum { node_type = xercesc::DOMNode::ELEMENT_NODE }; + }; + + template <> + struct dom_traits<xercesc::DOMAttr *> + { + enum { 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); + + XMLCh const* p ( + e.dom_element ()->lookupNamespacePrefix (xns.c_str (), false)); + + 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/CIAO/tools/Config_Handlers/XSCRT/XML.ipp b/CIAO/tools/Config_Handlers/XSCRT/XML.ipp new file mode 100644 index 00000000000..4a7b83efd1c --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/XML.tpp b/CIAO/tools/Config_Handlers/XSCRT/XML.tpp new file mode 100644 index 00000000000..63023a05d28 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp b/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp new file mode 100644 index 00000000000..6f810782953 --- /dev/null +++ b/CIAO/tools/Config_Handlers/XSCRT/XMLSchema.hpp @@ -0,0 +1,554 @@ +// 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> + 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/CIAO/tools/Config_Handlers/XSC_XML_Handlers_Export.h b/CIAO/tools/Config_Handlers/XSC_XML_Handlers_Export.h new file mode 100644 index 00000000000..82272eb6c05 --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/ccd.cpp b/CIAO/tools/Config_Handlers/ccd.cpp new file mode 100644 index 00000000000..64e40b82567 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ccd.cpp @@ -0,0 +1,1530 @@ +/* $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 (::CIAO::Config_Handlers::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), + 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); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + { + for (idlFile_const_iterator i (s.idlFile_.begin ());i != s.idlFile_.end ();++i) add_idlFile (*i); + } + + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + { + for (port_const_iterator i (s.port_.begin ());i != s.port_.end ();++i) add_port (*i); + } + + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ::CIAO::Config_Handlers::ComponentInterfaceDescription& ComponentInterfaceDescription:: + operator= (::CIAO::Config_Handlers::ComponentInterfaceDescription const& s) + { + 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.specificType_.get ()) specificType (*(s.specificType_)); + else specificType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + supportedType_.clear (); + { + for (supportedType_const_iterator i (s.supportedType_.begin ());i != s.supportedType_.end ();++i) add_supportedType (*i); + } + + idlFile_.clear (); + { + for (idlFile_const_iterator i (s.idlFile_.begin ());i != s.idlFile_.end ();++i) add_idlFile (*i); + } + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + port_.clear (); + { + for (port_const_iterator i (s.port_.begin ());i != s.port_.end ();++i) add_port (*i); + } + + property_.clear (); + { + for (property_const_iterator i (s.property_.begin ());i != s.property_.end ();++i) add_property (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_)); + else contentLocation_ = ::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); + + 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 (::XMLSchema::string< ACE_TCHAR > 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 (::XMLSchema::string< ACE_TCHAR > 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::ComponentPortDescription 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 (::CIAO::Config_Handlers::ComponentPropertyDescription 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 (::CIAO::Config_Handlers::Property 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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "specificType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + specificType (t); + } + + else if (n == "supportedType") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_supportedType (t); + } + + else if (n == "idlFile") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_idlFile (t); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "port") + { + ::CIAO::Config_Handlers::ComponentPortDescription t (e); + add_port (t); + } + + else if (n == "property") + { + ::CIAO::Config_Handlers::ComponentPropertyDescription t (e); + add_property (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_infoProperty (t); + } + + else if (n == "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 == "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 (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 + // + ComponentInterfaceDescription::Type::supportedType_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void ComponentInterfaceDescription:: + supportedType (Type const& o) + { + // VC6 anathema strikes again + // + ComponentInterfaceDescription::Type::supportedType_const_iterator b (o.begin_supportedType()), e (o.end_supportedType()); + + if (b != e) + { + supportedType_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) supportedType_next (o); + } + + supportedType_post (o); + } + + else supportedType_none (o); + } + + void 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 + // + ComponentInterfaceDescription::Type::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 + // + ComponentInterfaceDescription::Type::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 + // + ComponentInterfaceDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void ComponentInterfaceDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ComponentInterfaceDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void 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 + // + ComponentInterfaceDescription::Type::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 + // + ComponentInterfaceDescription::Type::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 + // + ComponentInterfaceDescription::Type::property_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void ComponentInterfaceDescription:: + property (Type const& o) + { + // VC6 anathema strikes again + // + ComponentInterfaceDescription::Type::property_const_iterator b (o.begin_property()), e (o.end_property()); + + if (b != e) + { + property_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) property_next (o); + } + + property_post (o); + } + + else property_none (o); + } + + void 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 + // + ComponentInterfaceDescription::Type::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 + // + ComponentInterfaceDescription::Type::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 > ("label", top_ ())); + Traversal::ComponentInterfaceDescription::label (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::ComponentInterfaceDescription::UUID (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + specificType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("specificType", top_ ())); + Traversal::ComponentInterfaceDescription::specificType (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + supportedType_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("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 > ("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 > ("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 > ("contentLocation", top_ ())); + Traversal::ComponentInterfaceDescription::contentLocation (o); + pop_ (); + } + + void ComponentInterfaceDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("href", "", top_ ()); + attr_ (&a); + Traversal::ComponentInterfaceDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/ccd.hpp b/CIAO/tools/Config_Handlers/ccd.hpp new file mode 100644 index 00000000000..bb3832af5a6 --- /dev/null +++ b/CIAO/tools/Config_Handlers/ccd.hpp @@ -0,0 +1,773 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export ComponentInterfaceDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator supportedType_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_supportedType (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > supportedType_; + + // idlFile + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator idlFile_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_idlFile (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > idlFile_; + + // configProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > configProperty_; + + // port + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ComponentPortDescription >::iterator port_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ComponentPortDescription >::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 (::CIAO::Config_Handlers::ComponentPortDescription const& ); + size_t count_port (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ComponentPortDescription > port_; + + // property + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ComponentPropertyDescription >::iterator property_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ComponentPropertyDescription >::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 (::CIAO::Config_Handlers::ComponentPropertyDescription const& ); + size_t count_property (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ComponentPropertyDescription > property_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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/CIAO/tools/Config_Handlers/cdd.cpp b/CIAO/tools/Config_Handlers/cdd.cpp new file mode 100644 index 00000000000..799ad5ebec7 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cdd.cpp @@ -0,0 +1,3397 @@ +/* $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 () + : + ::XSCRT::Type (), + regulator__ () + { + } + + Domain:: + Domain (::CIAO::Config_Handlers::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), + regulator__ () + { + if (UUID_.get ()) UUID_->container (this); + if (label_.get ()) label_->container (this); + { + for (node_const_iterator i (s.node_.begin ());i != s.node_.end ();++i) add_node (*i); + } + + { + for (interconnect_const_iterator i (s.interconnect_.begin ());i != s.interconnect_.end ();++i) add_interconnect (*i); + } + + { + for (bridge_const_iterator i (s.bridge_.begin ());i != s.bridge_.end ();++i) add_bridge (*i); + } + + { + for (sharedResource_const_iterator i (s.sharedResource_.begin ());i != s.sharedResource_.end ();++i) add_sharedResource (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + } + + ::CIAO::Config_Handlers::Domain& Domain:: + operator= (::CIAO::Config_Handlers::Domain const& s) + { + if (s.UUID_.get ()) UUID (*(s.UUID_)); + else UUID_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + if (s.label_.get ()) label (*(s.label_)); + else label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + node_.clear (); + { + for (node_const_iterator i (s.node_.begin ());i != s.node_.end ();++i) add_node (*i); + } + + interconnect_.clear (); + { + for (interconnect_const_iterator i (s.interconnect_.begin ());i != s.interconnect_.end ();++i) add_interconnect (*i); + } + + bridge_.clear (); + { + for (bridge_const_iterator i (s.bridge_.begin ());i != s.bridge_.end ();++i) add_bridge (*i); + } + + sharedResource_.clear (); + { + for (sharedResource_const_iterator i (s.sharedResource_.begin ());i != s.sharedResource_.end ();++i) add_sharedResource (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + 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 (::CIAO::Config_Handlers::Node 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 (::CIAO::Config_Handlers::Interconnect 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 (::CIAO::Config_Handlers::Bridge 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 (::CIAO::Config_Handlers::SharedResource 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 (::CIAO::Config_Handlers::Property 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__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Bridge:: + Bridge (::CIAO::Config_Handlers::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), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + { + for (connect_const_iterator i (s.connect_.begin ());i != s.connect_.end ();++i) add_connect (*i); + } + + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + } + + ::CIAO::Config_Handlers::Bridge& Bridge:: + operator= (::CIAO::Config_Handlers::Bridge const& s) + { + name (s.name ()); + + if (s.label_.get ()) label (*(s.label_)); + else label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + connect_.clear (); + { + for (connect_const_iterator i (s.connect_.begin ());i != s.connect_.end ();++i) add_connect (*i); + } + + resource_.clear (); + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + + 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 (::CIAO::Config_Handlers::Interconnect 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 (::CIAO::Config_Handlers::Resource 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__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Interconnect:: + Interconnect (::CIAO::Config_Handlers::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), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + { + for (connect_const_iterator i (s.connect_.begin ());i != s.connect_.end ();++i) add_connect (*i); + } + + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + } + + ::CIAO::Config_Handlers::Interconnect& Interconnect:: + operator= (::CIAO::Config_Handlers::Interconnect const& s) + { + name (s.name ()); + + if (s.label_.get ()) label (*(s.label_)); + else label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + connection_.clear (); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + connect_.clear (); + { + for (connect_const_iterator i (s.connect_.begin ());i != s.connect_.end ();++i) add_connect (*i); + } + + resource_.clear (); + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + + 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 (::CIAO::Config_Handlers::Bridge 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 (::CIAO::Config_Handlers::Node 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 (::CIAO::Config_Handlers::Resource 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__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + Node:: + Node (::CIAO::Config_Handlers::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), + regulator__ () + { + name_->container (this); + if (label_.get ()) label_->container (this); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + { + for (sharedResource_const_iterator i (s.sharedResource_.begin ());i != s.sharedResource_.end ();++i) add_sharedResource (*i); + } + + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + } + + ::CIAO::Config_Handlers::Node& Node:: + operator= (::CIAO::Config_Handlers::Node const& s) + { + name (s.name ()); + + if (s.label_.get ()) label (*(s.label_)); + else label_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (0); + + connection_.clear (); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + sharedResource_.clear (); + { + for (sharedResource_const_iterator i (s.sharedResource_.begin ());i != s.sharedResource_.end ();++i) add_sharedResource (*i); + } + + resource_.clear (); + { + for (resource_const_iterator i (s.resource_.begin ());i != s.resource_.end ();++i) add_resource (*i); + } + + 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 (::CIAO::Config_Handlers::Interconnect 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 (::CIAO::Config_Handlers::SharedResource 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 (::CIAO::Config_Handlers::Resource 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__) + : + ::XSCRT::Type (), + 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 (::CIAO::Config_Handlers::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); + } + + ::CIAO::Config_Handlers::SharedResource& SharedResource:: + operator= (::CIAO::Config_Handlers::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 == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "node") + { + ::CIAO::Config_Handlers::Node t (e); + add_node (t); + } + + else if (n == "interconnect") + { + ::CIAO::Config_Handlers::Interconnect t (e); + add_interconnect (t); + } + + else if (n == "bridge") + { + ::CIAO::Config_Handlers::Bridge t (e); + add_bridge (t); + } + + else if (n == "sharedResource") + { + ::CIAO::Config_Handlers::SharedResource t (e); + add_sharedResource (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "connect") + { + ::CIAO::Config_Handlers::Interconnect t (e); + add_connect (t); + } + + else if (n == "resource") + { + ::CIAO::Config_Handlers::Resource t (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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "connection") + { + ::CIAO::Config_Handlers::Bridge t (e); + add_connection (t); + } + + else if (n == "connect") + { + ::CIAO::Config_Handlers::Node t (e); + add_connect (t); + } + + else if (n == "resource") + { + ::CIAO::Config_Handlers::Resource t (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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "connection") + { + ::CIAO::Config_Handlers::Interconnect t (e); + add_connection (t); + } + + else if (n == "sharedResource") + { + ::CIAO::Config_Handlers::SharedResource t (e); + add_sharedResource (t); + } + + else if (n == "resource") + { + ::CIAO::Config_Handlers::Resource t (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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "resourceType") + { + resourceType_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + resourceType_->container (this); + } + + else if (n == "node") + { + node_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Node > (new ::CIAO::Config_Handlers::Node (e)); + node_->container (this); + } + + else if (n == "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 (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 (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 (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 (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 (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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Domain::Type::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 + // + Bridge::Type::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 + // + Bridge::Type::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 + // + Bridge::Type::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 + // + Bridge::Type::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 + // + Interconnect::Type::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 + // + Interconnect::Type::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 + // + Interconnect::Type::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 + // + Interconnect::Type::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 + // + Interconnect::Type::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 + // + Interconnect::Type::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 + // + Node::Type::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 + // + Node::Type::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 + // + Node::Type::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 + // + Node::Type::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 + // + Node::Type::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 + // + Node::Type::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 > ("UUID", top_ ())); + Traversal::Domain::UUID (o); + pop_ (); + } + + void Domain:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("label", top_ ())); + Traversal::Domain::label (o); + pop_ (); + } + + void Domain:: + node_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("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 > ("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 > ("name", top_ ())); + Traversal::Bridge::name (o); + pop_ (); + } + + void Bridge:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("label", top_ ())); + Traversal::Bridge::label (o); + pop_ (); + } + + void Bridge:: + connect_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("name", top_ ())); + Traversal::Interconnect::name (o); + pop_ (); + } + + void Interconnect:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("label", top_ ())); + Traversal::Interconnect::label (o); + pop_ (); + } + + void Interconnect:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("name", top_ ())); + Traversal::Node::name (o); + pop_ (); + } + + void Node:: + label (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("label", top_ ())); + Traversal::Node::label (o); + pop_ (); + } + + void Node:: + connection_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("name", top_ ())); + Traversal::SharedResource::name (o); + pop_ (); + } + + void SharedResource:: + resourceType (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("resourceType", top_ ())); + Traversal::SharedResource::resourceType (o); + pop_ (); + } + + void SharedResource:: + node (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("node", top_ ())); + Traversal::SharedResource::node (o); + pop_ (); + } + + void SharedResource:: + property (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("property", top_ ())); + Traversal::SharedResource::property (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/cdd.hpp b/CIAO/tools/Config_Handlers/cdd.hpp new file mode 100644 index 00000000000..65c90942c53 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cdd.hpp @@ -0,0 +1,1729 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export Domain : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // 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< ::CIAO::Config_Handlers::Node >::iterator node_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Node >::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 (::CIAO::Config_Handlers::Node const& ); + size_t count_node (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Node > node_; + + // interconnect + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Interconnect >::iterator interconnect_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Interconnect >::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 (::CIAO::Config_Handlers::Interconnect const& ); + size_t count_interconnect (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Interconnect > interconnect_; + + // bridge + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Bridge >::iterator bridge_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Bridge >::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 (::CIAO::Config_Handlers::Bridge const& ); + size_t count_bridge (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Bridge > bridge_; + + // sharedResource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SharedResource >::iterator sharedResource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SharedResource >::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 (::CIAO::Config_Handlers::SharedResource const& ); + size_t count_sharedResource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SharedResource > sharedResource_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > infoProperty_; + + public: + Domain (); + + 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; + + // 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< ::CIAO::Config_Handlers::Interconnect >::iterator connect_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Interconnect >::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 (::CIAO::Config_Handlers::Interconnect const& ); + size_t count_connect (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Interconnect > connect_; + + // resource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::iterator resource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::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 (::CIAO::Config_Handlers::Resource const& ); + size_t count_resource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Resource > resource_; + + public: + Bridge (::XMLSchema::string< ACE_TCHAR > const& name__); + + 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; + + // 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< ::CIAO::Config_Handlers::Bridge >::iterator connection_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Bridge >::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 (::CIAO::Config_Handlers::Bridge const& ); + size_t count_connection (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Bridge > connection_; + + // connect + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Node >::iterator connect_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Node >::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 (::CIAO::Config_Handlers::Node const& ); + size_t count_connect (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Node > connect_; + + // resource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::iterator resource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::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 (::CIAO::Config_Handlers::Resource const& ); + size_t count_resource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Resource > resource_; + + public: + Interconnect (::XMLSchema::string< ACE_TCHAR > const& name__); + + 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; + + // 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< ::CIAO::Config_Handlers::Interconnect >::iterator connection_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Interconnect >::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 (::CIAO::Config_Handlers::Interconnect const& ); + size_t count_connection (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Interconnect > connection_; + + // sharedResource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SharedResource >::iterator sharedResource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SharedResource >::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 (::CIAO::Config_Handlers::SharedResource const& ); + size_t count_sharedResource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SharedResource > sharedResource_; + + // resource + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::iterator resource_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Resource >::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 (::CIAO::Config_Handlers::Resource const& ); + size_t count_resource (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Resource > 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; + + // 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/CIAO/tools/Config_Handlers/cdp.cpp b/CIAO/tools/Config_Handlers/cdp.cpp new file mode 100644 index 00000000000..642932e59e9 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cdp.cpp @@ -0,0 +1,1351 @@ +/* $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 + { + // DeploymentPlan + // + + DeploymentPlan:: + DeploymentPlan () + : + ::XSCRT::Type (), + regulator__ () + { + } + + DeploymentPlan:: + DeploymentPlan (::CIAO::Config_Handlers::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), + regulator__ () + { + if (label_.get ()) label_->container (this); + if (UUID_.get ()) UUID_->container (this); + if (realizes_.get ()) realizes_->container (this); + { + for (implementation_const_iterator i (s.implementation_.begin ());i != s.implementation_.end ();++i) add_implementation (*i); + } + + { + for (instance_const_iterator i (s.instance_.begin ());i != s.instance_.end ();++i) add_instance (*i); + } + + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + } + + ::CIAO::Config_Handlers::DeploymentPlan& DeploymentPlan:: + operator= (::CIAO::Config_Handlers::DeploymentPlan const& s) + { + 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.realizes_.get ()) realizes (*(s.realizes_)); + else realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (0); + + implementation_.clear (); + { + for (implementation_const_iterator i (s.implementation_.begin ());i != s.implementation_.end ();++i) add_implementation (*i); + } + + instance_.clear (); + { + for (instance_const_iterator i (s.instance_.begin ());i != s.instance_.end ();++i) add_instance (*i); + } + + connection_.clear (); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + dependsOn_.clear (); + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + artifact_.clear (); + { + for (artifact_const_iterator i (s.artifact_.begin ());i != s.artifact_.end ();++i) add_artifact (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + 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 (::CIAO::Config_Handlers::MonolithicDeploymentDescription 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 (::CIAO::Config_Handlers::InstanceDeploymentDescription 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 (::CIAO::Config_Handlers::PlanConnectionDescription const& e) + { + connection_.push_back (e); + } + + size_t DeploymentPlan:: + count_connection(void) const + { + return connection_.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 (::CIAO::Config_Handlers::ImplementationDependency 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 (::CIAO::Config_Handlers::ArtifactDeploymentDescription 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 (::CIAO::Config_Handlers::Property const& e) + { + infoProperty_.push_back (e); + } + + size_t DeploymentPlan:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // 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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "realizes") + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + realizes (t); + } + + else if (n == "implementation") + { + ::CIAO::Config_Handlers::MonolithicDeploymentDescription t (e); + add_implementation (t); + } + + else if (n == "instance") + { + ::CIAO::Config_Handlers::InstanceDeploymentDescription t (e); + add_instance (t); + } + + else if (n == "connection") + { + ::CIAO::Config_Handlers::PlanConnectionDescription t (e); + add_connection (t); + } + + else if (n == "dependsOn") + { + ::CIAO::Config_Handlers::ImplementationDependency t (e); + add_dependsOn (t); + } + + else if (n == "artifact") + { + ::CIAO::Config_Handlers::ArtifactDeploymentDescription t (e); + add_artifact (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_infoProperty (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 DeploymentPlanTypeInfoInitializer + { + DeploymentPlanTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (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 + { + // 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); + dependsOn (o); + artifact (o); + infoProperty (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); + dependsOn (o); + artifact (o); + infoProperty (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 + // + DeploymentPlan::Type::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); + } + } + + void DeploymentPlan:: + implementation (Type const& o) + { + // VC6 anathema strikes again + // + DeploymentPlan::Type::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); + } + } + + 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:: + instance (Type& o) + { + // VC6 anathema strikes again + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::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:: + dependsOn (Type& o) + { + // VC6 anathema strikes again + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::artifact_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + + else artifact_none (o); + } + + void DeploymentPlan:: + artifact (Type const& o) + { + // VC6 anathema strikes again + // + DeploymentPlan::Type::artifact_const_iterator b (o.begin_artifact()), e (o.end_artifact()); + + if (b != e) + { + artifact_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) artifact_next (o); + } + + artifact_post (o); + } + + 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 + // + DeploymentPlan::Type::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 + // + DeploymentPlan::Type::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:: + post (Type&) + { + } + + void DeploymentPlan:: + post (Type const&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // 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 > ("label", top_ ())); + Traversal::DeploymentPlan::label (o); + pop_ (); + } + + void DeploymentPlan:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::DeploymentPlan::UUID (o); + pop_ (); + } + + void DeploymentPlan:: + realizes (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("realizes", top_ ())); + Traversal::DeploymentPlan::realizes (o); + pop_ (); + } + + void DeploymentPlan:: + implementation_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("connection", top_ ())); + } + + void DeploymentPlan:: + connection_next (Type const& o) + { + connection_post (o); + connection_pre (o); + } + + void DeploymentPlan:: + connection_post (Type const&) + { + pop_ (); + } + + void DeploymentPlan:: + dependsOn_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("infoProperty", top_ ())); + } + + void DeploymentPlan:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void DeploymentPlan:: + infoProperty_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/cdp.hpp b/CIAO/tools/Config_Handlers/cdp.hpp new file mode 100644 index 00000000000..df7d0a36ad6 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cdp.hpp @@ -0,0 +1,700 @@ +/* $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 DeploymentPlan; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +#include "ccd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export DeploymentPlan : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // 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< ::CIAO::Config_Handlers::MonolithicDeploymentDescription >::iterator implementation_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::MonolithicDeploymentDescription >::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 (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& ); + size_t count_implementation (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::MonolithicDeploymentDescription > implementation_; + + // instance + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::InstanceDeploymentDescription >::iterator instance_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::InstanceDeploymentDescription >::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 (::CIAO::Config_Handlers::InstanceDeploymentDescription const& ); + size_t count_instance (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::InstanceDeploymentDescription > instance_; + + // connection + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PlanConnectionDescription >::iterator connection_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PlanConnectionDescription >::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 (::CIAO::Config_Handlers::PlanConnectionDescription const& ); + size_t count_connection (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PlanConnectionDescription > connection_; + + // dependsOn + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationDependency >::iterator dependsOn_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationDependency >::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 (::CIAO::Config_Handlers::ImplementationDependency const& ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ImplementationDependency > dependsOn_; + + // artifact + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ArtifactDeploymentDescription >::iterator artifact_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ArtifactDeploymentDescription >::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 (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& ); + size_t count_artifact (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ArtifactDeploymentDescription > artifact_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > infoProperty_; + + 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 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 + 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 + 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 + post (Type&); + + virtual void + post (Type const&); + }; + } + } +} + +#include "XMLSchema/Writer.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + 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 + 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&); + + protected: + DeploymentPlan (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CDP_HPP diff --git a/CIAO/tools/Config_Handlers/cid.cpp b/CIAO/tools/Config_Handlers/cid.cpp new file mode 100644 index 00000000000..be716f2b8dc --- /dev/null +++ b/CIAO/tools/Config_Handlers/cid.cpp @@ -0,0 +1,4130 @@ +/* $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 + { + // SubcomponentInstantiationDescription + // + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (::XMLSchema::string< ACE_TCHAR > const& name__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + regulator__ () + { + name_->container (this); + } + + SubcomponentInstantiationDescription:: + SubcomponentInstantiationDescription (::CIAO::Config_Handlers::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), + 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); + { + for (selectRequirement_const_iterator i (s.selectRequirement_.begin ());i != s.selectRequirement_.end ();++i) add_selectRequirement (*i); + } + + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + if (referencedPackage_.get ()) referencedPackage_->container (this); + if (importedPackage_.get ()) importedPackage_->container (this); + if (id_.get ()) id_->container (this); + } + + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription& SubcomponentInstantiationDescription:: + operator= (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& s) + { + name (s.name ()); + + if (s.basePackage_.get ()) basePackage (*(s.basePackage_)); + else basePackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > (0); + + if (s.specializedConfig_.get ()) specializedConfig (*(s.specializedConfig_)); + else specializedConfig_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > (0); + + selectRequirement_.clear (); + { + for (selectRequirement_const_iterator i (s.selectRequirement_.begin ());i != s.selectRequirement_.end ();++i) add_selectRequirement (*i); + } + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + if (s.referencedPackage_.get ()) referencedPackage (*(s.referencedPackage_)); + else referencedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (0); + + if (s.importedPackage_.get ()) importedPackage (*(s.importedPackage_)); + else importedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > (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 (::CIAO::Config_Handlers::Requirement 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 (::CIAO::Config_Handlers::Property 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__, + ::XMLSchema::IDREF< ACE_TCHAR > const& instance__) + : + ::XSCRT::Type (), + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (propertyName__)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (instance__)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + SubcomponentPropertyReference:: + SubcomponentPropertyReference (::CIAO::Config_Handlers::SubcomponentPropertyReference const& s) + : + ::XSCRT::Type (), + propertyName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.propertyName_)), + instance_ (new ::XMLSchema::IDREF< ACE_TCHAR > (*s.instance_)), + regulator__ () + { + propertyName_->container (this); + instance_->container (this); + } + + ::CIAO::Config_Handlers::SubcomponentPropertyReference& SubcomponentPropertyReference:: + operator= (::CIAO::Config_Handlers::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 + // + ::XMLSchema::IDREF< ACE_TCHAR > const& SubcomponentPropertyReference:: + instance () const + { + return *instance_; + } + + void SubcomponentPropertyReference:: + instance (::XMLSchema::IDREF< ACE_TCHAR > const& e) + { + *instance_ = e; + } + + + // AssemblyPropertyMapping + // + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (::XMLSchema::string< ACE_TCHAR > const& name__, + ::XMLSchema::string< ACE_TCHAR > const& externalName__) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (name__)), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (externalName__)), + regulator__ () + { + name_->container (this); + externalName_->container (this); + } + + AssemblyPropertyMapping:: + AssemblyPropertyMapping (::CIAO::Config_Handlers::AssemblyPropertyMapping const& s) + : + ::XSCRT::Type (), + name_ (new ::XMLSchema::string< ACE_TCHAR > (*s.name_)), + externalName_ (new ::XMLSchema::string< ACE_TCHAR > (*s.externalName_)), + regulator__ () + { + name_->container (this); + externalName_->container (this); + { + for (delegatesTo_const_iterator i (s.delegatesTo_.begin ());i != s.delegatesTo_.end ();++i) add_delegatesTo (*i); + } + } + + ::CIAO::Config_Handlers::AssemblyPropertyMapping& AssemblyPropertyMapping:: + operator= (::CIAO::Config_Handlers::AssemblyPropertyMapping const& s) + { + name (s.name ()); + + externalName (s.externalName ()); + + delegatesTo_.clear (); + { + for (delegatesTo_const_iterator i (s.delegatesTo_.begin ());i != s.delegatesTo_.end ();++i) add_delegatesTo (*i); + } + + 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 (::CIAO::Config_Handlers::SubcomponentPropertyReference const& e) + { + delegatesTo_.push_back (e); + } + + size_t AssemblyPropertyMapping:: + count_delegatesTo(void) const + { + return delegatesTo_.size (); + } + + + // ComponentAssemblyDescription + // + + ComponentAssemblyDescription:: + ComponentAssemblyDescription () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ComponentAssemblyDescription:: + ComponentAssemblyDescription (::CIAO::Config_Handlers::ComponentAssemblyDescription const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (instance_const_iterator i (s.instance_.begin ());i != s.instance_.end ();++i) add_instance (*i); + } + + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + { + for (externalProperty_const_iterator i (s.externalProperty_.begin ());i != s.externalProperty_.end ();++i) add_externalProperty (*i); + } + } + + ::CIAO::Config_Handlers::ComponentAssemblyDescription& ComponentAssemblyDescription:: + operator= (::CIAO::Config_Handlers::ComponentAssemblyDescription const& s) + { + instance_.clear (); + { + for (instance_const_iterator i (s.instance_.begin ());i != s.instance_.end ();++i) add_instance (*i); + } + + connection_.clear (); + { + for (connection_const_iterator i (s.connection_.begin ());i != s.connection_.end ();++i) add_connection (*i); + } + + externalProperty_.clear (); + { + for (externalProperty_const_iterator i (s.externalProperty_.begin ());i != s.externalProperty_.end ();++i) add_externalProperty (*i); + } + + 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 (::CIAO::Config_Handlers::SubcomponentInstantiationDescription 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 (::CIAO::Config_Handlers::AssemblyConnectionDescription 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 (::CIAO::Config_Handlers::AssemblyPropertyMapping const& e) + { + externalProperty_.push_back (e); + } + + size_t ComponentAssemblyDescription:: + count_externalProperty(void) const + { + return externalProperty_.size (); + } + + + // MonolithicImplementationDescription + // + + MonolithicImplementationDescription:: + MonolithicImplementationDescription () + : + ::XSCRT::Type (), + regulator__ () + { + } + + MonolithicImplementationDescription:: + MonolithicImplementationDescription (::CIAO::Config_Handlers::MonolithicImplementationDescription const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (nodeExecParameter_const_iterator i (s.nodeExecParameter_.begin ());i != s.nodeExecParameter_.end ();++i) add_nodeExecParameter (*i); + } + + { + for (componentExecParameter_const_iterator i (s.componentExecParameter_.begin ());i != s.componentExecParameter_.end ();++i) add_componentExecParameter (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + { + for (primaryArtifact_const_iterator i (s.primaryArtifact_.begin ());i != s.primaryArtifact_.end ();++i) add_primaryArtifact (*i); + } + } + + ::CIAO::Config_Handlers::MonolithicImplementationDescription& MonolithicImplementationDescription:: + operator= (::CIAO::Config_Handlers::MonolithicImplementationDescription const& s) + { + nodeExecParameter_.clear (); + { + for (nodeExecParameter_const_iterator i (s.nodeExecParameter_.begin ());i != s.nodeExecParameter_.end ();++i) add_nodeExecParameter (*i); + } + + componentExecParameter_.clear (); + { + for (componentExecParameter_const_iterator i (s.componentExecParameter_.begin ());i != s.componentExecParameter_.end ();++i) add_componentExecParameter (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + primaryArtifact_.clear (); + { + for (primaryArtifact_const_iterator i (s.primaryArtifact_.begin ());i != s.primaryArtifact_.end ();++i) add_primaryArtifact (*i); + } + + 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::ImplementationRequirement 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 (::CIAO::Config_Handlers::NamedImplementationArtifact const& e) + { + primaryArtifact_.push_back (e); + } + + size_t MonolithicImplementationDescription:: + count_primaryArtifact(void) const + { + return primaryArtifact_.size (); + } + + + // ComponentImplementationDescription + // + + ComponentImplementationDescription:: + ComponentImplementationDescription () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ComponentImplementationDescription:: + ComponentImplementationDescription (::CIAO::Config_Handlers::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), + 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 (implements_.get ()) implements_->container (this); + if (assemblyImpl_.get ()) assemblyImpl_->container (this); + if (monolithicImpl_.get ()) monolithicImpl_->container (this); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + { + for (capability_const_iterator i (s.capability_.begin ());i != s.capability_.end ();++i) add_capability (*i); + } + + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ::CIAO::Config_Handlers::ComponentImplementationDescription& ComponentImplementationDescription:: + operator= (::CIAO::Config_Handlers::ComponentImplementationDescription const& s) + { + 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.implements_.get ()) implements (*(s.implements_)); + else implements_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (0); + + if (s.assemblyImpl_.get ()) assemblyImpl (*(s.assemblyImpl_)); + else assemblyImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentAssemblyDescription > (0); + + if (s.monolithicImpl_.get ()) monolithicImpl (*(s.monolithicImpl_)); + else monolithicImpl_ = ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > (0); + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + capability_.clear (); + { + for (capability_const_iterator i (s.capability_.begin ());i != s.capability_.end ();++i) add_capability (*i); + } + + dependsOn_.clear (); + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_)); + else contentLocation_ = ::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); + + 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::Capability 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 (::CIAO::Config_Handlers::ImplementationDependency 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 (::CIAO::Config_Handlers::Property const& e) + { + infoProperty_.push_back (e); + } + + size_t ComponentImplementationDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ComponentImplementationDescription + // + bool ComponentImplementationDescription:: + contentLocation_p () const + { + return contentLocation_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentImplementationDescription:: + contentLocation () const + { + return *contentLocation_; + } + + void ComponentImplementationDescription:: + 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); + } + } + + // 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); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + // 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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "basePackage") + { + ::CIAO::Config_Handlers::ComponentPackageDescription t (e); + basePackage (t); + } + + else if (n == "specializedConfig") + { + ::CIAO::Config_Handlers::PackageConfiguration t (e); + specializedConfig (t); + } + + else if (n == "selectRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_selectRequirement (t); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "referencedPackage") + { + ::CIAO::Config_Handlers::ComponentPackageReference t (e); + referencedPackage (t); + } + + else if (n == "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 == "id") + { + ::XMLSchema::ID< ACE_TCHAR > t (a); + id (t); + } + + 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 == "propertyName") + { + propertyName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + propertyName_->container (this); + } + + else if (n == "instance") + { + instance_ = ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > (new ::XMLSchema::IDREF< ACE_TCHAR > (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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "externalName") + { + externalName_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + externalName_->container (this); + } + + else if (n == "delegatesTo") + { + ::CIAO::Config_Handlers::SubcomponentPropertyReference t (e); + add_delegatesTo (t); + } + + 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 == "instance") + { + ::CIAO::Config_Handlers::SubcomponentInstantiationDescription t (e); + add_instance (t); + } + + else if (n == "connection") + { + ::CIAO::Config_Handlers::AssemblyConnectionDescription t (e); + add_connection (t); + } + + else if (n == "externalProperty") + { + ::CIAO::Config_Handlers::AssemblyPropertyMapping t (e); + add_externalProperty (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 == "nodeExecParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_nodeExecParameter (t); + } + + else if (n == "componentExecParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_componentExecParameter (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::ImplementationRequirement t (e); + add_deployRequirement (t); + } + + else if (n == "primaryArtifact") + { + ::CIAO::Config_Handlers::NamedImplementationArtifact t (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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "implements") + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + implements (t); + } + + else if (n == "assemblyImpl") + { + ::CIAO::Config_Handlers::ComponentAssemblyDescription t (e); + assemblyImpl (t); + } + + else if (n == "monolithicImpl") + { + ::CIAO::Config_Handlers::MonolithicImplementationDescription t (e); + monolithicImpl (t); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "capability") + { + ::CIAO::Config_Handlers::Capability t (e); + add_capability (t); + } + + else if (n == "dependsOn") + { + ::CIAO::Config_Handlers::ImplementationDependency t (e); + add_dependsOn (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_infoProperty (t); + } + + else if (n == "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 == "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 SubcomponentInstantiationDescriptionTypeInfoInitializer + { + SubcomponentInstantiationDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (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 (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 (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 ComponentAssemblyDescriptionTypeInfoInitializer + { + ComponentAssemblyDescriptionTypeInfoInitializer () + { + ::XSCRT::TypeId id (typeid (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 (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 (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_; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Traversal + { + // 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 + // + SubcomponentInstantiationDescription::Type::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 + // + SubcomponentInstantiationDescription::Type::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 + // + SubcomponentInstantiationDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void SubcomponentInstantiationDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + SubcomponentInstantiationDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void 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 + // + AssemblyPropertyMapping::Type::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 AssemblyPropertyMapping:: + delegatesTo (Type const& o) + { + // VC6 anathema strikes again + // + AssemblyPropertyMapping::Type::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 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:: + post (Type&) + { + } + + void AssemblyPropertyMapping:: + post (Type const&) + { + } + + // ComponentAssemblyDescription + // + // + + void ComponentAssemblyDescription:: + traverse (Type& o) + { + pre (o); + instance (o); + connection (o); + externalProperty (o); + post (o); + } + + void ComponentAssemblyDescription:: + traverse (Type const& o) + { + pre (o); + instance (o); + connection (o); + externalProperty (o); + post (o); + } + + void ComponentAssemblyDescription:: + pre (Type&) + { + } + + void ComponentAssemblyDescription:: + pre (Type const&) + { + } + + void ComponentAssemblyDescription:: + instance (Type& o) + { + // VC6 anathema strikes again + // + ComponentAssemblyDescription::Type::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); + } + } + + void ComponentAssemblyDescription:: + instance (Type const& o) + { + // VC6 anathema strikes again + // + ComponentAssemblyDescription::Type::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); + } + } + + 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:: + connection (Type& o) + { + // VC6 anathema strikes again + // + ComponentAssemblyDescription::Type::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 + // + ComponentAssemblyDescription::Type::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 + // + ComponentAssemblyDescription::Type::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 + // + ComponentAssemblyDescription::Type::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:: + 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 + // + MonolithicImplementationDescription::Type::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 + // + MonolithicImplementationDescription::Type::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 + // + MonolithicImplementationDescription::Type::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 + // + MonolithicImplementationDescription::Type::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 + // + MonolithicImplementationDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void MonolithicImplementationDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicImplementationDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void 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 + // + MonolithicImplementationDescription::Type::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); + } + } + + void MonolithicImplementationDescription:: + primaryArtifact (Type const& o) + { + // VC6 anathema strikes again + // + MonolithicImplementationDescription::Type::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); + } + } + + 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:: + 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.contentLocation_p ()) contentLocation (o); + else contentLocation_none (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.contentLocation_p ()) contentLocation (o); + else contentLocation_none (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 + // + ComponentImplementationDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void ComponentImplementationDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ComponentImplementationDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void 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 + // + ComponentImplementationDescription::Type::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 + // + ComponentImplementationDescription::Type::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 + // + ComponentImplementationDescription::Type::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 + // + ComponentImplementationDescription::Type::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 + // + ComponentImplementationDescription::Type::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 + // + ComponentImplementationDescription::Type::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:: + contentLocation (Type& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentImplementationDescription:: + contentLocation (Type const& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentImplementationDescription:: + contentLocation_none (Type&) + { + } + + void ComponentImplementationDescription:: + contentLocation_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&) + { + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Writer + { + // 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 > ("name", top_ ())); + Traversal::SubcomponentInstantiationDescription::name (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + basePackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("basePackage", top_ ())); + Traversal::SubcomponentInstantiationDescription::basePackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + specializedConfig (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("specializedConfig", top_ ())); + Traversal::SubcomponentInstantiationDescription::specializedConfig (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + selectRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("referencedPackage", top_ ())); + Traversal::SubcomponentInstantiationDescription::referencedPackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + importedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("importedPackage", top_ ())); + Traversal::SubcomponentInstantiationDescription::importedPackage (o); + pop_ (); + } + + void SubcomponentInstantiationDescription:: + id (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("id", "", 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 > ("propertyName", top_ ())); + Traversal::SubcomponentPropertyReference::propertyName (o); + pop_ (); + } + + void SubcomponentPropertyReference:: + instance (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("name", top_ ())); + Traversal::AssemblyPropertyMapping::name (o); + pop_ (); + } + + void AssemblyPropertyMapping:: + externalName (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("externalName", top_ ())); + Traversal::AssemblyPropertyMapping::externalName (o); + pop_ (); + } + + void AssemblyPropertyMapping:: + delegatesTo_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("delegatesTo", top_ ())); + } + + void AssemblyPropertyMapping:: + delegatesTo_next (Type const& o) + { + delegatesTo_post (o); + delegatesTo_pre (o); + } + + void AssemblyPropertyMapping:: + delegatesTo_post (Type const&) + { + 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 > ("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 > ("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 > ("externalProperty", top_ ())); + } + + void ComponentAssemblyDescription:: + externalProperty_next (Type const& o) + { + externalProperty_post (o); + externalProperty_pre (o); + } + + void ComponentAssemblyDescription:: + externalProperty_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 > ("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 > ("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 > ("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 > ("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 > ("label", top_ ())); + Traversal::ComponentImplementationDescription::label (o); + pop_ (); + } + + void ComponentImplementationDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::ComponentImplementationDescription::UUID (o); + pop_ (); + } + + void ComponentImplementationDescription:: + implements (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("implements", top_ ())); + Traversal::ComponentImplementationDescription::implements (o); + pop_ (); + } + + void ComponentImplementationDescription:: + assemblyImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("assemblyImpl", top_ ())); + Traversal::ComponentImplementationDescription::assemblyImpl (o); + pop_ (); + } + + void ComponentImplementationDescription:: + monolithicImpl (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("monolithicImpl", top_ ())); + Traversal::ComponentImplementationDescription::monolithicImpl (o); + pop_ (); + } + + void ComponentImplementationDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("infoProperty", top_ ())); + } + + void ComponentImplementationDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ComponentImplementationDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ComponentImplementationDescription:: + contentLocation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("contentLocation", top_ ())); + Traversal::ComponentImplementationDescription::contentLocation (o); + pop_ (); + } + + void ComponentImplementationDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("href", "", top_ ()); + attr_ (&a); + Traversal::ComponentImplementationDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/cid.hpp b/CIAO/tools/Config_Handlers/cid.hpp new file mode 100644 index 00000000000..c0b74ebc810 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cid.hpp @@ -0,0 +1,2054 @@ +/* $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 SubcomponentInstantiationDescription; + class SubcomponentPropertyReference; + class AssemblyPropertyMapping; + class ComponentAssemblyDescription; + class MonolithicImplementationDescription; + class ComponentImplementationDescription; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +#include "Basic_Deployment_Data.hpp" + +#include "ccd.hpp" + +#include "iad.hpp" + +#include "pcd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export SubcomponentInstantiationDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // 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< ::CIAO::Config_Handlers::Requirement >::iterator selectRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_selectRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > selectRequirement_; + + // configProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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; + + // 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: + ::XMLSchema::IDREF< ACE_TCHAR > const& instance () const; + void instance (::XMLSchema::IDREF< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::IDREF< ACE_TCHAR > > instance_; + + public: + SubcomponentPropertyReference (::XMLSchema::string< ACE_TCHAR > const& propertyName__, + ::XMLSchema::IDREF< ACE_TCHAR > 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; + + // 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< ::CIAO::Config_Handlers::SubcomponentPropertyReference >::iterator delegatesTo_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SubcomponentPropertyReference >::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 (::CIAO::Config_Handlers::SubcomponentPropertyReference const& ); + size_t count_delegatesTo (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SubcomponentPropertyReference > 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 ComponentAssemblyDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // instance + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription >::iterator instance_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription >::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 (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& ); + size_t count_instance (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription > instance_; + + // connection + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::AssemblyConnectionDescription >::iterator connection_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::AssemblyConnectionDescription >::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 (::CIAO::Config_Handlers::AssemblyConnectionDescription const& ); + size_t count_connection (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::AssemblyConnectionDescription > connection_; + + // externalProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::AssemblyPropertyMapping >::iterator externalProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::AssemblyPropertyMapping >::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 (::CIAO::Config_Handlers::AssemblyPropertyMapping const& ); + size_t count_externalProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::AssemblyPropertyMapping > externalProperty_; + + 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; + + // nodeExecParameter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator nodeExecParameter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_nodeExecParameter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > nodeExecParameter_; + + // componentExecParameter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator componentExecParameter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_componentExecParameter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > componentExecParameter_; + + // deployRequirement + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationRequirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationRequirement >::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 (::CIAO::Config_Handlers::ImplementationRequirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ImplementationRequirement > deployRequirement_; + + // primaryArtifact + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact >::iterator primaryArtifact_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact >::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 (::CIAO::Config_Handlers::NamedImplementationArtifact const& ); + size_t count_primaryArtifact (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact > 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > configProperty_; + + // capability + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Capability >::iterator capability_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Capability >::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 (::CIAO::Config_Handlers::Capability const& ); + size_t count_capability (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Capability > capability_; + + // dependsOn + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationDependency >::iterator dependsOn_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::ImplementationDependency >::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 (::CIAO::Config_Handlers::ImplementationDependency const& ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::ImplementationDependency > dependsOn_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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: + ComponentImplementationDescription (); + + ComponentImplementationDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentImplementationDescription (ComponentImplementationDescription const& s); + + ComponentImplementationDescription& + operator= (ComponentImplementationDescription 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 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 + 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 + 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 + 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 + 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 + 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 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 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&); + + 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 + 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: + ComponentImplementationDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CID_HPP diff --git a/CIAO/tools/Config_Handlers/cpd.cpp b/CIAO/tools/Config_Handlers/cpd.cpp new file mode 100644 index 00000000000..c59e5e18fef --- /dev/null +++ b/CIAO/tools/Config_Handlers/cpd.cpp @@ -0,0 +1,1274 @@ +/* $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 (::CIAO::Config_Handlers::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); + } + + ::CIAO::Config_Handlers::PackagedComponentImplementation& PackagedComponentImplementation:: + operator= (::CIAO::Config_Handlers::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 () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ComponentPackageDescription:: + ComponentPackageDescription (::CIAO::Config_Handlers::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), + 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 (realizes_.get ()) realizes_->container (this); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + { + for (implementation_const_iterator i (s.implementation_.begin ());i != s.implementation_.end ();++i) add_implementation (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ::CIAO::Config_Handlers::ComponentPackageDescription& ComponentPackageDescription:: + operator= (::CIAO::Config_Handlers::ComponentPackageDescription const& s) + { + 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.realizes_.get ()) realizes (*(s.realizes_)); + else realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (0); + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + implementation_.clear (); + { + for (implementation_const_iterator i (s.implementation_.begin ());i != s.implementation_.end ();++i) add_implementation (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_)); + else contentLocation_ = ::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); + + 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::PackagedComponentImplementation 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 (::CIAO::Config_Handlers::Property const& e) + { + infoProperty_.push_back (e); + } + + size_t ComponentPackageDescription:: + count_infoProperty(void) const + { + return infoProperty_.size (); + } + + // ComponentPackageDescription + // + bool ComponentPackageDescription:: + contentLocation_p () const + { + return contentLocation_.get () != 0; + } + + ::XMLSchema::string< ACE_TCHAR > const& ComponentPackageDescription:: + contentLocation () const + { + return *contentLocation_; + } + + void ComponentPackageDescription:: + 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); + } + } + + // 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); + } + } + } +} + +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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "realizes") + { + ::CIAO::Config_Handlers::ComponentInterfaceDescription t (e); + realizes (t); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "implementation") + { + ::CIAO::Config_Handlers::PackagedComponentImplementation t (e); + add_implementation (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_infoProperty (t); + } + + else if (n == "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 == "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 (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 (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_; + } + } +} + +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.contentLocation_p ()) contentLocation (o); + else contentLocation_none (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.contentLocation_p ()) contentLocation (o); + else contentLocation_none (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 + // + ComponentPackageDescription::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void ComponentPackageDescription:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + ComponentPackageDescription::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void 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 + // + ComponentPackageDescription::Type::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 + // + ComponentPackageDescription::Type::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 + // + ComponentPackageDescription::Type::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 + // + ComponentPackageDescription::Type::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:: + contentLocation (Type& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentPackageDescription:: + contentLocation (Type const& o) + { + dispatch (o.contentLocation ()); + } + + void ComponentPackageDescription:: + contentLocation_none (Type&) + { + } + + void ComponentPackageDescription:: + contentLocation_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&) + { + } + } + } +} + +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 > ("name", top_ ())); + Traversal::PackagedComponentImplementation::name (o); + pop_ (); + } + + void PackagedComponentImplementation:: + referencedImplementation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("label", top_ ())); + Traversal::ComponentPackageDescription::label (o); + pop_ (); + } + + void ComponentPackageDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::ComponentPackageDescription::UUID (o); + pop_ (); + } + + void ComponentPackageDescription:: + realizes (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("realizes", top_ ())); + Traversal::ComponentPackageDescription::realizes (o); + pop_ (); + } + + void ComponentPackageDescription:: + configProperty_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("infoProperty", top_ ())); + } + + void ComponentPackageDescription:: + infoProperty_next (Type const& o) + { + infoProperty_post (o); + infoProperty_pre (o); + } + + void ComponentPackageDescription:: + infoProperty_post (Type const&) + { + pop_ (); + } + + void ComponentPackageDescription:: + contentLocation (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("contentLocation", top_ ())); + Traversal::ComponentPackageDescription::contentLocation (o); + pop_ (); + } + + void ComponentPackageDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("href", "", top_ ()); + attr_ (&a); + Traversal::ComponentPackageDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/cpd.hpp b/CIAO/tools/Config_Handlers/cpd.hpp new file mode 100644 index 00000000000..301c15ec126 --- /dev/null +++ b/CIAO/tools/Config_Handlers/cpd.hpp @@ -0,0 +1,653 @@ +/* $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; + } +} + +#include <memory> +#include <list> +#include "XMLSchema/Types.hpp" + +#include "cid.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export PackagedComponentImplementation : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // 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; + + // 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< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > configProperty_; + + // implementation + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PackagedComponentImplementation >::iterator implementation_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PackagedComponentImplementation >::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 (::CIAO::Config_Handlers::PackagedComponentImplementation const& ); + size_t count_implementation (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PackagedComponentImplementation > implementation_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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: + ComponentPackageDescription (); + + ComponentPackageDescription (::XSCRT::XML::Element< ACE_TCHAR > const&); + ComponentPackageDescription (ComponentPackageDescription const& s); + + ComponentPackageDescription& + operator= (ComponentPackageDescription 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 + 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 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 + 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: + ComponentPackageDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // CPD_HPP diff --git a/CIAO/tools/Config_Handlers/iad.cpp b/CIAO/tools/Config_Handlers/iad.cpp new file mode 100644 index 00000000000..e05cc1272b1 --- /dev/null +++ b/CIAO/tools/Config_Handlers/iad.cpp @@ -0,0 +1,1516 @@ +/* $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 (::CIAO::Config_Handlers::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); + } + + ::CIAO::Config_Handlers::NamedImplementationArtifact& NamedImplementationArtifact:: + operator= (::CIAO::Config_Handlers::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 () + : + ::XSCRT::Type (), + regulator__ () + { + } + + ImplementationArtifactDescription:: + ImplementationArtifactDescription (::CIAO::Config_Handlers::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), + 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); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (contentLocation_.get ()) contentLocation_->container (this); + if (href_.get ()) href_->container (this); + } + + ::CIAO::Config_Handlers::ImplementationArtifactDescription& ImplementationArtifactDescription:: + operator= (::CIAO::Config_Handlers::ImplementationArtifactDescription const& s) + { + 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); + + location_.clear (); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + dependsOn_.clear (); + { + for (dependsOn_const_iterator i (s.dependsOn_.begin ());i != s.dependsOn_.end ();++i) add_dependsOn (*i); + } + + execParameter_.clear (); + { + for (execParameter_const_iterator i (s.execParameter_.begin ());i != s.execParameter_.end ();++i) add_execParameter (*i); + } + + infoProperty_.clear (); + { + for (infoProperty_const_iterator i (s.infoProperty_.begin ());i != s.infoProperty_.end ();++i) add_infoProperty (*i); + } + + deployRequirement_.clear (); + { + for (deployRequirement_const_iterator i (s.deployRequirement_.begin ());i != s.deployRequirement_.end ();++i) add_deployRequirement (*i); + } + + if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_)); + else contentLocation_ = ::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); + + 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 (::XMLSchema::string< ACE_TCHAR > 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 (::CIAO::Config_Handlers::NamedImplementationArtifact 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::Property 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 (::CIAO::Config_Handlers::Requirement 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 == "name") + { + name_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (new ::XMLSchema::string< ACE_TCHAR > (e)); + name_->container (this); + } + + else if (n == "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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "location") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + add_location (t); + } + + else if (n == "dependsOn") + { + ::CIAO::Config_Handlers::NamedImplementationArtifact t (e); + add_dependsOn (t); + } + + else if (n == "execParameter") + { + ::CIAO::Config_Handlers::Property t (e); + add_execParameter (t); + } + + else if (n == "infoProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_infoProperty (t); + } + + else if (n == "deployRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_deployRequirement (t); + } + + else if (n == "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 == "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 (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 (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 + // + ImplementationArtifactDescription::Type::location_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + + else location_none (o); + } + + void ImplementationArtifactDescription:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ImplementationArtifactDescription::Type::location_const_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + + 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 + // + ImplementationArtifactDescription::Type::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 + // + ImplementationArtifactDescription::Type::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 + // + ImplementationArtifactDescription::Type::execParameter_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void ImplementationArtifactDescription:: + execParameter (Type const& o) + { + // VC6 anathema strikes again + // + ImplementationArtifactDescription::Type::execParameter_const_iterator b (o.begin_execParameter()), e (o.end_execParameter()); + + if (b != e) + { + execParameter_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) execParameter_next (o); + } + + execParameter_post (o); + } + + else execParameter_none (o); + } + + void 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 + // + ImplementationArtifactDescription::Type::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 + // + ImplementationArtifactDescription::Type::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 + // + ImplementationArtifactDescription::Type::deployRequirement_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void ImplementationArtifactDescription:: + deployRequirement (Type const& o) + { + // VC6 anathema strikes again + // + ImplementationArtifactDescription::Type::deployRequirement_const_iterator b (o.begin_deployRequirement()), e (o.end_deployRequirement()); + + if (b != e) + { + deployRequirement_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) deployRequirement_next (o); + } + + deployRequirement_post (o); + } + + else deployRequirement_none (o); + } + + void 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 > ("name", top_ ())); + Traversal::NamedImplementationArtifact::name (o); + pop_ (); + } + + void NamedImplementationArtifact:: + referencedArtifact (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("label", top_ ())); + Traversal::ImplementationArtifactDescription::label (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::ImplementationArtifactDescription::UUID (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + location_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("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 > ("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 > ("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 > ("contentLocation", top_ ())); + Traversal::ImplementationArtifactDescription::contentLocation (o); + pop_ (); + } + + void ImplementationArtifactDescription:: + href (Type const& o) + { + ::XSCRT::XML::Attribute< ACE_TCHAR > a ("href", "", top_ ()); + attr_ (&a); + Traversal::ImplementationArtifactDescription::href (o); + attr_ (0); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/iad.hpp b/CIAO/tools/Config_Handlers/iad.hpp new file mode 100644 index 00000000000..85366d71951 --- /dev/null +++ b/CIAO/tools/Config_Handlers/iad.hpp @@ -0,0 +1,776 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#include "Basic_Deployment_Data.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export NamedImplementationArtifact : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // name + // + public: + ::XMLSchema::string< ACE_TCHAR > const& name () const; + void name (::XMLSchema::string< ACE_TCHAR > const& ); + + protected: + ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > name_; + + // 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; + + // 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< ::XMLSchema::string< ACE_TCHAR > >::iterator location_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_location (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > location_; + + // dependsOn + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact >::iterator dependsOn_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact >::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 (::CIAO::Config_Handlers::NamedImplementationArtifact const& ); + size_t count_dependsOn (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::NamedImplementationArtifact > dependsOn_; + + // execParameter + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator execParameter_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_execParameter (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > execParameter_; + + // infoProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_infoProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > infoProperty_; + + // deployRequirement + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::iterator deployRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_deployRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > 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/CIAO/tools/Config_Handlers/pcd.cpp b/CIAO/tools/Config_Handlers/pcd.cpp new file mode 100644 index 00000000000..b74723f1265 --- /dev/null +++ b/CIAO/tools/Config_Handlers/pcd.cpp @@ -0,0 +1,1294 @@ +/* $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 (::CIAO::Config_Handlers::ComponentPackageImport const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + } + + ::CIAO::Config_Handlers::ComponentPackageImport& ComponentPackageImport:: + operator= (::CIAO::Config_Handlers::ComponentPackageImport const& s) + { + location_.clear (); + { + for (location_const_iterator i (s.location_.begin ());i != s.location_.end ();++i) add_location (*i); + } + + 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 (::XMLSchema::string< ACE_TCHAR > const& e) + { + location_.push_back (e); + } + + size_t ComponentPackageImport:: + count_location(void) const + { + return location_.size (); + } + + + // PackageConfiguration + // + + PackageConfiguration:: + PackageConfiguration () + : + ::XSCRT::Type (), + regulator__ () + { + } + + PackageConfiguration:: + PackageConfiguration (::CIAO::Config_Handlers::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), + 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); + { + for (selectRequirement_const_iterator i (s.selectRequirement_.begin ());i != s.selectRequirement_.end ();++i) add_selectRequirement (*i); + } + + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + if (contentLocation_.get ()) contentLocation_->container (this); + } + + ::CIAO::Config_Handlers::PackageConfiguration& PackageConfiguration:: + operator= (::CIAO::Config_Handlers::PackageConfiguration const& s) + { + 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.basePackage_.get ()) basePackage (*(s.basePackage_)); + else basePackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > (0); + + if (s.specializedConfig_.get ()) specializedConfig (*(s.specializedConfig_)); + else specializedConfig_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackageConfiguration > (0); + + if (s.importedPackage_.get ()) importedPackage (*(s.importedPackage_)); + else importedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageImport > (0); + + if (s.referencedPackage_.get ()) referencedPackage (*(s.referencedPackage_)); + else referencedPackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (0); + + selectRequirement_.clear (); + { + for (selectRequirement_const_iterator i (s.selectRequirement_.begin ());i != s.selectRequirement_.end ();++i) add_selectRequirement (*i); + } + + configProperty_.clear (); + { + for (configProperty_const_iterator i (s.configProperty_.begin ());i != s.configProperty_.end ();++i) add_configProperty (*i); + } + + if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_)); + else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< ACE_TCHAR > > (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 (::CIAO::Config_Handlers::Requirement 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 (::CIAO::Config_Handlers::Property 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 == "location") + { + ::XMLSchema::string< ACE_TCHAR > t (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 == "label") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + label (t); + } + + else if (n == "UUID") + { + ::XMLSchema::string< ACE_TCHAR > t (e); + UUID (t); + } + + else if (n == "basePackage") + { + ::CIAO::Config_Handlers::ComponentPackageDescription t (e); + basePackage (t); + } + + else if (n == "specializedConfig") + { + ::CIAO::Config_Handlers::PackageConfiguration t (e); + specializedConfig (t); + } + + else if (n == "importedPackage") + { + ::CIAO::Config_Handlers::ComponentPackageImport t (e); + importedPackage (t); + } + + else if (n == "referencedPackage") + { + ::CIAO::Config_Handlers::ComponentPackageReference t (e); + referencedPackage (t); + } + + else if (n == "selectRequirement") + { + ::CIAO::Config_Handlers::Requirement t (e); + add_selectRequirement (t); + } + + else if (n == "configProperty") + { + ::CIAO::Config_Handlers::Property t (e); + add_configProperty (t); + } + + else if (n == "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 (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 (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 + // + ComponentPackageImport::Type::location_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void ComponentPackageImport:: + location (Type const& o) + { + // VC6 anathema strikes again + // + ComponentPackageImport::Type::location_const_iterator b (o.begin_location()), e (o.end_location()); + + if (b != e) + { + location_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) location_next (o); + } + + location_post (o); + } + } + + void 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:: + 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 + // + PackageConfiguration::Type::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 + // + PackageConfiguration::Type::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 + // + PackageConfiguration::Type::configProperty_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void PackageConfiguration:: + configProperty (Type const& o) + { + // VC6 anathema strikes again + // + PackageConfiguration::Type::configProperty_const_iterator b (o.begin_configProperty()), e (o.end_configProperty()); + + if (b != e) + { + configProperty_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) configProperty_next (o); + } + + configProperty_post (o); + } + + else configProperty_none (o); + } + + void 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 > ("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 > ("label", top_ ())); + Traversal::PackageConfiguration::label (o); + pop_ (); + } + + void PackageConfiguration:: + UUID (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("UUID", top_ ())); + Traversal::PackageConfiguration::UUID (o); + pop_ (); + } + + void PackageConfiguration:: + basePackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("basePackage", top_ ())); + Traversal::PackageConfiguration::basePackage (o); + pop_ (); + } + + void PackageConfiguration:: + specializedConfig (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("specializedConfig", top_ ())); + Traversal::PackageConfiguration::specializedConfig (o); + pop_ (); + } + + void PackageConfiguration:: + importedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("importedPackage", top_ ())); + Traversal::PackageConfiguration::importedPackage (o); + pop_ (); + } + + void PackageConfiguration:: + referencedPackage (Type const& o) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("referencedPackage", top_ ())); + Traversal::PackageConfiguration::referencedPackage (o); + pop_ (); + } + + void PackageConfiguration:: + selectRequirement_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("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 > ("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 > ("contentLocation", top_ ())); + Traversal::PackageConfiguration::contentLocation (o); + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/pcd.hpp b/CIAO/tools/Config_Handlers/pcd.hpp new file mode 100644 index 00000000000..d18119a5fc4 --- /dev/null +++ b/CIAO/tools/Config_Handlers/pcd.hpp @@ -0,0 +1,661 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#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; + + // location + // + public: + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::iterator location_iterator; + typedef ::std::list< ::XMLSchema::string< ACE_TCHAR > >::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 (::XMLSchema::string< ACE_TCHAR > const& ); + size_t count_location (void) const; + + protected: + ::std::list< ::XMLSchema::string< ACE_TCHAR > > 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; + + // 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< ::CIAO::Config_Handlers::Requirement >::iterator selectRequirement_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Requirement >::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 (::CIAO::Config_Handlers::Requirement const& ); + size_t count_selectRequirement (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Requirement > selectRequirement_; + + // configProperty + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::Property >::iterator configProperty_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::Property >::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 (::CIAO::Config_Handlers::Property const& ); + size_t count_configProperty (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::Property > 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 + 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/CIAO/tools/Config_Handlers/test.cdp b/CIAO/tools/Config_Handlers/test.cdp new file mode 100644 index 00000000000..2430859601b --- /dev/null +++ b/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/CIAO/tools/Config_Handlers/test.cpp b/CIAO/tools/Config_Handlers/test.cpp new file mode 100644 index 00000000000..88a7d8f2a24 --- /dev/null +++ b/CIAO/tools/Config_Handlers/test.cpp @@ -0,0 +1,120 @@ +// $Id$ + +#include <iostream> + +#include "Deployment.hpp" +#include "DP_Handler.h" +#include "DAnCE/Deployment/Deployment_DataC.h" +#include "DAnCE/Deployment/CIAO_ServerResourcesC.h" +#include "ace/Get_Opt.h" +#include "Utils/XML_Helper.h" +#include "DnC_Dump.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 main (int argc, char *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 + XML_Helper the_helper; + + if (xercesc::DOMDocument *doc = the_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 (the_helper.create_dom(0)); + + //Serialize the XSC into a DOMDocument + deploymentPlan(*reverse_handler.xsc(), the_xsc); + + + //Write it to test.xml + the_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/CIAO/tools/Config_Handlers/toplevel.cpp b/CIAO/tools/Config_Handlers/toplevel.cpp new file mode 100644 index 00000000000..4a06443d8fb --- /dev/null +++ b/CIAO/tools/Config_Handlers/toplevel.cpp @@ -0,0 +1,339 @@ +/* $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 (::CIAO::Config_Handlers::TopLevelPackageDescription const& s) + : + ::XSCRT::Type (), + regulator__ () + { + { + for (basePackage_const_iterator i (s.basePackage_.begin ());i != s.basePackage_.end ();++i) add_basePackage (*i); + } + } + + ::CIAO::Config_Handlers::TopLevelPackageDescription& TopLevelPackageDescription:: + operator= (::CIAO::Config_Handlers::TopLevelPackageDescription const& s) + { + basePackage_.clear (); + { + for (basePackage_const_iterator i (s.basePackage_.begin ());i != s.basePackage_.end ();++i) add_basePackage (*i); + } + + return *this; + } + + + // TopLevelPackageDescription + // + TopLevelPackageDescription::basePackage_iterator TopLevelPackageDescription:: + begin_basePackage () + { + return basePackage_.begin (); + } + + TopLevelPackageDescription::basePackage_iterator TopLevelPackageDescription:: + end_basePackage () + { + return basePackage_.end (); + } + + TopLevelPackageDescription::basePackage_const_iterator TopLevelPackageDescription:: + begin_basePackage () const + { + return basePackage_.begin (); + } + + TopLevelPackageDescription::basePackage_const_iterator TopLevelPackageDescription:: + end_basePackage () const + { + return basePackage_.end (); + } + + void TopLevelPackageDescription:: + add_basePackage (::CIAO::Config_Handlers::PackageConfiguration const& e) + { + basePackage_.push_back (e); + } + + size_t TopLevelPackageDescription:: + count_basePackage(void) const + { + return basePackage_.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 == "basePackage") + { + ::CIAO::Config_Handlers::PackageConfiguration t (e); + add_basePackage (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 (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); + basePackage (o); + post (o); + } + + void TopLevelPackageDescription:: + traverse (Type const& o) + { + pre (o); + basePackage (o); + post (o); + } + + void TopLevelPackageDescription:: + pre (Type&) + { + } + + void TopLevelPackageDescription:: + pre (Type const&) + { + } + + void TopLevelPackageDescription:: + basePackage (Type& o) + { + // VC6 anathema strikes again + // + TopLevelPackageDescription::Type::basePackage_iterator b (o.begin_basePackage()), e (o.end_basePackage()); + + if (b != e) + { + basePackage_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) basePackage_next (o); + } + + basePackage_post (o); + } + } + + void TopLevelPackageDescription:: + basePackage (Type const& o) + { + // VC6 anathema strikes again + // + TopLevelPackageDescription::Type::basePackage_const_iterator b (o.begin_basePackage()), e (o.end_basePackage()); + + if (b != e) + { + basePackage_pre (o); + for (; b != e;) + { + dispatch (*b); + if (++b != e) basePackage_next (o); + } + + basePackage_post (o); + } + } + + void TopLevelPackageDescription:: + basePackage_pre (Type&) + { + } + + void TopLevelPackageDescription:: + basePackage_pre (Type const&) + { + } + + void TopLevelPackageDescription:: + basePackage_next (Type&) + { + } + + void TopLevelPackageDescription:: + basePackage_next (Type const&) + { + } + + void TopLevelPackageDescription:: + basePackage_post (Type&) + { + } + + void TopLevelPackageDescription:: + basePackage_post (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:: + basePackage_pre (Type const&) + { + push_ (::XSCRT::XML::Element< ACE_TCHAR > ("basePackage", top_ ())); + } + + void TopLevelPackageDescription:: + basePackage_next (Type const& o) + { + basePackage_post (o); + basePackage_pre (o); + } + + void TopLevelPackageDescription:: + basePackage_post (Type const&) + { + pop_ (); + } + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + diff --git a/CIAO/tools/Config_Handlers/toplevel.hpp b/CIAO/tools/Config_Handlers/toplevel.hpp new file mode 100644 index 00000000000..468b927cc59 --- /dev/null +++ b/CIAO/tools/Config_Handlers/toplevel.hpp @@ -0,0 +1,211 @@ +/* $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 <list> +#include "XMLSchema/Types.hpp" + +#include "pcd.hpp" + +namespace CIAO +{ + namespace Config_Handlers + { + class XSC_XML_Handlers_Export TopLevelPackageDescription : public ::XSCRT::Type + { + typedef ::XSCRT::Type Base; + + // basePackage + // + public: + typedef ::std::list< ::CIAO::Config_Handlers::PackageConfiguration >::iterator basePackage_iterator; + typedef ::std::list< ::CIAO::Config_Handlers::PackageConfiguration >::const_iterator basePackage_const_iterator; + basePackage_iterator begin_basePackage (); + basePackage_iterator end_basePackage (); + basePackage_const_iterator begin_basePackage () const; + basePackage_const_iterator end_basePackage () const; + void add_basePackage (::CIAO::Config_Handlers::PackageConfiguration const& ); + size_t count_basePackage (void) const; + + protected: + ::std::list< ::CIAO::Config_Handlers::PackageConfiguration > basePackage_; + + 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 + basePackage (Type&); + + virtual void + basePackage (Type const&); + + virtual void + basePackage_pre (Type&); + + virtual void + basePackage_pre (Type const&); + + virtual void + basePackage_next (Type&); + + virtual void + basePackage_next (Type const&); + + virtual void + basePackage_post (Type&); + + virtual void + basePackage_post (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 + basePackage_pre (Type &o) + { + + this->basePackage_pre (const_cast <Type const &> (o)); + } + + + virtual void + basePackage_pre (Type const&); + + virtual void + basePackage_next (Type &o) + { + + this->basePackage_next (const_cast <Type const &> (o)); + } + + + virtual void + basePackage_next (Type const&); + + virtual void + basePackage_post (Type &o) + { + + this->basePackage_post (const_cast <Type const &> (o)); + } + + + virtual void + basePackage_post (Type const&); + + protected: + TopLevelPackageDescription (); + }; + } + } +} + +namespace CIAO +{ + namespace Config_Handlers + { + } +} + +#endif // TOPLEVEL_HPP |