ChangeLogTag:Mon Aug 23 21:32:50 2004 Balachandran Natarajan <bala@dre.vanderbilt.edu>

26 files changed, 14565 insertions, 7 deletions

diff --git a/TAO/CIAO/CIDLC/TypeNameEmitter.cpp b/TAO/CIAO/CIDLC/TypeNameEmitter.cpp
index b812af3d334..6603518da0c 100644
--- a/TAO/CIAO/CIDLC/TypeNameEmitter.cpp
+++ b/TAO/CIAO/CIDLC/TypeNameEmitter.cpp
@@ -1292,7 +1292,7 @@ ExtractedTypeDeclEmitter::traverse (Double&)
 void
 ExtractedTypeDeclEmitter::traverse (String&)
 {
-  os << "char * " << STRS[EXTRACT] << " = 0;";
+  os << "const char * " << STRS[EXTRACT] << " = 0;";
 }
 
 void
diff --git a/TAO/CIAO/ChangeLog b/TAO/CIAO/ChangeLog
index 781b2dd40fc..c585e9ed633 100644
--- a/TAO/CIAO/ChangeLog
+++ b/TAO/CIAO/ChangeLog
@@ -1,3 +1,45 @@
+Mon Aug 23 21:32:50 2004  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
+
+ 	* CIDLC/TypeNameEmitter.cpp:
+
+	  Fixed a compiler error in the daily builds showing up from a
+	  non-const declaration of a char * for extraction into an Any. 
+
+	* DAnCE/Config_Handlers/Config.h:
+
+	  Deployment.h has been renamed to Config.h 
+	
+	* DAnCE/Config_Handlers/Process_Element.h:	
+	* DAnCE/Config_Handlers/Basic_Handler.h:
+	
+	  Include Config.h
+	  
+	* DAnCE/Config_Handlers/Basic_Deployment_Data.cpp:
+	* DAnCE/Config_Handlers/Basic_Deployment_Data.hpp:
+	* DAnCE/Config_Handlers/Deployment.cpp:
+	* DAnCE/Config_Handlers/Deployment.hpp:
+	* DAnCE/Config_Handlers/ccd.cpp:
+	* DAnCE/Config_Handlers/ccd.hpp:
+	* DAnCE/Config_Handlers/cdd.cpp:
+	* DAnCE/Config_Handlers/cdd.hpp:
+	* DAnCE/Config_Handlers/cdp.cpp:
+	* DAnCE/Config_Handlers/cdp.hpp:
+	* DAnCE/Config_Handlers/cid.cpp:
+	* DAnCE/Config_Handlers/cid.hpp:
+	* DAnCE/Config_Handlers/cpd.cpp:
+	* DAnCE/Config_Handlers/cpd.hpp:
+	* DAnCE/Config_Handlers/iad.cpp:
+	* DAnCE/Config_Handlers/iad.hpp:
+	* DAnCE/Config_Handlers/pcd.cpp:
+	* DAnCE/Config_Handlers/pcd.hpp:
+	* DAnCE/Config_Handlers/toplevel.cpp:
+	* DAnCE/Config_Handlers/toplevel.hpp:
+	* DAnCE/Config_Handlers/Config_Handlers.mpc:	
+
+	  Generated code from XSC which is going to be used for the next
+	  generation handlers. They have been added in the MPC but guarded
+	  with requires += dummy_label since they give lot of warnings. 
+
 Mon Aug 23 08:02:12 UTC 2004  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * tools/IDL3_to_IDL2/IDL3_to_IDL2.mpc:
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.cpp
new file mode 100644
index 00000000000..062be4de64c
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.cpp
@@ -0,0 +1,6257 @@
+// $Id$
+#include "Basic_Deployment_Data.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // TCKind
+    // 
+
+    TCKind::
+    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 ()
+    :
+    regulator__ ()
+    {
+    }
+
+    DataType::
+    DataType (::CIAO::Config_Handlers::DataType const& s)
+    :
+    kind_ (s.kind_.get () ? new ::CIAO::Config_Handlers::TCKind (*s.kind_) : 0),
+    regulator__ ()
+    {
+      if (kind_.get ()) kind_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::DataType& DataType::
+    operator= (::CIAO::Config_Handlers::DataType const& s)
+    {
+      if (s.kind_.get ()) kind (*(s.kind_));
+      else kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > (0);
+
+      return *this;
+    }
+
+
+    // DataType
+    // 
+    bool DataType::
+    kind_p () const
+    {
+      return kind_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::TCKind const& DataType::
+    kind () const
+    {
+      return *kind_;
+    }
+
+    ::CIAO::Config_Handlers::TCKind& DataType::
+    kind ()
+    {
+      return *kind_;
+    }
+
+    void DataType::
+    kind (::CIAO::Config_Handlers::TCKind const& e)
+    {
+      if (kind_.get ())
+      {
+        *kind_ = e;
+      }
+
+      else
+      {
+        kind_ = ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > (new ::CIAO::Config_Handlers::TCKind (e));
+        kind_->container (this);
+      }
+    }
+
+
+    // DataValue
+    // 
+
+    DataValue::
+    DataValue ()
+    :
+    regulator__ ()
+    {
+    }
+
+    DataValue::
+    DataValue (::CIAO::Config_Handlers::DataValue const& s)
+    :
+    short__ (s.short__.get () ? new ::XMLSchema::short_ (*s.short__) : 0),
+    long__ (s.long__.get () ? new ::XMLSchema::int_ (*s.long__) : 0),
+    ushort_ (s.ushort_.get () ? new ::XMLSchema::unsignedShort (*s.ushort_) : 0),
+    ulong_ (s.ulong_.get () ? new ::XMLSchema::unsignedInt (*s.ulong_) : 0),
+    float__ (s.float__.get () ? new ::XMLSchema::float_ (*s.float__) : 0),
+    double__ (s.double__.get () ? new ::XMLSchema::double_ (*s.double__) : 0),
+    boolean_ (s.boolean_.get () ? new ::XMLSchema::boolean (*s.boolean_) : 0),
+    octet_ (s.octet_.get () ? new ::XMLSchema::unsignedByte (*s.octet_) : 0),
+    objref_ (s.objref_.get () ? new ::XMLSchema::string< char > (*s.objref_) : 0),
+    enum__ (s.enum__.get () ? new ::XMLSchema::string< char > (*s.enum__) : 0),
+    string_ (s.string_.get () ? new ::XMLSchema::string< char > (*s.string_) : 0),
+    longlong_ (s.longlong_.get () ? new ::XMLSchema::long_ (*s.longlong_) : 0),
+    ulonglong_ (s.ulonglong_.get () ? new ::XMLSchema::unsignedLong (*s.ulonglong_) : 0),
+    longdouble_ (s.longdouble_.get () ? new ::XMLSchema::double_ (*s.longdouble_) : 0),
+    fixed_ (s.fixed_.get () ? new ::XMLSchema::string< char > (*s.fixed_) : 0),
+    typecode_ (s.typecode_.get () ? new ::CIAO::Config_Handlers::DataType (*s.typecode_) : 0),
+    regulator__ ()
+    {
+      if (short__.get ()) short__->container (this);
+      if (long__.get ()) long__->container (this);
+      if (ushort_.get ()) ushort_->container (this);
+      if (ulong_.get ()) ulong_->container (this);
+      if (float__.get ()) float__->container (this);
+      if (double__.get ()) double__->container (this);
+      if (boolean_.get ()) boolean_->container (this);
+      if (octet_.get ()) octet_->container (this);
+      if (objref_.get ()) objref_->container (this);
+      if (enum__.get ()) enum__->container (this);
+      if (string_.get ()) string_->container (this);
+      if (longlong_.get ()) longlong_->container (this);
+      if (ulonglong_.get ()) ulonglong_->container (this);
+      if (longdouble_.get ()) longdouble_->container (this);
+      if (fixed_.get ()) fixed_->container (this);
+      if (typecode_.get ()) typecode_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::DataValue& DataValue::
+    operator= (::CIAO::Config_Handlers::DataValue const& s)
+    {
+      if (s.short__.get ()) short_ (*(s.short__));
+      else short__ = ::std::auto_ptr< ::XMLSchema::short_ > (0);
+
+      if (s.long__.get ()) long_ (*(s.long__));
+      else long__ = ::std::auto_ptr< ::XMLSchema::int_ > (0);
+
+      if (s.ushort_.get ()) ushort (*(s.ushort_));
+      else ushort_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (0);
+
+      if (s.ulong_.get ()) ulong (*(s.ulong_));
+      else ulong_ = ::std::auto_ptr< ::XMLSchema::unsignedInt > (0);
+
+      if (s.float__.get ()) float_ (*(s.float__));
+      else float__ = ::std::auto_ptr< ::XMLSchema::float_ > (0);
+
+      if (s.double__.get ()) double_ (*(s.double__));
+      else double__ = ::std::auto_ptr< ::XMLSchema::double_ > (0);
+
+      if (s.boolean_.get ()) boolean (*(s.boolean_));
+      else boolean_ = ::std::auto_ptr< ::XMLSchema::boolean > (0);
+
+      if (s.octet_.get ()) octet (*(s.octet_));
+      else octet_ = ::std::auto_ptr< ::XMLSchema::unsignedByte > (0);
+
+      if (s.objref_.get ()) objref (*(s.objref_));
+      else objref_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.enum__.get ()) enum_ (*(s.enum__));
+      else enum__ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.string_.get ()) string (*(s.string_));
+      else string_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.longlong_.get ()) longlong (*(s.longlong_));
+      else longlong_ = ::std::auto_ptr< ::XMLSchema::long_ > (0);
+
+      if (s.ulonglong_.get ()) ulonglong (*(s.ulonglong_));
+      else ulonglong_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (0);
+
+      if (s.longdouble_.get ()) longdouble (*(s.longdouble_));
+      else longdouble_ = ::std::auto_ptr< ::XMLSchema::double_ > (0);
+
+      if (s.fixed_.get ()) fixed (*(s.fixed_));
+      else fixed_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.typecode_.get ()) typecode (*(s.typecode_));
+      else typecode_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (0);
+
+      return *this;
+    }
+
+
+    // DataValue
+    // 
+    bool DataValue::
+    short_p () const
+    {
+      return short__.get () != 0;
+    }
+
+    ::XMLSchema::short_ const& DataValue::
+    short_ () const
+    {
+      return *short__;
+    }
+
+    ::XMLSchema::short_& DataValue::
+    short_ ()
+    {
+      return *short__;
+    }
+
+    void DataValue::
+    short_ (::XMLSchema::short_ const& e)
+    {
+      if (short__.get ())
+      {
+        *short__ = e;
+      }
+
+      else
+      {
+        short__ = ::std::auto_ptr< ::XMLSchema::short_ > (new ::XMLSchema::short_ (e));
+        short__->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    long_p () const
+    {
+      return long__.get () != 0;
+    }
+
+    ::XMLSchema::int_ const& DataValue::
+    long_ () const
+    {
+      return *long__;
+    }
+
+    ::XMLSchema::int_& DataValue::
+    long_ ()
+    {
+      return *long__;
+    }
+
+    void DataValue::
+    long_ (::XMLSchema::int_ const& e)
+    {
+      if (long__.get ())
+      {
+        *long__ = e;
+      }
+
+      else
+      {
+        long__ = ::std::auto_ptr< ::XMLSchema::int_ > (new ::XMLSchema::int_ (e));
+        long__->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    ushort_p () const
+    {
+      return ushort_.get () != 0;
+    }
+
+    ::XMLSchema::unsignedShort const& DataValue::
+    ushort () const
+    {
+      return *ushort_;
+    }
+
+    ::XMLSchema::unsignedShort& DataValue::
+    ushort ()
+    {
+      return *ushort_;
+    }
+
+    void DataValue::
+    ushort (::XMLSchema::unsignedShort const& e)
+    {
+      if (ushort_.get ())
+      {
+        *ushort_ = e;
+      }
+
+      else
+      {
+        ushort_ = ::std::auto_ptr< ::XMLSchema::unsignedShort > (new ::XMLSchema::unsignedShort (e));
+        ushort_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    ulong_p () const
+    {
+      return ulong_.get () != 0;
+    }
+
+    ::XMLSchema::unsignedInt const& DataValue::
+    ulong () const
+    {
+      return *ulong_;
+    }
+
+    ::XMLSchema::unsignedInt& DataValue::
+    ulong ()
+    {
+      return *ulong_;
+    }
+
+    void DataValue::
+    ulong (::XMLSchema::unsignedInt const& e)
+    {
+      if (ulong_.get ())
+      {
+        *ulong_ = e;
+      }
+
+      else
+      {
+        ulong_ = ::std::auto_ptr< ::XMLSchema::unsignedInt > (new ::XMLSchema::unsignedInt (e));
+        ulong_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    float_p () const
+    {
+      return float__.get () != 0;
+    }
+
+    ::XMLSchema::float_ const& DataValue::
+    float_ () const
+    {
+      return *float__;
+    }
+
+    ::XMLSchema::float_& DataValue::
+    float_ ()
+    {
+      return *float__;
+    }
+
+    void DataValue::
+    float_ (::XMLSchema::float_ const& e)
+    {
+      if (float__.get ())
+      {
+        *float__ = e;
+      }
+
+      else
+      {
+        float__ = ::std::auto_ptr< ::XMLSchema::float_ > (new ::XMLSchema::float_ (e));
+        float__->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    double_p () const
+    {
+      return double__.get () != 0;
+    }
+
+    ::XMLSchema::double_ const& DataValue::
+    double_ () const
+    {
+      return *double__;
+    }
+
+    ::XMLSchema::double_& DataValue::
+    double_ ()
+    {
+      return *double__;
+    }
+
+    void DataValue::
+    double_ (::XMLSchema::double_ const& e)
+    {
+      if (double__.get ())
+      {
+        *double__ = e;
+      }
+
+      else
+      {
+        double__ = ::std::auto_ptr< ::XMLSchema::double_ > (new ::XMLSchema::double_ (e));
+        double__->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    boolean_p () const
+    {
+      return boolean_.get () != 0;
+    }
+
+    ::XMLSchema::boolean const& DataValue::
+    boolean () const
+    {
+      return *boolean_;
+    }
+
+    ::XMLSchema::boolean& DataValue::
+    boolean ()
+    {
+      return *boolean_;
+    }
+
+    void DataValue::
+    boolean (::XMLSchema::boolean const& e)
+    {
+      if (boolean_.get ())
+      {
+        *boolean_ = e;
+      }
+
+      else
+      {
+        boolean_ = ::std::auto_ptr< ::XMLSchema::boolean > (new ::XMLSchema::boolean (e));
+        boolean_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    octet_p () const
+    {
+      return octet_.get () != 0;
+    }
+
+    ::XMLSchema::unsignedByte const& DataValue::
+    octet () const
+    {
+      return *octet_;
+    }
+
+    ::XMLSchema::unsignedByte& DataValue::
+    octet ()
+    {
+      return *octet_;
+    }
+
+    void DataValue::
+    octet (::XMLSchema::unsignedByte const& e)
+    {
+      if (octet_.get ())
+      {
+        *octet_ = e;
+      }
+
+      else
+      {
+        octet_ = ::std::auto_ptr< ::XMLSchema::unsignedByte > (new ::XMLSchema::unsignedByte (e));
+        octet_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    objref_p () const
+    {
+      return objref_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& DataValue::
+    objref () const
+    {
+      return *objref_;
+    }
+
+    ::XMLSchema::string< char >& DataValue::
+    objref ()
+    {
+      return *objref_;
+    }
+
+    void DataValue::
+    objref (::XMLSchema::string< char > const& e)
+    {
+      if (objref_.get ())
+      {
+        *objref_ = e;
+      }
+
+      else
+      {
+        objref_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        objref_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    enum_p () const
+    {
+      return enum__.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& DataValue::
+    enum_ () const
+    {
+      return *enum__;
+    }
+
+    ::XMLSchema::string< char >& DataValue::
+    enum_ ()
+    {
+      return *enum__;
+    }
+
+    void DataValue::
+    enum_ (::XMLSchema::string< char > const& e)
+    {
+      if (enum__.get ())
+      {
+        *enum__ = e;
+      }
+
+      else
+      {
+        enum__ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        enum__->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    string_p () const
+    {
+      return string_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& DataValue::
+    string () const
+    {
+      return *string_;
+    }
+
+    ::XMLSchema::string< char >& DataValue::
+    string ()
+    {
+      return *string_;
+    }
+
+    void DataValue::
+    string (::XMLSchema::string< char > const& e)
+    {
+      if (string_.get ())
+      {
+        *string_ = e;
+      }
+
+      else
+      {
+        string_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        string_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    longlong_p () const
+    {
+      return longlong_.get () != 0;
+    }
+
+    ::XMLSchema::long_ const& DataValue::
+    longlong () const
+    {
+      return *longlong_;
+    }
+
+    ::XMLSchema::long_& DataValue::
+    longlong ()
+    {
+      return *longlong_;
+    }
+
+    void DataValue::
+    longlong (::XMLSchema::long_ const& e)
+    {
+      if (longlong_.get ())
+      {
+        *longlong_ = e;
+      }
+
+      else
+      {
+        longlong_ = ::std::auto_ptr< ::XMLSchema::long_ > (new ::XMLSchema::long_ (e));
+        longlong_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    ulonglong_p () const
+    {
+      return ulonglong_.get () != 0;
+    }
+
+    ::XMLSchema::unsignedLong const& DataValue::
+    ulonglong () const
+    {
+      return *ulonglong_;
+    }
+
+    ::XMLSchema::unsignedLong& DataValue::
+    ulonglong ()
+    {
+      return *ulonglong_;
+    }
+
+    void DataValue::
+    ulonglong (::XMLSchema::unsignedLong const& e)
+    {
+      if (ulonglong_.get ())
+      {
+        *ulonglong_ = e;
+      }
+
+      else
+      {
+        ulonglong_ = ::std::auto_ptr< ::XMLSchema::unsignedLong > (new ::XMLSchema::unsignedLong (e));
+        ulonglong_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    longdouble_p () const
+    {
+      return longdouble_.get () != 0;
+    }
+
+    ::XMLSchema::double_ const& DataValue::
+    longdouble () const
+    {
+      return *longdouble_;
+    }
+
+    ::XMLSchema::double_& DataValue::
+    longdouble ()
+    {
+      return *longdouble_;
+    }
+
+    void DataValue::
+    longdouble (::XMLSchema::double_ const& e)
+    {
+      if (longdouble_.get ())
+      {
+        *longdouble_ = e;
+      }
+
+      else
+      {
+        longdouble_ = ::std::auto_ptr< ::XMLSchema::double_ > (new ::XMLSchema::double_ (e));
+        longdouble_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    fixed_p () const
+    {
+      return fixed_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& DataValue::
+    fixed () const
+    {
+      return *fixed_;
+    }
+
+    ::XMLSchema::string< char >& DataValue::
+    fixed ()
+    {
+      return *fixed_;
+    }
+
+    void DataValue::
+    fixed (::XMLSchema::string< char > const& e)
+    {
+      if (fixed_.get ())
+      {
+        *fixed_ = e;
+      }
+
+      else
+      {
+        fixed_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        fixed_->container (this);
+      }
+    }
+
+    // DataValue
+    // 
+    bool DataValue::
+    typecode_p () const
+    {
+      return typecode_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::DataType const& DataValue::
+    typecode () const
+    {
+      return *typecode_;
+    }
+
+    ::CIAO::Config_Handlers::DataType& DataValue::
+    typecode ()
+    {
+      return *typecode_;
+    }
+
+    void DataValue::
+    typecode (::CIAO::Config_Handlers::DataType const& e)
+    {
+      if (typecode_.get ())
+      {
+        *typecode_ = e;
+      }
+
+      else
+      {
+        typecode_ = ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > (new ::CIAO::Config_Handlers::DataType (e));
+        typecode_->container (this);
+      }
+    }
+
+
+    // Any
+    // 
+
+    Any::
+    Any ()
+    :
+    type_ (new ::CIAO::Config_Handlers::DataType ()),
+    value_ (new ::CIAO::Config_Handlers::DataValue ()),
+    regulator__ ()
+    {
+      type_->container (this);
+      value_->container (this);
+    }
+
+    Any::
+    Any (::CIAO::Config_Handlers::Any const& s)
+    :
+    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_;
+    }
+
+    ::CIAO::Config_Handlers::DataType& Any::
+    type ()
+    {
+      return *type_;
+    }
+
+    void Any::
+    type (::CIAO::Config_Handlers::DataType const& e)
+    {
+      *type_ = e;
+    }
+
+    // Any
+    // 
+    ::CIAO::Config_Handlers::DataValue const& Any::
+    value () const
+    {
+      return *value_;
+    }
+
+    ::CIAO::Config_Handlers::DataValue& Any::
+    value ()
+    {
+      return *value_;
+    }
+
+    void Any::
+    value (::CIAO::Config_Handlers::DataValue const& e)
+    {
+      *value_ = e;
+    }
+
+
+    // Property
+    // 
+
+    Property::
+    Property ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    value_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      value_->container (this);
+    }
+
+    Property::
+    Property (::CIAO::Config_Handlers::Property const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*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< char > const& Property::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& Property::
+    name ()
+    {
+      return *name_;
+    }
+
+    void Property::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // Property
+    // 
+    ::CIAO::Config_Handlers::Any const& Property::
+    value () const
+    {
+      return *value_;
+    }
+
+    ::CIAO::Config_Handlers::Any& Property::
+    value ()
+    {
+      return *value_;
+    }
+
+    void Property::
+    value (::CIAO::Config_Handlers::Any const& e)
+    {
+      *value_ = e;
+    }
+
+
+    // Node
+    // 
+
+    Node::
+    Node ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    label_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      label_->container (this);
+    }
+
+    Node::
+    Node (::CIAO::Config_Handlers::Node const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    label_ (new ::XMLSchema::string< char > (*s.label_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      label_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::Node& Node::
+    operator= (::CIAO::Config_Handlers::Node const& s)
+    {
+      name (s.name ());
+
+      label (s.label ());
+
+      return *this;
+    }
+
+
+    // Node
+    // 
+    ::XMLSchema::string< char > const& Node::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& Node::
+    name ()
+    {
+      return *name_;
+    }
+
+    void Node::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // Node
+    // 
+    ::XMLSchema::string< char > const& Node::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& Node::
+    label ()
+    {
+      return *label_;
+    }
+
+    void Node::
+    label (::XMLSchema::string< char > const& e)
+    {
+      *label_ = e;
+    }
+
+
+    // SatisfierPropertyKind
+    // 
+
+    SatisfierPropertyKind::
+    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 ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind ()),
+    value_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      kind_->container (this);
+      value_->container (this);
+    }
+
+    SatisfierProperty::
+    SatisfierProperty (::CIAO::Config_Handlers::SatisfierProperty const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind (*s.kind_)),
+    value_ (new ::CIAO::Config_Handlers::Any (*s.value_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      kind_->container (this);
+      value_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::SatisfierProperty& SatisfierProperty::
+    operator= (::CIAO::Config_Handlers::SatisfierProperty const& s)
+    {
+      name (s.name ());
+
+      kind (s.kind ());
+
+      value (s.value ());
+
+      return *this;
+    }
+
+
+    // SatisfierProperty
+    // 
+    ::XMLSchema::string< char > const& SatisfierProperty::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& SatisfierProperty::
+    name ()
+    {
+      return *name_;
+    }
+
+    void SatisfierProperty::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // SatisfierProperty
+    // 
+    ::CIAO::Config_Handlers::SatisfierPropertyKind const& SatisfierProperty::
+    kind () const
+    {
+      return *kind_;
+    }
+
+    ::CIAO::Config_Handlers::SatisfierPropertyKind& SatisfierProperty::
+    kind ()
+    {
+      return *kind_;
+    }
+
+    void SatisfierProperty::
+    kind (::CIAO::Config_Handlers::SatisfierPropertyKind const& e)
+    {
+      *kind_ = e;
+    }
+
+    // SatisfierProperty
+    // 
+    ::CIAO::Config_Handlers::Any const& SatisfierProperty::
+    value () const
+    {
+      return *value_;
+    }
+
+    ::CIAO::Config_Handlers::Any& SatisfierProperty::
+    value ()
+    {
+      return *value_;
+    }
+
+    void SatisfierProperty::
+    value (::CIAO::Config_Handlers::Any const& e)
+    {
+      *value_ = e;
+    }
+
+
+    // Resource
+    // 
+
+    Resource::
+    Resource ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+    }
+
+    Resource::
+    Resource (::CIAO::Config_Handlers::Resource const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    resourceType_ (new ::XMLSchema::string< char > (*s.resourceType_)),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty (*s.property_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::Resource& Resource::
+    operator= (::CIAO::Config_Handlers::Resource const& s)
+    {
+      name (s.name ());
+
+      resourceType (s.resourceType ());
+
+      property (s.property ());
+
+      return *this;
+    }
+
+
+    // Resource
+    // 
+    ::XMLSchema::string< char > const& Resource::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& Resource::
+    name ()
+    {
+      return *name_;
+    }
+
+    void Resource::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // Resource
+    // 
+    ::XMLSchema::string< char > const& Resource::
+    resourceType () const
+    {
+      return *resourceType_;
+    }
+
+    ::XMLSchema::string< char >& Resource::
+    resourceType ()
+    {
+      return *resourceType_;
+    }
+
+    void Resource::
+    resourceType (::XMLSchema::string< char > const& e)
+    {
+      *resourceType_ = e;
+    }
+
+    // Resource
+    // 
+    ::CIAO::Config_Handlers::SatisfierProperty const& Resource::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::SatisfierProperty& Resource::
+    property ()
+    {
+      return *property_;
+    }
+
+    void Resource::
+    property (::CIAO::Config_Handlers::SatisfierProperty const& e)
+    {
+      *property_ = e;
+    }
+
+
+    // SharedResource
+    // 
+
+    SharedResource::
+    SharedResource ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    node_ (new ::CIAO::Config_Handlers::Node ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      node_->container (this);
+      property_->container (this);
+    }
+
+    SharedResource::
+    SharedResource (::CIAO::Config_Handlers::SharedResource const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    resourceType_ (new ::XMLSchema::string< char > (*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< char > const& SharedResource::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& SharedResource::
+    name ()
+    {
+      return *name_;
+    }
+
+    void SharedResource::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // SharedResource
+    // 
+    ::XMLSchema::string< char > const& SharedResource::
+    resourceType () const
+    {
+      return *resourceType_;
+    }
+
+    ::XMLSchema::string< char >& SharedResource::
+    resourceType ()
+    {
+      return *resourceType_;
+    }
+
+    void SharedResource::
+    resourceType (::XMLSchema::string< char > const& e)
+    {
+      *resourceType_ = e;
+    }
+
+    // SharedResource
+    // 
+    ::CIAO::Config_Handlers::Node const& SharedResource::
+    node () const
+    {
+      return *node_;
+    }
+
+    ::CIAO::Config_Handlers::Node& SharedResource::
+    node ()
+    {
+      return *node_;
+    }
+
+    void SharedResource::
+    node (::CIAO::Config_Handlers::Node const& e)
+    {
+      *node_ = e;
+    }
+
+    // SharedResource
+    // 
+    ::CIAO::Config_Handlers::SatisfierProperty const& SharedResource::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::SatisfierProperty& SharedResource::
+    property ()
+    {
+      return *property_;
+    }
+
+    void SharedResource::
+    property (::CIAO::Config_Handlers::SatisfierProperty const& e)
+    {
+      *property_ = e;
+    }
+
+
+    // Requirement
+    // 
+
+    Requirement::
+    Requirement ()
+    :
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    name_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::Property ()),
+    regulator__ ()
+    {
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+    }
+
+    Requirement::
+    Requirement (::CIAO::Config_Handlers::Requirement const& s)
+    :
+    resourceType_ (new ::XMLSchema::string< char > (*s.resourceType_)),
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    property_ (new ::CIAO::Config_Handlers::Property (*s.property_)),
+    regulator__ ()
+    {
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::Requirement& Requirement::
+    operator= (::CIAO::Config_Handlers::Requirement const& s)
+    {
+      resourceType (s.resourceType ());
+
+      name (s.name ());
+
+      property (s.property ());
+
+      return *this;
+    }
+
+
+    // Requirement
+    // 
+    ::XMLSchema::string< char > const& Requirement::
+    resourceType () const
+    {
+      return *resourceType_;
+    }
+
+    ::XMLSchema::string< char >& Requirement::
+    resourceType ()
+    {
+      return *resourceType_;
+    }
+
+    void Requirement::
+    resourceType (::XMLSchema::string< char > const& e)
+    {
+      *resourceType_ = e;
+    }
+
+    // Requirement
+    // 
+    ::XMLSchema::string< char > const& Requirement::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& Requirement::
+    name ()
+    {
+      return *name_;
+    }
+
+    void Requirement::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // Requirement
+    // 
+    ::CIAO::Config_Handlers::Property const& Requirement::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::Property& Requirement::
+    property ()
+    {
+      return *property_;
+    }
+
+    void Requirement::
+    property (::CIAO::Config_Handlers::Property const& e)
+    {
+      *property_ = e;
+    }
+
+
+    // ResourceDeploymentDescription
+    // 
+
+    ResourceDeploymentDescription::
+    ResourceDeploymentDescription ()
+    :
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    ResourceDeploymentDescription::
+    ResourceDeploymentDescription (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s)
+    :
+    requirementName_ (new ::XMLSchema::string< char > (*s.requirementName_)),
+    resourceName_ (new ::XMLSchema::string< char > (*s.resourceName_)),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any (*s.resourceValue_)),
+    regulator__ ()
+    {
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ResourceDeploymentDescription& ResourceDeploymentDescription::
+    operator= (::CIAO::Config_Handlers::ResourceDeploymentDescription const& s)
+    {
+      requirementName (s.requirementName ());
+
+      resourceName (s.resourceName ());
+
+      resourceValue (s.resourceValue ());
+
+      return *this;
+    }
+
+
+    // ResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ResourceDeploymentDescription::
+    requirementName () const
+    {
+      return *requirementName_;
+    }
+
+    ::XMLSchema::string< char >& ResourceDeploymentDescription::
+    requirementName ()
+    {
+      return *requirementName_;
+    }
+
+    void ResourceDeploymentDescription::
+    requirementName (::XMLSchema::string< char > const& e)
+    {
+      *requirementName_ = e;
+    }
+
+    // ResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ResourceDeploymentDescription::
+    resourceName () const
+    {
+      return *resourceName_;
+    }
+
+    ::XMLSchema::string< char >& ResourceDeploymentDescription::
+    resourceName ()
+    {
+      return *resourceName_;
+    }
+
+    void ResourceDeploymentDescription::
+    resourceName (::XMLSchema::string< char > const& e)
+    {
+      *resourceName_ = e;
+    }
+
+    // ResourceDeploymentDescription
+    // 
+    ::CIAO::Config_Handlers::Any const& ResourceDeploymentDescription::
+    resourceValue () const
+    {
+      return *resourceValue_;
+    }
+
+    ::CIAO::Config_Handlers::Any& ResourceDeploymentDescription::
+    resourceValue ()
+    {
+      return *resourceValue_;
+    }
+
+    void ResourceDeploymentDescription::
+    resourceValue (::CIAO::Config_Handlers::Any const& e)
+    {
+      *resourceValue_ = e;
+    }
+
+
+    // ArtifactDeploymentDescription
+    // 
+
+    ArtifactDeploymentDescription::
+    ArtifactDeploymentDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+    }
+
+    ArtifactDeploymentDescription::
+    ArtifactDeploymentDescription (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    source_ (new ::XMLSchema::string< char > (*s.source_)),
+    node_ (s.node_.get () ? new ::XMLSchema::string< char > (*s.node_) : 0),
+    execParameter_ (s.execParameter_.get () ? new ::CIAO::Config_Handlers::Property (*s.execParameter_) : 0),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.deployRequirement_) : 0),
+    deployedResource_ (s.deployedResource_.get () ? new ::CIAO::Config_Handlers::ResourceDeploymentDescription (*s.deployedResource_) : 0),
+    id_ (s.id_.get () ? new ::XMLSchema::ID< char > (*s.id_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+      if (node_.get ()) node_->container (this);
+      location_.reserve (s.location_.size ());
+      {
+        for (location_const_iterator i (s.location_.begin ());
+        i != s.location_.end ();
+        ++i) add_location (*i);
+      }
+
+      if (execParameter_.get ()) execParameter_->container (this);
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+      if (deployedResource_.get ()) deployedResource_->container (this);
+      if (id_.get ()) id_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ArtifactDeploymentDescription& ArtifactDeploymentDescription::
+    operator= (::CIAO::Config_Handlers::ArtifactDeploymentDescription const& s)
+    {
+      name (s.name ());
+
+      source (s.source ());
+
+      if (s.node_.get ()) node (*(s.node_));
+      else node_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      location_.clear ();
+      location_.reserve (s.location_.size ());
+      {
+        for (location_const_iterator i (s.location_.begin ());
+        i != s.location_.end ();
+        ++i) add_location (*i);
+      }
+
+      if (s.execParameter_.get ()) execParameter (*(s.execParameter_));
+      else execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      if (s.deployedResource_.get ()) deployedResource (*(s.deployedResource_));
+      else deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceDeploymentDescription > (0);
+
+      if (s.id_.get ()) id (*(s.id_));
+      else id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (0);
+
+      return *this;
+    }
+
+
+    // ArtifactDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ArtifactDeploymentDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& ArtifactDeploymentDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void ArtifactDeploymentDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ArtifactDeploymentDescription::
+    source () const
+    {
+      return *source_;
+    }
+
+    ::XMLSchema::string< char >& ArtifactDeploymentDescription::
+    source ()
+    {
+      return *source_;
+    }
+
+    void ArtifactDeploymentDescription::
+    source (::XMLSchema::string< char > const& e)
+    {
+      *source_ = e;
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    bool ArtifactDeploymentDescription::
+    node_p () const
+    {
+      return node_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ArtifactDeploymentDescription::
+    node () const
+    {
+      return *node_;
+    }
+
+    ::XMLSchema::string< char >& ArtifactDeploymentDescription::
+    node ()
+    {
+      return *node_;
+    }
+
+    void ArtifactDeploymentDescription::
+    node (::XMLSchema::string< char > const& e)
+    {
+      if (node_.get ())
+      {
+        *node_ = e;
+      }
+
+      else
+      {
+        node_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        node_->container (this);
+      }
+    }
+
+    // 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< char > const& e)
+    {
+      if (location_.capacity () < location_.size () + 1)
+      {
+        ::std::vector< ::XMLSchema::string< char > > v;
+        v.reserve (location_.size () + 1);
+
+        while (location_.size ())
+        {
+          //@@ VC6
+          ::XMLSchema::string< char >& t = location_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          location_.pop_back ();
+        }
+
+        location_.swap (v);
+      }
+
+      location_.push_back (e);
+      location_.back ().container (this);
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    bool ArtifactDeploymentDescription::
+    execParameter_p () const
+    {
+      return execParameter_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ArtifactDeploymentDescription::
+    execParameter () const
+    {
+      return *execParameter_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ArtifactDeploymentDescription::
+    execParameter ()
+    {
+      return *execParameter_;
+    }
+
+    void ArtifactDeploymentDescription::
+    execParameter (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (execParameter_.get ())
+      {
+        *execParameter_ = e;
+      }
+
+      else
+      {
+        execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        execParameter_->container (this);
+      }
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    bool ArtifactDeploymentDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& ArtifactDeploymentDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& ArtifactDeploymentDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void ArtifactDeploymentDescription::
+    deployRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    bool ArtifactDeploymentDescription::
+    deployedResource_p () const
+    {
+      return deployedResource_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ResourceDeploymentDescription const& ArtifactDeploymentDescription::
+    deployedResource () const
+    {
+      return *deployedResource_;
+    }
+
+    ::CIAO::Config_Handlers::ResourceDeploymentDescription& ArtifactDeploymentDescription::
+    deployedResource ()
+    {
+      return *deployedResource_;
+    }
+
+    void ArtifactDeploymentDescription::
+    deployedResource (::CIAO::Config_Handlers::ResourceDeploymentDescription const& e)
+    {
+      if (deployedResource_.get ())
+      {
+        *deployedResource_ = e;
+      }
+
+      else
+      {
+        deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceDeploymentDescription > (new ::CIAO::Config_Handlers::ResourceDeploymentDescription (e));
+        deployedResource_->container (this);
+      }
+    }
+
+    // ArtifactDeploymentDescription
+    // 
+    bool ArtifactDeploymentDescription::
+    id_p () const
+    {
+      return id_.get () != 0;
+    }
+
+    ::XMLSchema::ID< char > const& ArtifactDeploymentDescription::
+    id () const
+    {
+      return *id_;
+    }
+
+    ::XMLSchema::ID< char >& ArtifactDeploymentDescription::
+    id ()
+    {
+      return *id_;
+    }
+
+    void ArtifactDeploymentDescription::
+    id (::XMLSchema::ID< char > const& e)
+    {
+      if (id_.get ())
+      {
+        *id_ = e;
+      }
+
+      else
+      {
+        id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (new ::XMLSchema::ID< char > (e));
+        id_->container (this);
+      }
+    }
+
+
+    // MonolithicDeploymentDescription
+    // 
+
+    MonolithicDeploymentDescription::
+    MonolithicDeploymentDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+    }
+
+    MonolithicDeploymentDescription::
+    MonolithicDeploymentDescription (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    source_ (new ::XMLSchema::string< char > (*s.source_)),
+    execParameter_ (s.execParameter_.get () ? new ::CIAO::Config_Handlers::Property (*s.execParameter_) : 0),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.deployRequirement_) : 0),
+    id_ (s.id_.get () ? new ::XMLSchema::ID< char > (*s.id_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+      artifact_.reserve (s.artifact_.size ());
+      {
+        for (artifact_const_iterator i (s.artifact_.begin ());
+        i != s.artifact_.end ();
+        ++i) add_artifact (*i);
+      }
+
+      if (execParameter_.get ()) execParameter_->container (this);
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+      if (id_.get ()) id_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::MonolithicDeploymentDescription& MonolithicDeploymentDescription::
+    operator= (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& s)
+    {
+      name (s.name ());
+
+      source (s.source ());
+
+      artifact_.clear ();
+      artifact_.reserve (s.artifact_.size ());
+      {
+        for (artifact_const_iterator i (s.artifact_.begin ());
+        i != s.artifact_.end ();
+        ++i) add_artifact (*i);
+      }
+
+      if (s.execParameter_.get ()) execParameter (*(s.execParameter_));
+      else execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      if (s.id_.get ()) id (*(s.id_));
+      else id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (0);
+
+      return *this;
+    }
+
+
+    // MonolithicDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& MonolithicDeploymentDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& MonolithicDeploymentDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void MonolithicDeploymentDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // MonolithicDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& MonolithicDeploymentDescription::
+    source () const
+    {
+      return *source_;
+    }
+
+    ::XMLSchema::string< char >& MonolithicDeploymentDescription::
+    source ()
+    {
+      return *source_;
+    }
+
+    void MonolithicDeploymentDescription::
+    source (::XMLSchema::string< char > const& e)
+    {
+      *source_ = e;
+    }
+
+    // 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< char > const& e)
+    {
+      if (artifact_.capacity () < artifact_.size () + 1)
+      {
+        ::std::vector< ::XMLSchema::IDREF< char > > v;
+        v.reserve (artifact_.size () + 1);
+
+        while (artifact_.size ())
+        {
+          //@@ VC6
+          ::XMLSchema::IDREF< char >& t = artifact_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          artifact_.pop_back ();
+        }
+
+        artifact_.swap (v);
+      }
+
+      artifact_.push_back (e);
+      artifact_.back ().container (this);
+    }
+
+    // MonolithicDeploymentDescription
+    // 
+    bool MonolithicDeploymentDescription::
+    execParameter_p () const
+    {
+      return execParameter_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& MonolithicDeploymentDescription::
+    execParameter () const
+    {
+      return *execParameter_;
+    }
+
+    ::CIAO::Config_Handlers::Property& MonolithicDeploymentDescription::
+    execParameter ()
+    {
+      return *execParameter_;
+    }
+
+    void MonolithicDeploymentDescription::
+    execParameter (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (execParameter_.get ())
+      {
+        *execParameter_ = e;
+      }
+
+      else
+      {
+        execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        execParameter_->container (this);
+      }
+    }
+
+    // MonolithicDeploymentDescription
+    // 
+    bool MonolithicDeploymentDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& MonolithicDeploymentDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& MonolithicDeploymentDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void MonolithicDeploymentDescription::
+    deployRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+    // MonolithicDeploymentDescription
+    // 
+    bool MonolithicDeploymentDescription::
+    id_p () const
+    {
+      return id_.get () != 0;
+    }
+
+    ::XMLSchema::ID< char > const& MonolithicDeploymentDescription::
+    id () const
+    {
+      return *id_;
+    }
+
+    ::XMLSchema::ID< char >& MonolithicDeploymentDescription::
+    id ()
+    {
+      return *id_;
+    }
+
+    void MonolithicDeploymentDescription::
+    id (::XMLSchema::ID< char > const& e)
+    {
+      if (id_.get ())
+      {
+        *id_ = e;
+      }
+
+      else
+      {
+        id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (new ::XMLSchema::ID< char > (e));
+        id_->container (this);
+      }
+    }
+
+
+    // ResourceUsageKind
+    // 
+
+    ResourceUsageKind::
+    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 ()
+    :
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind ()),
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    InstanceResourceDeploymentDescription::
+    InstanceResourceDeploymentDescription (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s)
+    :
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_)),
+    requirementName_ (new ::XMLSchema::string< char > (*s.requirementName_)),
+    resourceName_ (new ::XMLSchema::string< char > (*s.resourceName_)),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any (*s.resourceValue_)),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& InstanceResourceDeploymentDescription::
+    operator= (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& s)
+    {
+      resourceUsage (s.resourceUsage ());
+
+      requirementName (s.requirementName ());
+
+      resourceName (s.resourceName ());
+
+      resourceValue (s.resourceValue ());
+
+      return *this;
+    }
+
+
+    // InstanceResourceDeploymentDescription
+    // 
+    ::CIAO::Config_Handlers::ResourceUsageKind const& InstanceResourceDeploymentDescription::
+    resourceUsage () const
+    {
+      return *resourceUsage_;
+    }
+
+    ::CIAO::Config_Handlers::ResourceUsageKind& InstanceResourceDeploymentDescription::
+    resourceUsage ()
+    {
+      return *resourceUsage_;
+    }
+
+    void InstanceResourceDeploymentDescription::
+    resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e)
+    {
+      *resourceUsage_ = e;
+    }
+
+    // InstanceResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& InstanceResourceDeploymentDescription::
+    requirementName () const
+    {
+      return *requirementName_;
+    }
+
+    ::XMLSchema::string< char >& InstanceResourceDeploymentDescription::
+    requirementName ()
+    {
+      return *requirementName_;
+    }
+
+    void InstanceResourceDeploymentDescription::
+    requirementName (::XMLSchema::string< char > const& e)
+    {
+      *requirementName_ = e;
+    }
+
+    // InstanceResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& InstanceResourceDeploymentDescription::
+    resourceName () const
+    {
+      return *resourceName_;
+    }
+
+    ::XMLSchema::string< char >& InstanceResourceDeploymentDescription::
+    resourceName ()
+    {
+      return *resourceName_;
+    }
+
+    void InstanceResourceDeploymentDescription::
+    resourceName (::XMLSchema::string< char > const& e)
+    {
+      *resourceName_ = e;
+    }
+
+    // InstanceResourceDeploymentDescription
+    // 
+    ::CIAO::Config_Handlers::Any const& InstanceResourceDeploymentDescription::
+    resourceValue () const
+    {
+      return *resourceValue_;
+    }
+
+    ::CIAO::Config_Handlers::Any& InstanceResourceDeploymentDescription::
+    resourceValue ()
+    {
+      return *resourceValue_;
+    }
+
+    void InstanceResourceDeploymentDescription::
+    resourceValue (::CIAO::Config_Handlers::Any const& e)
+    {
+      *resourceValue_ = e;
+    }
+
+
+    // InstanceDeploymentDescription
+    // 
+
+    InstanceDeploymentDescription::
+    InstanceDeploymentDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    node_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    implementation_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      node_->container (this);
+      source_->container (this);
+      implementation_->container (this);
+    }
+
+    InstanceDeploymentDescription::
+    InstanceDeploymentDescription (::CIAO::Config_Handlers::InstanceDeploymentDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    node_ (new ::XMLSchema::string< char > (*s.node_)),
+    source_ (new ::XMLSchema::string< char > (*s.source_)),
+    implementation_ (new ::XMLSchema::IDREF< char > (*s.implementation_)),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    deployedResource_ (s.deployedResource_.get () ? new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (*s.deployedResource_) : 0),
+    deployedSharedResource_ (s.deployedSharedResource_.get () ? new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (*s.deployedSharedResource_) : 0),
+    id_ (s.id_.get () ? new ::XMLSchema::ID< char > (*s.id_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      node_->container (this);
+      source_->container (this);
+      implementation_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      if (deployedResource_.get ()) deployedResource_->container (this);
+      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 ());
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.deployedResource_.get ()) deployedResource (*(s.deployedResource_));
+      else deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (0);
+
+      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< char > > (0);
+
+      return *this;
+    }
+
+
+    // InstanceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& InstanceDeploymentDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& InstanceDeploymentDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void InstanceDeploymentDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& InstanceDeploymentDescription::
+    node () const
+    {
+      return *node_;
+    }
+
+    ::XMLSchema::string< char >& InstanceDeploymentDescription::
+    node ()
+    {
+      return *node_;
+    }
+
+    void InstanceDeploymentDescription::
+    node (::XMLSchema::string< char > const& e)
+    {
+      *node_ = e;
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& InstanceDeploymentDescription::
+    source () const
+    {
+      return *source_;
+    }
+
+    ::XMLSchema::string< char >& InstanceDeploymentDescription::
+    source ()
+    {
+      return *source_;
+    }
+
+    void InstanceDeploymentDescription::
+    source (::XMLSchema::string< char > const& e)
+    {
+      *source_ = e;
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    ::XMLSchema::IDREF< char > const& InstanceDeploymentDescription::
+    implementation () const
+    {
+      return *implementation_;
+    }
+
+    ::XMLSchema::IDREF< char >& InstanceDeploymentDescription::
+    implementation ()
+    {
+      return *implementation_;
+    }
+
+    void InstanceDeploymentDescription::
+    implementation (::XMLSchema::IDREF< char > const& e)
+    {
+      *implementation_ = e;
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    bool InstanceDeploymentDescription::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& InstanceDeploymentDescription::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& InstanceDeploymentDescription::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void InstanceDeploymentDescription::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    bool InstanceDeploymentDescription::
+    deployedResource_p () const
+    {
+      return deployedResource_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& InstanceDeploymentDescription::
+    deployedResource () const
+    {
+      return *deployedResource_;
+    }
+
+    ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& InstanceDeploymentDescription::
+    deployedResource ()
+    {
+      return *deployedResource_;
+    }
+
+    void InstanceDeploymentDescription::
+    deployedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& e)
+    {
+      if (deployedResource_.get ())
+      {
+        *deployedResource_ = e;
+      }
+
+      else
+      {
+        deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > (new ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription (e));
+        deployedResource_->container (this);
+      }
+    }
+
+    // InstanceDeploymentDescription
+    // 
+    bool InstanceDeploymentDescription::
+    deployedSharedResource_p () const
+    {
+      return deployedSharedResource_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& InstanceDeploymentDescription::
+    deployedSharedResource () const
+    {
+      return *deployedSharedResource_;
+    }
+
+    ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& InstanceDeploymentDescription::
+    deployedSharedResource ()
+    {
+      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< char > const& InstanceDeploymentDescription::
+    id () const
+    {
+      return *id_;
+    }
+
+    ::XMLSchema::ID< char >& InstanceDeploymentDescription::
+    id ()
+    {
+      return *id_;
+    }
+
+    void InstanceDeploymentDescription::
+    id (::XMLSchema::ID< char > const& e)
+    {
+      if (id_.get ())
+      {
+        *id_ = e;
+      }
+
+      else
+      {
+        id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (new ::XMLSchema::ID< char > (e));
+        id_->container (this);
+      }
+    }
+
+
+    // CCMComponentPortKind
+    // 
+
+    CCMComponentPortKind::
+    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 ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    specificType_ (new ::XMLSchema::string< char > ()),
+    supportedType_ (new ::XMLSchema::string< char > ()),
+    provider_ (new ::XMLSchema::string< char > ()),
+    exclusiveProvider_ (new ::XMLSchema::string< char > ()),
+    exclusiveUser_ (new ::XMLSchema::string< char > ()),
+    optional_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      specificType_->container (this);
+      supportedType_->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)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    specificType_ (new ::XMLSchema::string< char > (*s.specificType_)),
+    supportedType_ (new ::XMLSchema::string< char > (*s.supportedType_)),
+    provider_ (new ::XMLSchema::string< char > (*s.provider_)),
+    exclusiveProvider_ (new ::XMLSchema::string< char > (*s.exclusiveProvider_)),
+    exclusiveUser_ (new ::XMLSchema::string< char > (*s.exclusiveUser_)),
+    optional_ (new ::XMLSchema::string< char > (*s.optional_)),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      specificType_->container (this);
+      supportedType_->container (this);
+      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 ());
+
+      specificType (s.specificType ());
+
+      supportedType (s.supportedType ());
+
+      provider (s.provider ());
+
+      exclusiveProvider (s.exclusiveProvider ());
+
+      exclusiveUser (s.exclusiveUser ());
+
+      optional (s.optional ());
+
+      kind (s.kind ());
+
+      return *this;
+    }
+
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void ComponentPortDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    specificType () const
+    {
+      return *specificType_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    specificType ()
+    {
+      return *specificType_;
+    }
+
+    void ComponentPortDescription::
+    specificType (::XMLSchema::string< char > const& e)
+    {
+      *specificType_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    supportedType () const
+    {
+      return *supportedType_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    supportedType ()
+    {
+      return *supportedType_;
+    }
+
+    void ComponentPortDescription::
+    supportedType (::XMLSchema::string< char > const& e)
+    {
+      *supportedType_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    provider () const
+    {
+      return *provider_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    provider ()
+    {
+      return *provider_;
+    }
+
+    void ComponentPortDescription::
+    provider (::XMLSchema::string< char > const& e)
+    {
+      *provider_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    exclusiveProvider () const
+    {
+      return *exclusiveProvider_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    exclusiveProvider ()
+    {
+      return *exclusiveProvider_;
+    }
+
+    void ComponentPortDescription::
+    exclusiveProvider (::XMLSchema::string< char > const& e)
+    {
+      *exclusiveProvider_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    exclusiveUser () const
+    {
+      return *exclusiveUser_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    exclusiveUser ()
+    {
+      return *exclusiveUser_;
+    }
+
+    void ComponentPortDescription::
+    exclusiveUser (::XMLSchema::string< char > const& e)
+    {
+      *exclusiveUser_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::XMLSchema::string< char > const& ComponentPortDescription::
+    optional () const
+    {
+      return *optional_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPortDescription::
+    optional ()
+    {
+      return *optional_;
+    }
+
+    void ComponentPortDescription::
+    optional (::XMLSchema::string< char > const& e)
+    {
+      *optional_ = e;
+    }
+
+    // ComponentPortDescription
+    // 
+    ::CIAO::Config_Handlers::CCMComponentPortKind const& ComponentPortDescription::
+    kind () const
+    {
+      return *kind_;
+    }
+
+    ::CIAO::Config_Handlers::CCMComponentPortKind& ComponentPortDescription::
+    kind ()
+    {
+      return *kind_;
+    }
+
+    void ComponentPortDescription::
+    kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e)
+    {
+      *kind_ = e;
+    }
+
+
+    // ComponentPropertyDescription
+    // 
+
+    ComponentPropertyDescription::
+    ComponentPropertyDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    type_ (new ::CIAO::Config_Handlers::DataType ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      type_->container (this);
+    }
+
+    ComponentPropertyDescription::
+    ComponentPropertyDescription (::CIAO::Config_Handlers::ComponentPropertyDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*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< char > const& ComponentPropertyDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPropertyDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void ComponentPropertyDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // ComponentPropertyDescription
+    // 
+    ::CIAO::Config_Handlers::DataType const& ComponentPropertyDescription::
+    type () const
+    {
+      return *type_;
+    }
+
+    ::CIAO::Config_Handlers::DataType& ComponentPropertyDescription::
+    type ()
+    {
+      return *type_;
+    }
+
+    void ComponentPropertyDescription::
+    type (::CIAO::Config_Handlers::DataType const& e)
+    {
+      *type_ = e;
+    }
+
+
+    // ComponentExternalPortEndpoint
+    // 
+
+    ComponentExternalPortEndpoint::
+    ComponentExternalPortEndpoint ()
+    :
+    portName_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+    }
+
+    ComponentExternalPortEndpoint::
+    ComponentExternalPortEndpoint (::CIAO::Config_Handlers::ComponentExternalPortEndpoint const& s)
+    :
+    portName_ (new ::XMLSchema::string< char > (*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< char > const& ComponentExternalPortEndpoint::
+    portName () const
+    {
+      return *portName_;
+    }
+
+    ::XMLSchema::string< char >& ComponentExternalPortEndpoint::
+    portName ()
+    {
+      return *portName_;
+    }
+
+    void ComponentExternalPortEndpoint::
+    portName (::XMLSchema::string< char > const& e)
+    {
+      *portName_ = e;
+    }
+
+
+    // PlanSubcomponentPortEndpoint
+    // 
+
+    PlanSubcomponentPortEndpoint::
+    PlanSubcomponentPortEndpoint ()
+    :
+    portName_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind ()),
+    instance_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+      kind_->container (this);
+      instance_->container (this);
+    }
+
+    PlanSubcomponentPortEndpoint::
+    PlanSubcomponentPortEndpoint (::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint const& s)
+    :
+    portName_ (new ::XMLSchema::string< char > (*s.portName_)),
+    provider_ (s.provider_.get () ? new ::XMLSchema::string< char > (*s.provider_) : 0),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind (*s.kind_)),
+    instance_ (new ::XMLSchema::IDREF< char > (*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< char > > (0);
+
+      kind (s.kind ());
+
+      instance (s.instance ());
+
+      return *this;
+    }
+
+
+    // PlanSubcomponentPortEndpoint
+    // 
+    ::XMLSchema::string< char > const& PlanSubcomponentPortEndpoint::
+    portName () const
+    {
+      return *portName_;
+    }
+
+    ::XMLSchema::string< char >& PlanSubcomponentPortEndpoint::
+    portName ()
+    {
+      return *portName_;
+    }
+
+    void PlanSubcomponentPortEndpoint::
+    portName (::XMLSchema::string< char > const& e)
+    {
+      *portName_ = e;
+    }
+
+    // PlanSubcomponentPortEndpoint
+    // 
+    bool PlanSubcomponentPortEndpoint::
+    provider_p () const
+    {
+      return provider_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& PlanSubcomponentPortEndpoint::
+    provider () const
+    {
+      return *provider_;
+    }
+
+    ::XMLSchema::string< char >& PlanSubcomponentPortEndpoint::
+    provider ()
+    {
+      return *provider_;
+    }
+
+    void PlanSubcomponentPortEndpoint::
+    provider (::XMLSchema::string< char > const& e)
+    {
+      if (provider_.get ())
+      {
+        *provider_ = e;
+      }
+
+      else
+      {
+        provider_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        provider_->container (this);
+      }
+    }
+
+    // PlanSubcomponentPortEndpoint
+    // 
+    ::CIAO::Config_Handlers::CCMComponentPortKind const& PlanSubcomponentPortEndpoint::
+    kind () const
+    {
+      return *kind_;
+    }
+
+    ::CIAO::Config_Handlers::CCMComponentPortKind& PlanSubcomponentPortEndpoint::
+    kind ()
+    {
+      return *kind_;
+    }
+
+    void PlanSubcomponentPortEndpoint::
+    kind (::CIAO::Config_Handlers::CCMComponentPortKind const& e)
+    {
+      *kind_ = e;
+    }
+
+    // PlanSubcomponentPortEndpoint
+    // 
+    ::XMLSchema::IDREF< char > const& PlanSubcomponentPortEndpoint::
+    instance () const
+    {
+      return *instance_;
+    }
+
+    ::XMLSchema::IDREF< char >& PlanSubcomponentPortEndpoint::
+    instance ()
+    {
+      return *instance_;
+    }
+
+    void PlanSubcomponentPortEndpoint::
+    instance (::XMLSchema::IDREF< char > const& e)
+    {
+      *instance_ = e;
+    }
+
+
+    // ExternalReferenceEndpoint
+    // 
+
+    ExternalReferenceEndpoint::
+    ExternalReferenceEndpoint ()
+    :
+    location_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      location_->container (this);
+    }
+
+    ExternalReferenceEndpoint::
+    ExternalReferenceEndpoint (::CIAO::Config_Handlers::ExternalReferenceEndpoint const& s)
+    :
+    location_ (new ::XMLSchema::string< char > (*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< char > const& ExternalReferenceEndpoint::
+    location () const
+    {
+      return *location_;
+    }
+
+    ::XMLSchema::string< char >& ExternalReferenceEndpoint::
+    location ()
+    {
+      return *location_;
+    }
+
+    void ExternalReferenceEndpoint::
+    location (::XMLSchema::string< char > const& e)
+    {
+      *location_ = e;
+    }
+
+
+    // ConnectionResourceDeploymentDescription
+    // 
+
+    ConnectionResourceDeploymentDescription::
+    ConnectionResourceDeploymentDescription ()
+    :
+    targetName_ (new ::XMLSchema::string< char > ()),
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      targetName_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    ConnectionResourceDeploymentDescription::
+    ConnectionResourceDeploymentDescription (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s)
+    :
+    targetName_ (new ::XMLSchema::string< char > (*s.targetName_)),
+    requirementName_ (new ::XMLSchema::string< char > (*s.requirementName_)),
+    resourceName_ (new ::XMLSchema::string< char > (*s.resourceName_)),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any (*s.resourceValue_)),
+    regulator__ ()
+    {
+      targetName_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription& ConnectionResourceDeploymentDescription::
+    operator= (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& s)
+    {
+      targetName (s.targetName ());
+
+      requirementName (s.requirementName ());
+
+      resourceName (s.resourceName ());
+
+      resourceValue (s.resourceValue ());
+
+      return *this;
+    }
+
+
+    // ConnectionResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ConnectionResourceDeploymentDescription::
+    targetName () const
+    {
+      return *targetName_;
+    }
+
+    ::XMLSchema::string< char >& ConnectionResourceDeploymentDescription::
+    targetName ()
+    {
+      return *targetName_;
+    }
+
+    void ConnectionResourceDeploymentDescription::
+    targetName (::XMLSchema::string< char > const& e)
+    {
+      *targetName_ = e;
+    }
+
+    // ConnectionResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ConnectionResourceDeploymentDescription::
+    requirementName () const
+    {
+      return *requirementName_;
+    }
+
+    ::XMLSchema::string< char >& ConnectionResourceDeploymentDescription::
+    requirementName ()
+    {
+      return *requirementName_;
+    }
+
+    void ConnectionResourceDeploymentDescription::
+    requirementName (::XMLSchema::string< char > const& e)
+    {
+      *requirementName_ = e;
+    }
+
+    // ConnectionResourceDeploymentDescription
+    // 
+    ::XMLSchema::string< char > const& ConnectionResourceDeploymentDescription::
+    resourceName () const
+    {
+      return *resourceName_;
+    }
+
+    ::XMLSchema::string< char >& ConnectionResourceDeploymentDescription::
+    resourceName ()
+    {
+      return *resourceName_;
+    }
+
+    void ConnectionResourceDeploymentDescription::
+    resourceName (::XMLSchema::string< char > const& e)
+    {
+      *resourceName_ = e;
+    }
+
+    // ConnectionResourceDeploymentDescription
+    // 
+    ::CIAO::Config_Handlers::Any const& ConnectionResourceDeploymentDescription::
+    resourceValue () const
+    {
+      return *resourceValue_;
+    }
+
+    ::CIAO::Config_Handlers::Any& ConnectionResourceDeploymentDescription::
+    resourceValue ()
+    {
+      return *resourceValue_;
+    }
+
+    void ConnectionResourceDeploymentDescription::
+    resourceValue (::CIAO::Config_Handlers::Any const& e)
+    {
+      *resourceValue_ = e;
+    }
+
+
+    // PlanConnectionDescription
+    // 
+
+    PlanConnectionDescription::
+    PlanConnectionDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+    }
+
+    PlanConnectionDescription::
+    PlanConnectionDescription (::CIAO::Config_Handlers::PlanConnectionDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    source_ (s.source_.get () ? new ::XMLSchema::string< char > (*s.source_) : 0),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.deployRequirement_) : 0),
+    deployedResource_ (s.deployedResource_.get () ? new ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription (*s.deployedResource_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      if (source_.get ()) source_->container (this);
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+      externalEndpoint_.reserve (s.externalEndpoint_.size ());
+      {
+        for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());
+        i != s.externalEndpoint_.end ();
+        ++i) add_externalEndpoint (*i);
+      }
+
+      internalEndpoint_.reserve (s.internalEndpoint_.size ());
+      {
+        for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());
+        i != s.internalEndpoint_.end ();
+        ++i) add_internalEndpoint (*i);
+      }
+
+      externalReference_.reserve (s.externalReference_.size ());
+      {
+        for (externalReference_const_iterator i (s.externalReference_.begin ());
+        i != s.externalReference_.end ();
+        ++i) add_externalReference (*i);
+      }
+
+      if (deployedResource_.get ()) deployedResource_->container (this);
+    }
+
+    ::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< char > > (0);
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      externalEndpoint_.clear ();
+      externalEndpoint_.reserve (s.externalEndpoint_.size ());
+      {
+        for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());
+        i != s.externalEndpoint_.end ();
+        ++i) add_externalEndpoint (*i);
+      }
+
+      internalEndpoint_.clear ();
+      internalEndpoint_.reserve (s.internalEndpoint_.size ());
+      {
+        for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());
+        i != s.internalEndpoint_.end ();
+        ++i) add_internalEndpoint (*i);
+      }
+
+      externalReference_.clear ();
+      externalReference_.reserve (s.externalReference_.size ());
+      {
+        for (externalReference_const_iterator i (s.externalReference_.begin ());
+        i != s.externalReference_.end ();
+        ++i) add_externalReference (*i);
+      }
+
+      if (s.deployedResource_.get ()) deployedResource (*(s.deployedResource_));
+      else deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription > (0);
+
+      return *this;
+    }
+
+
+    // PlanConnectionDescription
+    // 
+    ::XMLSchema::string< char > const& PlanConnectionDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& PlanConnectionDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void PlanConnectionDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // PlanConnectionDescription
+    // 
+    bool PlanConnectionDescription::
+    source_p () const
+    {
+      return source_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& PlanConnectionDescription::
+    source () const
+    {
+      return *source_;
+    }
+
+    ::XMLSchema::string< char >& PlanConnectionDescription::
+    source ()
+    {
+      return *source_;
+    }
+
+    void PlanConnectionDescription::
+    source (::XMLSchema::string< char > const& e)
+    {
+      if (source_.get ())
+      {
+        *source_ = e;
+      }
+
+      else
+      {
+        source_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        source_->container (this);
+      }
+    }
+
+    // PlanConnectionDescription
+    // 
+    bool PlanConnectionDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& PlanConnectionDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& PlanConnectionDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void PlanConnectionDescription::
+    deployRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+    // 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)
+    {
+      if (externalEndpoint_.capacity () < externalEndpoint_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > v;
+        v.reserve (externalEndpoint_.size () + 1);
+
+        while (externalEndpoint_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ComponentExternalPortEndpoint& t = externalEndpoint_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          externalEndpoint_.pop_back ();
+        }
+
+        externalEndpoint_.swap (v);
+      }
+
+      externalEndpoint_.push_back (e);
+      externalEndpoint_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (internalEndpoint_.capacity () < internalEndpoint_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint > v;
+        v.reserve (internalEndpoint_.size () + 1);
+
+        while (internalEndpoint_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint& t = internalEndpoint_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          internalEndpoint_.pop_back ();
+        }
+
+        internalEndpoint_.swap (v);
+      }
+
+      internalEndpoint_.push_back (e);
+      internalEndpoint_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (externalReference_.capacity () < externalReference_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > v;
+        v.reserve (externalReference_.size () + 1);
+
+        while (externalReference_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ExternalReferenceEndpoint& t = externalReference_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          externalReference_.pop_back ();
+        }
+
+        externalReference_.swap (v);
+      }
+
+      externalReference_.push_back (e);
+      externalReference_.back ().container (this);
+    }
+
+    // PlanConnectionDescription
+    // 
+    bool PlanConnectionDescription::
+    deployedResource_p () const
+    {
+      return deployedResource_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& PlanConnectionDescription::
+    deployedResource () const
+    {
+      return *deployedResource_;
+    }
+
+    ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription& PlanConnectionDescription::
+    deployedResource ()
+    {
+      return *deployedResource_;
+    }
+
+    void PlanConnectionDescription::
+    deployedResource (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& e)
+    {
+      if (deployedResource_.get ())
+      {
+        *deployedResource_ = e;
+      }
+
+      else
+      {
+        deployedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription > (new ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription (e));
+        deployedResource_->container (this);
+      }
+    }
+
+
+    // ImplementationDependency
+    // 
+
+    ImplementationDependency::
+    ImplementationDependency ()
+    :
+    requiredType_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      requiredType_->container (this);
+    }
+
+    ImplementationDependency::
+    ImplementationDependency (::CIAO::Config_Handlers::ImplementationDependency const& s)
+    :
+    requiredType_ (new ::XMLSchema::string< char > (*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< char > const& ImplementationDependency::
+    requiredType () const
+    {
+      return *requiredType_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationDependency::
+    requiredType ()
+    {
+      return *requiredType_;
+    }
+
+    void ImplementationDependency::
+    requiredType (::XMLSchema::string< char > const& e)
+    {
+      *requiredType_ = e;
+    }
+
+
+    // Capability
+    // 
+
+    Capability::
+    Capability ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+    }
+
+    Capability::
+    Capability (::CIAO::Config_Handlers::Capability const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    resourceType_ (new ::XMLSchema::string< char > (*s.resourceType_)),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty (*s.property_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::Capability& Capability::
+    operator= (::CIAO::Config_Handlers::Capability const& s)
+    {
+      name (s.name ());
+
+      resourceType (s.resourceType ());
+
+      property (s.property ());
+
+      return *this;
+    }
+
+
+    // Capability
+    // 
+    ::XMLSchema::string< char > const& Capability::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& Capability::
+    name ()
+    {
+      return *name_;
+    }
+
+    void Capability::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // Capability
+    // 
+    ::XMLSchema::string< char > const& Capability::
+    resourceType () const
+    {
+      return *resourceType_;
+    }
+
+    ::XMLSchema::string< char >& Capability::
+    resourceType ()
+    {
+      return *resourceType_;
+    }
+
+    void Capability::
+    resourceType (::XMLSchema::string< char > const& e)
+    {
+      *resourceType_ = e;
+    }
+
+    // Capability
+    // 
+    ::CIAO::Config_Handlers::SatisfierProperty const& Capability::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::SatisfierProperty& Capability::
+    property ()
+    {
+      return *property_;
+    }
+
+    void Capability::
+    property (::CIAO::Config_Handlers::SatisfierProperty const& e)
+    {
+      *property_ = e;
+    }
+
+
+    // ImplementationRequirement
+    // 
+
+    ImplementationRequirement::
+    ImplementationRequirement ()
+    :
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind ()),
+    resourcePort_ (new ::XMLSchema::string< char > ()),
+    componentPort_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    name_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::Property ()),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      resourcePort_->container (this);
+      componentPort_->container (this);
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+    }
+
+    ImplementationRequirement::
+    ImplementationRequirement (::CIAO::Config_Handlers::ImplementationRequirement const& s)
+    :
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind (*s.resourceUsage_)),
+    resourcePort_ (new ::XMLSchema::string< char > (*s.resourcePort_)),
+    componentPort_ (new ::XMLSchema::string< char > (*s.componentPort_)),
+    resourceType_ (new ::XMLSchema::string< char > (*s.resourceType_)),
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    property_ (new ::CIAO::Config_Handlers::Property (*s.property_)),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      resourcePort_->container (this);
+      componentPort_->container (this);
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ImplementationRequirement& ImplementationRequirement::
+    operator= (::CIAO::Config_Handlers::ImplementationRequirement const& s)
+    {
+      resourceUsage (s.resourceUsage ());
+
+      resourcePort (s.resourcePort ());
+
+      componentPort (s.componentPort ());
+
+      resourceType (s.resourceType ());
+
+      name (s.name ());
+
+      property (s.property ());
+
+      return *this;
+    }
+
+
+    // ImplementationRequirement
+    // 
+    ::CIAO::Config_Handlers::ResourceUsageKind const& ImplementationRequirement::
+    resourceUsage () const
+    {
+      return *resourceUsage_;
+    }
+
+    ::CIAO::Config_Handlers::ResourceUsageKind& ImplementationRequirement::
+    resourceUsage ()
+    {
+      return *resourceUsage_;
+    }
+
+    void ImplementationRequirement::
+    resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& e)
+    {
+      *resourceUsage_ = e;
+    }
+
+    // ImplementationRequirement
+    // 
+    ::XMLSchema::string< char > const& ImplementationRequirement::
+    resourcePort () const
+    {
+      return *resourcePort_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationRequirement::
+    resourcePort ()
+    {
+      return *resourcePort_;
+    }
+
+    void ImplementationRequirement::
+    resourcePort (::XMLSchema::string< char > const& e)
+    {
+      *resourcePort_ = e;
+    }
+
+    // ImplementationRequirement
+    // 
+    ::XMLSchema::string< char > const& ImplementationRequirement::
+    componentPort () const
+    {
+      return *componentPort_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationRequirement::
+    componentPort ()
+    {
+      return *componentPort_;
+    }
+
+    void ImplementationRequirement::
+    componentPort (::XMLSchema::string< char > const& e)
+    {
+      *componentPort_ = e;
+    }
+
+    // ImplementationRequirement
+    // 
+    ::XMLSchema::string< char > const& ImplementationRequirement::
+    resourceType () const
+    {
+      return *resourceType_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationRequirement::
+    resourceType ()
+    {
+      return *resourceType_;
+    }
+
+    void ImplementationRequirement::
+    resourceType (::XMLSchema::string< char > const& e)
+    {
+      *resourceType_ = e;
+    }
+
+    // ImplementationRequirement
+    // 
+    ::XMLSchema::string< char > const& ImplementationRequirement::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationRequirement::
+    name ()
+    {
+      return *name_;
+    }
+
+    void ImplementationRequirement::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // ImplementationRequirement
+    // 
+    ::CIAO::Config_Handlers::Property const& ImplementationRequirement::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ImplementationRequirement::
+    property ()
+    {
+      return *property_;
+    }
+
+    void ImplementationRequirement::
+    property (::CIAO::Config_Handlers::Property const& e)
+    {
+      *property_ = e;
+    }
+
+
+    // ComponentPackageReference
+    // 
+
+    ComponentPackageReference::
+    ComponentPackageReference ()
+    :
+    requiredUUID_ (new ::XMLSchema::string< char > ()),
+    requiredName_ (new ::XMLSchema::string< char > ()),
+    requiredType_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      requiredUUID_->container (this);
+      requiredName_->container (this);
+      requiredType_->container (this);
+    }
+
+    ComponentPackageReference::
+    ComponentPackageReference (::CIAO::Config_Handlers::ComponentPackageReference const& s)
+    :
+    requiredUUID_ (new ::XMLSchema::string< char > (*s.requiredUUID_)),
+    requiredName_ (new ::XMLSchema::string< char > (*s.requiredName_)),
+    requiredType_ (new ::XMLSchema::string< char > (*s.requiredType_)),
+    regulator__ ()
+    {
+      requiredUUID_->container (this);
+      requiredName_->container (this);
+      requiredType_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageReference& ComponentPackageReference::
+    operator= (::CIAO::Config_Handlers::ComponentPackageReference const& s)
+    {
+      requiredUUID (s.requiredUUID ());
+
+      requiredName (s.requiredName ());
+
+      requiredType (s.requiredType ());
+
+      return *this;
+    }
+
+
+    // ComponentPackageReference
+    // 
+    ::XMLSchema::string< char > const& ComponentPackageReference::
+    requiredUUID () const
+    {
+      return *requiredUUID_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageReference::
+    requiredUUID ()
+    {
+      return *requiredUUID_;
+    }
+
+    void ComponentPackageReference::
+    requiredUUID (::XMLSchema::string< char > const& e)
+    {
+      *requiredUUID_ = e;
+    }
+
+    // ComponentPackageReference
+    // 
+    ::XMLSchema::string< char > const& ComponentPackageReference::
+    requiredName () const
+    {
+      return *requiredName_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageReference::
+    requiredName ()
+    {
+      return *requiredName_;
+    }
+
+    void ComponentPackageReference::
+    requiredName (::XMLSchema::string< char > const& e)
+    {
+      *requiredName_ = e;
+    }
+
+    // ComponentPackageReference
+    // 
+    ::XMLSchema::string< char > const& ComponentPackageReference::
+    requiredType () const
+    {
+      return *requiredType_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageReference::
+    requiredType ()
+    {
+      return *requiredType_;
+    }
+
+    void ComponentPackageReference::
+    requiredType (::XMLSchema::string< char > const& e)
+    {
+      *requiredType_ = e;
+    }
+
+
+    // SubcomponentPortEndpoint
+    // 
+
+    SubcomponentPortEndpoint::
+    SubcomponentPortEndpoint ()
+    :
+    portName_ (new ::XMLSchema::string< char > ()),
+    instance_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+      instance_->container (this);
+    }
+
+    SubcomponentPortEndpoint::
+    SubcomponentPortEndpoint (::CIAO::Config_Handlers::SubcomponentPortEndpoint const& s)
+    :
+    portName_ (new ::XMLSchema::string< char > (*s.portName_)),
+    instance_ (new ::XMLSchema::IDREF< char > (*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< char > const& SubcomponentPortEndpoint::
+    portName () const
+    {
+      return *portName_;
+    }
+
+    ::XMLSchema::string< char >& SubcomponentPortEndpoint::
+    portName ()
+    {
+      return *portName_;
+    }
+
+    void SubcomponentPortEndpoint::
+    portName (::XMLSchema::string< char > const& e)
+    {
+      *portName_ = e;
+    }
+
+    // SubcomponentPortEndpoint
+    // 
+    ::XMLSchema::IDREF< char > const& SubcomponentPortEndpoint::
+    instance () const
+    {
+      return *instance_;
+    }
+
+    ::XMLSchema::IDREF< char >& SubcomponentPortEndpoint::
+    instance ()
+    {
+      return *instance_;
+    }
+
+    void SubcomponentPortEndpoint::
+    instance (::XMLSchema::IDREF< char > const& e)
+    {
+      *instance_ = e;
+    }
+
+
+    // AssemblyConnectionDescription
+    // 
+
+    AssemblyConnectionDescription::
+    AssemblyConnectionDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+    }
+
+    AssemblyConnectionDescription::
+    AssemblyConnectionDescription (::CIAO::Config_Handlers::AssemblyConnectionDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.deployRequirement_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+      externalEndpoint_.reserve (s.externalEndpoint_.size ());
+      {
+        for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());
+        i != s.externalEndpoint_.end ();
+        ++i) add_externalEndpoint (*i);
+      }
+
+      internalEndpoint_.reserve (s.internalEndpoint_.size ());
+      {
+        for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());
+        i != s.internalEndpoint_.end ();
+        ++i) add_internalEndpoint (*i);
+      }
+
+      externalReference_.reserve (s.externalReference_.size ());
+      {
+        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 ());
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      externalEndpoint_.clear ();
+      externalEndpoint_.reserve (s.externalEndpoint_.size ());
+      {
+        for (externalEndpoint_const_iterator i (s.externalEndpoint_.begin ());
+        i != s.externalEndpoint_.end ();
+        ++i) add_externalEndpoint (*i);
+      }
+
+      internalEndpoint_.clear ();
+      internalEndpoint_.reserve (s.internalEndpoint_.size ());
+      {
+        for (internalEndpoint_const_iterator i (s.internalEndpoint_.begin ());
+        i != s.internalEndpoint_.end ();
+        ++i) add_internalEndpoint (*i);
+      }
+
+      externalReference_.clear ();
+      externalReference_.reserve (s.externalReference_.size ());
+      {
+        for (externalReference_const_iterator i (s.externalReference_.begin ());
+        i != s.externalReference_.end ();
+        ++i) add_externalReference (*i);
+      }
+
+      return *this;
+    }
+
+
+    // AssemblyConnectionDescription
+    // 
+    ::XMLSchema::string< char > const& AssemblyConnectionDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& AssemblyConnectionDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void AssemblyConnectionDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // AssemblyConnectionDescription
+    // 
+    bool AssemblyConnectionDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& AssemblyConnectionDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& AssemblyConnectionDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void AssemblyConnectionDescription::
+    deployRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+    // 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)
+    {
+      if (externalEndpoint_.capacity () < externalEndpoint_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > v;
+        v.reserve (externalEndpoint_.size () + 1);
+
+        while (externalEndpoint_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ComponentExternalPortEndpoint& t = externalEndpoint_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          externalEndpoint_.pop_back ();
+        }
+
+        externalEndpoint_.swap (v);
+      }
+
+      externalEndpoint_.push_back (e);
+      externalEndpoint_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (internalEndpoint_.capacity () < internalEndpoint_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::SubcomponentPortEndpoint > v;
+        v.reserve (internalEndpoint_.size () + 1);
+
+        while (internalEndpoint_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::SubcomponentPortEndpoint& t = internalEndpoint_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          internalEndpoint_.pop_back ();
+        }
+
+        internalEndpoint_.swap (v);
+      }
+
+      internalEndpoint_.push_back (e);
+      internalEndpoint_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (externalReference_.capacity () < externalReference_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > v;
+        v.reserve (externalReference_.size () + 1);
+
+        while (externalReference_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ExternalReferenceEndpoint& t = externalReference_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          externalReference_.pop_back ();
+        }
+
+        externalReference_.swap (v);
+      }
+
+      externalReference_.push_back (e);
+      externalReference_.back ().container (this);
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // TCKind
+    //
+
+    TCKind::
+    TCKind (::XSCRT::XML::Element< char > const& e)
+    : Type (e)
+    {
+      ::std::basic_string< char > 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< char > const& a)
+    : Type (a)
+    {
+      ::std::basic_string< char > 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< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "kind")
+        {
+          ::CIAO::Config_Handlers::TCKind t (e);
+          kind (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // DataValue
+    //
+
+    DataValue::
+    DataValue (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "short")
+        {
+          ::XMLSchema::short_ t (e);
+          short_ (t);
+        }
+
+        else if (n == "long")
+        {
+          ::XMLSchema::int_ t (e);
+          long_ (t);
+        }
+
+        else if (n == "ushort")
+        {
+          ::XMLSchema::unsignedShort t (e);
+          ushort (t);
+        }
+
+        else if (n == "ulong")
+        {
+          ::XMLSchema::unsignedInt t (e);
+          ulong (t);
+        }
+
+        else if (n == "float")
+        {
+          ::XMLSchema::float_ t (e);
+          float_ (t);
+        }
+
+        else if (n == "double")
+        {
+          ::XMLSchema::double_ t (e);
+          double_ (t);
+        }
+
+        else if (n == "boolean")
+        {
+          ::XMLSchema::boolean t (e);
+          boolean (t);
+        }
+
+        else if (n == "octet")
+        {
+          ::XMLSchema::unsignedByte t (e);
+          octet (t);
+        }
+
+        else if (n == "objref")
+        {
+          ::XMLSchema::string< char > t (e);
+          objref (t);
+        }
+
+        else if (n == "enum")
+        {
+          ::XMLSchema::string< char > t (e);
+          enum_ (t);
+        }
+
+        else if (n == "string")
+        {
+          ::XMLSchema::string< char > t (e);
+          string (t);
+        }
+
+        else if (n == "longlong")
+        {
+          ::XMLSchema::long_ t (e);
+          longlong (t);
+        }
+
+        else if (n == "ulonglong")
+        {
+          ::XMLSchema::unsignedLong t (e);
+          ulonglong (t);
+        }
+
+        else if (n == "longdouble")
+        {
+          ::XMLSchema::double_ t (e);
+          longdouble (t);
+        }
+
+        else if (n == "fixed")
+        {
+          ::XMLSchema::string< char > t (e);
+          fixed (t);
+        }
+
+        else if (n == "typecode")
+        {
+          ::CIAO::Config_Handlers::DataType t (e);
+          typecode (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Any
+    //
+
+    Any::
+    Any (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    type_ (new ::CIAO::Config_Handlers::DataType ()),
+    value_ (new ::CIAO::Config_Handlers::DataValue ()),
+    regulator__ ()
+    {
+      type_->container (this);
+      value_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "type")
+        {
+          ::CIAO::Config_Handlers::DataType t (e);
+          type (t);
+        }
+
+        else if (n == "value")
+        {
+          ::CIAO::Config_Handlers::DataValue t (e);
+          value (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Property
+    //
+
+    Property::
+    Property (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    value_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      value_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "value")
+        {
+          ::CIAO::Config_Handlers::Any t (e);
+          value (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Node
+    //
+
+    Node::
+    Node (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    label_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      label_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // SatisfierPropertyKind
+    //
+
+    SatisfierPropertyKind::
+    SatisfierPropertyKind (::XSCRT::XML::Element< char > const& e)
+    : Type (e)
+    {
+      ::std::basic_string< char > 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< char > const& a)
+    : Type (a)
+    {
+      ::std::basic_string< char > 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< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::SatisfierPropertyKind ()),
+    value_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      kind_->container (this);
+      value_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "kind")
+        {
+          ::CIAO::Config_Handlers::SatisfierPropertyKind t (e);
+          kind (t);
+        }
+
+        else if (n == "value")
+        {
+          ::CIAO::Config_Handlers::Any t (e);
+          value (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Resource
+    //
+
+    Resource::
+    Resource (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "resourceType")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceType (t);
+        }
+
+        else if (n == "property")
+        {
+          ::CIAO::Config_Handlers::SatisfierProperty t (e);
+          property (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // SharedResource
+    //
+
+    SharedResource::
+    SharedResource (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    node_ (new ::CIAO::Config_Handlers::Node ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      node_->container (this);
+      property_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "resourceType")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceType (t);
+        }
+
+        else if (n == "node")
+        {
+          ::CIAO::Config_Handlers::Node t (e);
+          node (t);
+        }
+
+        else if (n == "property")
+        {
+          ::CIAO::Config_Handlers::SatisfierProperty t (e);
+          property (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Requirement
+    //
+
+    Requirement::
+    Requirement (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    name_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::Property ()),
+    regulator__ ()
+    {
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "resourceType")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceType (t);
+        }
+
+        else if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "property")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          property (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ResourceDeploymentDescription
+    //
+
+    ResourceDeploymentDescription::
+    ResourceDeploymentDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "requirementName")
+        {
+          ::XMLSchema::string< char > t (e);
+          requirementName (t);
+        }
+
+        else if (n == "resourceName")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceName (t);
+        }
+
+        else if (n == "resourceValue")
+        {
+          ::CIAO::Config_Handlers::Any t (e);
+          resourceValue (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ArtifactDeploymentDescription
+    //
+
+    ArtifactDeploymentDescription::
+    ArtifactDeploymentDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "source")
+        {
+          ::XMLSchema::string< char > t (e);
+          source (t);
+        }
+
+        else if (n == "node")
+        {
+          ::XMLSchema::string< char > t (e);
+          node (t);
+        }
+
+        else if (n == "location")
+        {
+          ::XMLSchema::string< char > t (e);
+          add_location (t);
+        }
+
+        else if (n == "execParameter")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          execParameter (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          deployRequirement (t);
+        }
+
+        else if (n == "deployedResource")
+        {
+          ::CIAO::Config_Handlers::ResourceDeploymentDescription t (e);
+          deployedResource (t);
+        }
+
+        else 
+        {
+        }
+      }
+
+      while (p.more_attributes ())
+      {
+        ::XSCRT::XML::Attribute< char > a (p.next_attribute ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (a.name ()));
+        if (n == "id")
+        {
+          ::XMLSchema::ID< char > t (a);
+          id (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // MonolithicDeploymentDescription
+    //
+
+    MonolithicDeploymentDescription::
+    MonolithicDeploymentDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      source_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "source")
+        {
+          ::XMLSchema::string< char > t (e);
+          source (t);
+        }
+
+        else if (n == "artifact")
+        {
+          ::XMLSchema::IDREF< char > t (e);
+          add_artifact (t);
+        }
+
+        else if (n == "execParameter")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          execParameter (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          deployRequirement (t);
+        }
+
+        else 
+        {
+        }
+      }
+
+      while (p.more_attributes ())
+      {
+        ::XSCRT::XML::Attribute< char > a (p.next_attribute ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (a.name ()));
+        if (n == "id")
+        {
+          ::XMLSchema::ID< char > t (a);
+          id (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ResourceUsageKind
+    //
+
+    ResourceUsageKind::
+    ResourceUsageKind (::XSCRT::XML::Element< char > const& e)
+    : Type (e)
+    {
+      ::std::basic_string< char > 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< char > const& a)
+    : Type (a)
+    {
+      ::std::basic_string< char > 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< char > const& e)
+    :
+    Base__ (e),
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind ()),
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "resourceUsage")
+        {
+          ::CIAO::Config_Handlers::ResourceUsageKind t (e);
+          resourceUsage (t);
+        }
+
+        else if (n == "requirementName")
+        {
+          ::XMLSchema::string< char > t (e);
+          requirementName (t);
+        }
+
+        else if (n == "resourceName")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceName (t);
+        }
+
+        else if (n == "resourceValue")
+        {
+          ::CIAO::Config_Handlers::Any t (e);
+          resourceValue (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // InstanceDeploymentDescription
+    //
+
+    InstanceDeploymentDescription::
+    InstanceDeploymentDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    node_ (new ::XMLSchema::string< char > ()),
+    source_ (new ::XMLSchema::string< char > ()),
+    implementation_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      node_->container (this);
+      source_->container (this);
+      implementation_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "node")
+        {
+          ::XMLSchema::string< char > t (e);
+          node (t);
+        }
+
+        else if (n == "source")
+        {
+          ::XMLSchema::string< char > t (e);
+          source (t);
+        }
+
+        else if (n == "implementation")
+        {
+          ::XMLSchema::IDREF< char > t (e);
+          implementation (t);
+        }
+
+        else if (n == "configProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          configProperty (t);
+        }
+
+        else if (n == "deployedResource")
+        {
+          ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e);
+          deployedResource (t);
+        }
+
+        else if (n == "deployedSharedResource")
+        {
+          ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription t (e);
+          deployedSharedResource (t);
+        }
+
+        else 
+        {
+        }
+      }
+
+      while (p.more_attributes ())
+      {
+        ::XSCRT::XML::Attribute< char > a (p.next_attribute ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (a.name ()));
+        if (n == "id")
+        {
+          ::XMLSchema::ID< char > t (a);
+          id (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // CCMComponentPortKind
+    //
+
+    CCMComponentPortKind::
+    CCMComponentPortKind (::XSCRT::XML::Element< char > const& e)
+    : Type (e)
+    {
+      ::std::basic_string< char > 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< char > const& a)
+    : Type (a)
+    {
+      ::std::basic_string< char > 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< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    specificType_ (new ::XMLSchema::string< char > ()),
+    supportedType_ (new ::XMLSchema::string< char > ()),
+    provider_ (new ::XMLSchema::string< char > ()),
+    exclusiveProvider_ (new ::XMLSchema::string< char > ()),
+    exclusiveUser_ (new ::XMLSchema::string< char > ()),
+    optional_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      specificType_->container (this);
+      supportedType_->container (this);
+      provider_->container (this);
+      exclusiveProvider_->container (this);
+      exclusiveUser_->container (this);
+      optional_->container (this);
+      kind_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "specificType")
+        {
+          ::XMLSchema::string< char > t (e);
+          specificType (t);
+        }
+
+        else if (n == "supportedType")
+        {
+          ::XMLSchema::string< char > t (e);
+          supportedType (t);
+        }
+
+        else if (n == "provider")
+        {
+          ::XMLSchema::string< char > t (e);
+          provider (t);
+        }
+
+        else if (n == "exclusiveProvider")
+        {
+          ::XMLSchema::string< char > t (e);
+          exclusiveProvider (t);
+        }
+
+        else if (n == "exclusiveUser")
+        {
+          ::XMLSchema::string< char > t (e);
+          exclusiveUser (t);
+        }
+
+        else if (n == "optional")
+        {
+          ::XMLSchema::string< char > t (e);
+          optional (t);
+        }
+
+        else if (n == "kind")
+        {
+          ::CIAO::Config_Handlers::CCMComponentPortKind t (e);
+          kind (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentPropertyDescription
+    //
+
+    ComponentPropertyDescription::
+    ComponentPropertyDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    type_ (new ::CIAO::Config_Handlers::DataType ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      type_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "type")
+        {
+          ::CIAO::Config_Handlers::DataType t (e);
+          type (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentExternalPortEndpoint
+    //
+
+    ComponentExternalPortEndpoint::
+    ComponentExternalPortEndpoint (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    portName_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "portName")
+        {
+          ::XMLSchema::string< char > t (e);
+          portName (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // PlanSubcomponentPortEndpoint
+    //
+
+    PlanSubcomponentPortEndpoint::
+    PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    portName_ (new ::XMLSchema::string< char > ()),
+    kind_ (new ::CIAO::Config_Handlers::CCMComponentPortKind ()),
+    instance_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+      kind_->container (this);
+      instance_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "portName")
+        {
+          ::XMLSchema::string< char > t (e);
+          portName (t);
+        }
+
+        else if (n == "provider")
+        {
+          ::XMLSchema::string< char > t (e);
+          provider (t);
+        }
+
+        else if (n == "kind")
+        {
+          ::CIAO::Config_Handlers::CCMComponentPortKind t (e);
+          kind (t);
+        }
+
+        else if (n == "instance")
+        {
+          ::XMLSchema::IDREF< char > t (e);
+          instance (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ExternalReferenceEndpoint
+    //
+
+    ExternalReferenceEndpoint::
+    ExternalReferenceEndpoint (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    location_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      location_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "location")
+        {
+          ::XMLSchema::string< char > t (e);
+          location (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ConnectionResourceDeploymentDescription
+    //
+
+    ConnectionResourceDeploymentDescription::
+    ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    targetName_ (new ::XMLSchema::string< char > ()),
+    requirementName_ (new ::XMLSchema::string< char > ()),
+    resourceName_ (new ::XMLSchema::string< char > ()),
+    resourceValue_ (new ::CIAO::Config_Handlers::Any ()),
+    regulator__ ()
+    {
+      targetName_->container (this);
+      requirementName_->container (this);
+      resourceName_->container (this);
+      resourceValue_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "targetName")
+        {
+          ::XMLSchema::string< char > t (e);
+          targetName (t);
+        }
+
+        else if (n == "requirementName")
+        {
+          ::XMLSchema::string< char > t (e);
+          requirementName (t);
+        }
+
+        else if (n == "resourceName")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceName (t);
+        }
+
+        else if (n == "resourceValue")
+        {
+          ::CIAO::Config_Handlers::Any t (e);
+          resourceValue (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // PlanConnectionDescription
+    //
+
+    PlanConnectionDescription::
+    PlanConnectionDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "source")
+        {
+          ::XMLSchema::string< char > t (e);
+          source (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          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);
+          deployedResource (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ImplementationDependency
+    //
+
+    ImplementationDependency::
+    ImplementationDependency (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    requiredType_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      requiredType_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "requiredType")
+        {
+          ::XMLSchema::string< char > t (e);
+          requiredType (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // Capability
+    //
+
+    Capability::
+    Capability (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::SatisfierProperty ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      resourceType_->container (this);
+      property_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "resourceType")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceType (t);
+        }
+
+        else if (n == "property")
+        {
+          ::CIAO::Config_Handlers::SatisfierProperty t (e);
+          property (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ImplementationRequirement
+    //
+
+    ImplementationRequirement::
+    ImplementationRequirement (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    resourceUsage_ (new ::CIAO::Config_Handlers::ResourceUsageKind ()),
+    resourcePort_ (new ::XMLSchema::string< char > ()),
+    componentPort_ (new ::XMLSchema::string< char > ()),
+    resourceType_ (new ::XMLSchema::string< char > ()),
+    name_ (new ::XMLSchema::string< char > ()),
+    property_ (new ::CIAO::Config_Handlers::Property ()),
+    regulator__ ()
+    {
+      resourceUsage_->container (this);
+      resourcePort_->container (this);
+      componentPort_->container (this);
+      resourceType_->container (this);
+      name_->container (this);
+      property_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "resourceUsage")
+        {
+          ::CIAO::Config_Handlers::ResourceUsageKind t (e);
+          resourceUsage (t);
+        }
+
+        else if (n == "resourcePort")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourcePort (t);
+        }
+
+        else if (n == "componentPort")
+        {
+          ::XMLSchema::string< char > t (e);
+          componentPort (t);
+        }
+
+        else if (n == "resourceType")
+        {
+          ::XMLSchema::string< char > t (e);
+          resourceType (t);
+        }
+
+        else if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "property")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          property (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentPackageReference
+    //
+
+    ComponentPackageReference::
+    ComponentPackageReference (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    requiredUUID_ (new ::XMLSchema::string< char > ()),
+    requiredName_ (new ::XMLSchema::string< char > ()),
+    requiredType_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      requiredUUID_->container (this);
+      requiredName_->container (this);
+      requiredType_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "requiredUUID")
+        {
+          ::XMLSchema::string< char > t (e);
+          requiredUUID (t);
+        }
+
+        else if (n == "requiredName")
+        {
+          ::XMLSchema::string< char > t (e);
+          requiredName (t);
+        }
+
+        else if (n == "requiredType")
+        {
+          ::XMLSchema::string< char > t (e);
+          requiredType (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // SubcomponentPortEndpoint
+    //
+
+    SubcomponentPortEndpoint::
+    SubcomponentPortEndpoint (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    portName_ (new ::XMLSchema::string< char > ()),
+    instance_ (new ::XMLSchema::IDREF< char > ()),
+    regulator__ ()
+    {
+      portName_->container (this);
+      instance_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "portName")
+        {
+          ::XMLSchema::string< char > t (e);
+          portName (t);
+        }
+
+        else if (n == "instance")
+        {
+          ::XMLSchema::IDREF< char > t (e);
+          instance (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // AssemblyConnectionDescription
+    //
+
+    AssemblyConnectionDescription::
+    AssemblyConnectionDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      name_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          deployRequirement (t);
+        }
+
+        else if (n == "externalEndpoint")
+        {
+          ::CIAO::Config_Handlers::ComponentExternalPortEndpoint t (e);
+          add_externalEndpoint (t);
+        }
+
+        else if (n == "internalEndpoint")
+        {
+          ::CIAO::Config_Handlers::SubcomponentPortEndpoint t (e);
+          add_internalEndpoint (t);
+        }
+
+        else if (n == "externalReference")
+        {
+          ::CIAO::Config_Handlers::ExternalReferenceEndpoint t (e);
+          add_externalReference (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.hpp b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.hpp
new file mode 100644
index 00000000000..735ed133b4f
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Deployment_Data.hpp
@@ -0,0 +1,1928 @@
+//$Id$
+#ifndef BASIC_DEPLOYMENT_DATA_HPP
+#define BASIC_DEPLOYMENT_DATA_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class TCKind;
+    class DataType;
+    class DataValue;
+    class Any;
+    class Property;
+    class Node;
+    class SatisfierPropertyKind;
+    class SatisfierProperty;
+    class Resource;
+    class SharedResource;
+    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 <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class TCKind : public ::XSCRT::Type
+    {
+      public:
+      TCKind ();
+      TCKind (::XSCRT::XML::Element< char > const&);
+      TCKind (::XSCRT::XML::Attribute< char > 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
+      operator== (TCKind const& a, TCKind const& b);
+
+      friend bool
+      operator!= (TCKind const& a, TCKind const& b);
+
+      private:
+      TCKind (Value v);
+
+      Value v_;
+    };
+
+    class DataType : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // kind
+      // 
+      public:
+      bool kind_p () const;
+      ::CIAO::Config_Handlers::TCKind const& kind () const;
+      ::CIAO::Config_Handlers::TCKind& kind ();
+      void kind (::CIAO::Config_Handlers::TCKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::TCKind > kind_;
+
+      public:
+      DataType ();
+      DataType (::XSCRT::XML::Element< char > const&);
+      DataType (DataType const& s);
+
+      DataType&
+      operator= (DataType const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class DataValue : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // short
+      // 
+      public:
+      bool short_p () const;
+      ::XMLSchema::short_ const& short_ () const;
+      ::XMLSchema::short_& short_ ();
+      void short_ (::XMLSchema::short_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::short_ > short__;
+
+      // long
+      // 
+      public:
+      bool long_p () const;
+      ::XMLSchema::int_ const& long_ () const;
+      ::XMLSchema::int_& long_ ();
+      void long_ (::XMLSchema::int_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::int_ > long__;
+
+      // ushort
+      // 
+      public:
+      bool ushort_p () const;
+      ::XMLSchema::unsignedShort const& ushort () const;
+      ::XMLSchema::unsignedShort& ushort ();
+      void ushort (::XMLSchema::unsignedShort const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::unsignedShort > ushort_;
+
+      // ulong
+      // 
+      public:
+      bool ulong_p () const;
+      ::XMLSchema::unsignedInt const& ulong () const;
+      ::XMLSchema::unsignedInt& ulong ();
+      void ulong (::XMLSchema::unsignedInt const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::unsignedInt > ulong_;
+
+      // float
+      // 
+      public:
+      bool float_p () const;
+      ::XMLSchema::float_ const& float_ () const;
+      ::XMLSchema::float_& float_ ();
+      void float_ (::XMLSchema::float_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::float_ > float__;
+
+      // double
+      // 
+      public:
+      bool double_p () const;
+      ::XMLSchema::double_ const& double_ () const;
+      ::XMLSchema::double_& double_ ();
+      void double_ (::XMLSchema::double_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::double_ > double__;
+
+      // boolean
+      // 
+      public:
+      bool boolean_p () const;
+      ::XMLSchema::boolean const& boolean () const;
+      ::XMLSchema::boolean& boolean ();
+      void boolean (::XMLSchema::boolean const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::boolean > boolean_;
+
+      // octet
+      // 
+      public:
+      bool octet_p () const;
+      ::XMLSchema::unsignedByte const& octet () const;
+      ::XMLSchema::unsignedByte& octet ();
+      void octet (::XMLSchema::unsignedByte const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::unsignedByte > octet_;
+
+      // objref
+      // 
+      public:
+      bool objref_p () const;
+      ::XMLSchema::string< char > const& objref () const;
+      ::XMLSchema::string< char >& objref ();
+      void objref (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > objref_;
+
+      // enum
+      // 
+      public:
+      bool enum_p () const;
+      ::XMLSchema::string< char > const& enum_ () const;
+      ::XMLSchema::string< char >& enum_ ();
+      void enum_ (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > enum__;
+
+      // string
+      // 
+      public:
+      bool string_p () const;
+      ::XMLSchema::string< char > const& string () const;
+      ::XMLSchema::string< char >& string ();
+      void string (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > string_;
+
+      // longlong
+      // 
+      public:
+      bool longlong_p () const;
+      ::XMLSchema::long_ const& longlong () const;
+      ::XMLSchema::long_& longlong ();
+      void longlong (::XMLSchema::long_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::long_ > longlong_;
+
+      // ulonglong
+      // 
+      public:
+      bool ulonglong_p () const;
+      ::XMLSchema::unsignedLong const& ulonglong () const;
+      ::XMLSchema::unsignedLong& ulonglong ();
+      void ulonglong (::XMLSchema::unsignedLong const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::unsignedLong > ulonglong_;
+
+      // longdouble
+      // 
+      public:
+      bool longdouble_p () const;
+      ::XMLSchema::double_ const& longdouble () const;
+      ::XMLSchema::double_& longdouble ();
+      void longdouble (::XMLSchema::double_ const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::double_ > longdouble_;
+
+      // fixed
+      // 
+      public:
+      bool fixed_p () const;
+      ::XMLSchema::string< char > const& fixed () const;
+      ::XMLSchema::string< char >& fixed ();
+      void fixed (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > fixed_;
+
+      // typecode
+      // 
+      public:
+      bool typecode_p () const;
+      ::CIAO::Config_Handlers::DataType const& typecode () const;
+      ::CIAO::Config_Handlers::DataType& typecode ();
+      void typecode (::CIAO::Config_Handlers::DataType const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > typecode_;
+
+      public:
+      DataValue ();
+      DataValue (::XSCRT::XML::Element< char > const&);
+      DataValue (DataValue const& s);
+
+      DataValue&
+      operator= (DataValue const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Any : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // type
+      // 
+      public:
+      ::CIAO::Config_Handlers::DataType const& type () const;
+      ::CIAO::Config_Handlers::DataType& type ();
+      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;
+      ::CIAO::Config_Handlers::DataValue& value ();
+      void value (::CIAO::Config_Handlers::DataValue const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::DataValue > value_;
+
+      public:
+      Any ();
+      Any (::XSCRT::XML::Element< char > const&);
+      Any (Any const& s);
+
+      Any&
+      operator= (Any const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Property : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // value
+      // 
+      public:
+      ::CIAO::Config_Handlers::Any const& value () const;
+      ::CIAO::Config_Handlers::Any& value ();
+      void value (::CIAO::Config_Handlers::Any const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Any > value_;
+
+      public:
+      Property ();
+      Property (::XSCRT::XML::Element< char > const&);
+      Property (Property const& s);
+
+      Property&
+      operator= (Property const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Node : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // label
+      // 
+      public:
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      public:
+      Node ();
+      Node (::XSCRT::XML::Element< char > const&);
+      Node (Node const& s);
+
+      Node&
+      operator= (Node const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class SatisfierPropertyKind : public ::XSCRT::Type
+    {
+      public:
+      SatisfierPropertyKind ();
+      SatisfierPropertyKind (::XSCRT::XML::Element< char > const&);
+      SatisfierPropertyKind (::XSCRT::XML::Attribute< char > 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
+      operator== (SatisfierPropertyKind const& a, SatisfierPropertyKind const& b);
+
+      friend bool
+      operator!= (SatisfierPropertyKind const& a, SatisfierPropertyKind const& b);
+
+      private:
+      SatisfierPropertyKind (Value v);
+
+      Value v_;
+    };
+
+    class SatisfierProperty : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // kind
+      // 
+      public:
+      ::CIAO::Config_Handlers::SatisfierPropertyKind const& kind () const;
+      ::CIAO::Config_Handlers::SatisfierPropertyKind& kind ();
+      void kind (::CIAO::Config_Handlers::SatisfierPropertyKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierPropertyKind > kind_;
+
+      // value
+      // 
+      public:
+      ::CIAO::Config_Handlers::Any const& value () const;
+      ::CIAO::Config_Handlers::Any& value ();
+      void value (::CIAO::Config_Handlers::Any const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Any > value_;
+
+      public:
+      SatisfierProperty ();
+      SatisfierProperty (::XSCRT::XML::Element< char > const&);
+      SatisfierProperty (SatisfierProperty const& s);
+
+      SatisfierProperty&
+      operator= (SatisfierProperty const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Resource : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // resourceType
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceType () const;
+      ::XMLSchema::string< char >& resourceType ();
+      void resourceType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceType_;
+
+      // property
+      // 
+      public:
+      ::CIAO::Config_Handlers::SatisfierProperty const& property () const;
+      ::CIAO::Config_Handlers::SatisfierProperty& property ();
+      void property (::CIAO::Config_Handlers::SatisfierProperty const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierProperty > property_;
+
+      public:
+      Resource ();
+      Resource (::XSCRT::XML::Element< char > const&);
+      Resource (Resource const& s);
+
+      Resource&
+      operator= (Resource const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class SharedResource : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // resourceType
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceType () const;
+      ::XMLSchema::string< char >& resourceType ();
+      void resourceType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceType_;
+
+      // node
+      // 
+      public:
+      ::CIAO::Config_Handlers::Node const& node () const;
+      ::CIAO::Config_Handlers::Node& node ();
+      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;
+      ::CIAO::Config_Handlers::SatisfierProperty& property ();
+      void property (::CIAO::Config_Handlers::SatisfierProperty const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierProperty > property_;
+
+      public:
+      SharedResource ();
+      SharedResource (::XSCRT::XML::Element< char > const&);
+      SharedResource (SharedResource const& s);
+
+      SharedResource&
+      operator= (SharedResource const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Requirement : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // resourceType
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceType () const;
+      ::XMLSchema::string< char >& resourceType ();
+      void resourceType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceType_;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // property
+      // 
+      public:
+      ::CIAO::Config_Handlers::Property const& property () const;
+      ::CIAO::Config_Handlers::Property& property ();
+      void property (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > property_;
+
+      public:
+      Requirement ();
+      Requirement (::XSCRT::XML::Element< char > const&);
+      Requirement (Requirement const& s);
+
+      Requirement&
+      operator= (Requirement const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ResourceDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // requirementName
+      // 
+      public:
+      ::XMLSchema::string< char > const& requirementName () const;
+      ::XMLSchema::string< char >& requirementName ();
+      void requirementName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requirementName_;
+
+      // resourceName
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceName () const;
+      ::XMLSchema::string< char >& resourceName ();
+      void resourceName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceName_;
+
+      // resourceValue
+      // 
+      public:
+      ::CIAO::Config_Handlers::Any const& resourceValue () const;
+      ::CIAO::Config_Handlers::Any& resourceValue ();
+      void resourceValue (::CIAO::Config_Handlers::Any const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Any > resourceValue_;
+
+      public:
+      ResourceDeploymentDescription ();
+      ResourceDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      ResourceDeploymentDescription (ResourceDeploymentDescription const& s);
+
+      ResourceDeploymentDescription&
+      operator= (ResourceDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ArtifactDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // source
+      // 
+      public:
+      ::XMLSchema::string< char > const& source () const;
+      ::XMLSchema::string< char >& source ();
+      void source (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > source_;
+
+      // node
+      // 
+      public:
+      bool node_p () const;
+      ::XMLSchema::string< char > const& node () const;
+      ::XMLSchema::string< char >& node ();
+      void node (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > node_;
+
+      // location
+      // 
+      public:
+      typedef ::std::vector< ::XMLSchema::string< char > >::iterator location_iterator;
+      typedef ::std::vector< ::XMLSchema::string< char > >::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< char > const& );
+
+      protected:
+      ::std::vector< ::XMLSchema::string< char > > location_;
+
+      // execParameter
+      // 
+      public:
+      bool execParameter_p () const;
+      ::CIAO::Config_Handlers::Property const& execParameter () const;
+      ::CIAO::Config_Handlers::Property& execParameter ();
+      void execParameter (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > execParameter_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > deployRequirement_;
+
+      // deployedResource
+      // 
+      public:
+      bool deployedResource_p () const;
+      ::CIAO::Config_Handlers::ResourceDeploymentDescription const& deployedResource () const;
+      ::CIAO::Config_Handlers::ResourceDeploymentDescription& deployedResource ();
+      void deployedResource (::CIAO::Config_Handlers::ResourceDeploymentDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceDeploymentDescription > deployedResource_;
+
+      // id
+      // 
+      public:
+      bool id_p () const;
+      ::XMLSchema::ID< char > const& id () const;
+      ::XMLSchema::ID< char >& id ();
+      void id (::XMLSchema::ID< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::ID< char > > id_;
+
+      public:
+      ArtifactDeploymentDescription ();
+      ArtifactDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      ArtifactDeploymentDescription (ArtifactDeploymentDescription const& s);
+
+      ArtifactDeploymentDescription&
+      operator= (ArtifactDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class MonolithicDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // source
+      // 
+      public:
+      ::XMLSchema::string< char > const& source () const;
+      ::XMLSchema::string< char >& source ();
+      void source (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > source_;
+
+      // artifact
+      // 
+      public:
+      typedef ::std::vector< ::XMLSchema::IDREF< char > >::iterator artifact_iterator;
+      typedef ::std::vector< ::XMLSchema::IDREF< char > >::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< char > const& );
+
+      protected:
+      ::std::vector< ::XMLSchema::IDREF< char > > artifact_;
+
+      // execParameter
+      // 
+      public:
+      bool execParameter_p () const;
+      ::CIAO::Config_Handlers::Property const& execParameter () const;
+      ::CIAO::Config_Handlers::Property& execParameter ();
+      void execParameter (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > execParameter_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > deployRequirement_;
+
+      // id
+      // 
+      public:
+      bool id_p () const;
+      ::XMLSchema::ID< char > const& id () const;
+      ::XMLSchema::ID< char >& id ();
+      void id (::XMLSchema::ID< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::ID< char > > id_;
+
+      public:
+      MonolithicDeploymentDescription ();
+      MonolithicDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      MonolithicDeploymentDescription (MonolithicDeploymentDescription const& s);
+
+      MonolithicDeploymentDescription&
+      operator= (MonolithicDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ResourceUsageKind : public ::XSCRT::Type
+    {
+      public:
+      ResourceUsageKind ();
+      ResourceUsageKind (::XSCRT::XML::Element< char > const&);
+      ResourceUsageKind (::XSCRT::XML::Attribute< char > 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
+      operator== (ResourceUsageKind const& a, ResourceUsageKind const& b);
+
+      friend bool
+      operator!= (ResourceUsageKind const& a, ResourceUsageKind const& b);
+
+      private:
+      ResourceUsageKind (Value v);
+
+      Value v_;
+    };
+
+    class InstanceResourceDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // resourceUsage
+      // 
+      public:
+      ::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage () const;
+      ::CIAO::Config_Handlers::ResourceUsageKind& resourceUsage ();
+      void resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > resourceUsage_;
+
+      // requirementName
+      // 
+      public:
+      ::XMLSchema::string< char > const& requirementName () const;
+      ::XMLSchema::string< char >& requirementName ();
+      void requirementName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requirementName_;
+
+      // resourceName
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceName () const;
+      ::XMLSchema::string< char >& resourceName ();
+      void resourceName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceName_;
+
+      // resourceValue
+      // 
+      public:
+      ::CIAO::Config_Handlers::Any const& resourceValue () const;
+      ::CIAO::Config_Handlers::Any& resourceValue ();
+      void resourceValue (::CIAO::Config_Handlers::Any const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Any > resourceValue_;
+
+      public:
+      InstanceResourceDeploymentDescription ();
+      InstanceResourceDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      InstanceResourceDeploymentDescription (InstanceResourceDeploymentDescription const& s);
+
+      InstanceResourceDeploymentDescription&
+      operator= (InstanceResourceDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class InstanceDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // node
+      // 
+      public:
+      ::XMLSchema::string< char > const& node () const;
+      ::XMLSchema::string< char >& node ();
+      void node (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > node_;
+
+      // source
+      // 
+      public:
+      ::XMLSchema::string< char > const& source () const;
+      ::XMLSchema::string< char >& source ();
+      void source (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > source_;
+
+      // implementation
+      // 
+      public:
+      ::XMLSchema::IDREF< char > const& implementation () const;
+      ::XMLSchema::IDREF< char >& implementation ();
+      void implementation (::XMLSchema::IDREF< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::IDREF< char > > implementation_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // deployedResource
+      // 
+      public:
+      bool deployedResource_p () const;
+      ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& deployedResource () const;
+      ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& deployedResource ();
+      void deployedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > deployedResource_;
+
+      // deployedSharedResource
+      // 
+      public:
+      bool deployedSharedResource_p () const;
+      ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& deployedSharedResource () const;
+      ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription& deployedSharedResource ();
+      void deployedSharedResource (::CIAO::Config_Handlers::InstanceResourceDeploymentDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::InstanceResourceDeploymentDescription > deployedSharedResource_;
+
+      // id
+      // 
+      public:
+      bool id_p () const;
+      ::XMLSchema::ID< char > const& id () const;
+      ::XMLSchema::ID< char >& id ();
+      void id (::XMLSchema::ID< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::ID< char > > id_;
+
+      public:
+      InstanceDeploymentDescription ();
+      InstanceDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      InstanceDeploymentDescription (InstanceDeploymentDescription const& s);
+
+      InstanceDeploymentDescription&
+      operator= (InstanceDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class CCMComponentPortKind : public ::XSCRT::Type
+    {
+      public:
+      CCMComponentPortKind ();
+      CCMComponentPortKind (::XSCRT::XML::Element< char > const&);
+      CCMComponentPortKind (::XSCRT::XML::Attribute< char > 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
+      operator== (CCMComponentPortKind const& a, CCMComponentPortKind const& b);
+
+      friend bool
+      operator!= (CCMComponentPortKind const& a, CCMComponentPortKind const& b);
+
+      private:
+      CCMComponentPortKind (Value v);
+
+      Value v_;
+    };
+
+    class ComponentPortDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // specificType
+      // 
+      public:
+      ::XMLSchema::string< char > const& specificType () const;
+      ::XMLSchema::string< char >& specificType ();
+      void specificType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > specificType_;
+
+      // supportedType
+      // 
+      public:
+      ::XMLSchema::string< char > const& supportedType () const;
+      ::XMLSchema::string< char >& supportedType ();
+      void supportedType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > supportedType_;
+
+      // provider
+      // 
+      public:
+      ::XMLSchema::string< char > const& provider () const;
+      ::XMLSchema::string< char >& provider ();
+      void provider (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > provider_;
+
+      // exclusiveProvider
+      // 
+      public:
+      ::XMLSchema::string< char > const& exclusiveProvider () const;
+      ::XMLSchema::string< char >& exclusiveProvider ();
+      void exclusiveProvider (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > exclusiveProvider_;
+
+      // exclusiveUser
+      // 
+      public:
+      ::XMLSchema::string< char > const& exclusiveUser () const;
+      ::XMLSchema::string< char >& exclusiveUser ();
+      void exclusiveUser (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > exclusiveUser_;
+
+      // optional
+      // 
+      public:
+      ::XMLSchema::string< char > const& optional () const;
+      ::XMLSchema::string< char >& optional ();
+      void optional (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > optional_;
+
+      // kind
+      // 
+      public:
+      ::CIAO::Config_Handlers::CCMComponentPortKind const& kind () const;
+      ::CIAO::Config_Handlers::CCMComponentPortKind& kind ();
+      void kind (::CIAO::Config_Handlers::CCMComponentPortKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > kind_;
+
+      public:
+      ComponentPortDescription ();
+      ComponentPortDescription (::XSCRT::XML::Element< char > const&);
+      ComponentPortDescription (ComponentPortDescription const& s);
+
+      ComponentPortDescription&
+      operator= (ComponentPortDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentPropertyDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // type
+      // 
+      public:
+      ::CIAO::Config_Handlers::DataType const& type () const;
+      ::CIAO::Config_Handlers::DataType& type ();
+      void type (::CIAO::Config_Handlers::DataType const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::DataType > type_;
+
+      public:
+      ComponentPropertyDescription ();
+      ComponentPropertyDescription (::XSCRT::XML::Element< char > const&);
+      ComponentPropertyDescription (ComponentPropertyDescription const& s);
+
+      ComponentPropertyDescription&
+      operator= (ComponentPropertyDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentExternalPortEndpoint : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // portName
+      // 
+      public:
+      ::XMLSchema::string< char > const& portName () const;
+      ::XMLSchema::string< char >& portName ();
+      void portName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > portName_;
+
+      public:
+      ComponentExternalPortEndpoint ();
+      ComponentExternalPortEndpoint (::XSCRT::XML::Element< char > const&);
+      ComponentExternalPortEndpoint (ComponentExternalPortEndpoint const& s);
+
+      ComponentExternalPortEndpoint&
+      operator= (ComponentExternalPortEndpoint const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class PlanSubcomponentPortEndpoint : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // portName
+      // 
+      public:
+      ::XMLSchema::string< char > const& portName () const;
+      ::XMLSchema::string< char >& portName ();
+      void portName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > portName_;
+
+      // provider
+      // 
+      public:
+      bool provider_p () const;
+      ::XMLSchema::string< char > const& provider () const;
+      ::XMLSchema::string< char >& provider ();
+      void provider (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > provider_;
+
+      // kind
+      // 
+      public:
+      ::CIAO::Config_Handlers::CCMComponentPortKind const& kind () const;
+      ::CIAO::Config_Handlers::CCMComponentPortKind& kind ();
+      void kind (::CIAO::Config_Handlers::CCMComponentPortKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::CCMComponentPortKind > kind_;
+
+      // instance
+      // 
+      public:
+      ::XMLSchema::IDREF< char > const& instance () const;
+      ::XMLSchema::IDREF< char >& instance ();
+      void instance (::XMLSchema::IDREF< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::IDREF< char > > instance_;
+
+      public:
+      PlanSubcomponentPortEndpoint ();
+      PlanSubcomponentPortEndpoint (::XSCRT::XML::Element< char > const&);
+      PlanSubcomponentPortEndpoint (PlanSubcomponentPortEndpoint const& s);
+
+      PlanSubcomponentPortEndpoint&
+      operator= (PlanSubcomponentPortEndpoint const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ExternalReferenceEndpoint : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // location
+      // 
+      public:
+      ::XMLSchema::string< char > const& location () const;
+      ::XMLSchema::string< char >& location ();
+      void location (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > location_;
+
+      public:
+      ExternalReferenceEndpoint ();
+      ExternalReferenceEndpoint (::XSCRT::XML::Element< char > const&);
+      ExternalReferenceEndpoint (ExternalReferenceEndpoint const& s);
+
+      ExternalReferenceEndpoint&
+      operator= (ExternalReferenceEndpoint const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ConnectionResourceDeploymentDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // targetName
+      // 
+      public:
+      ::XMLSchema::string< char > const& targetName () const;
+      ::XMLSchema::string< char >& targetName ();
+      void targetName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > targetName_;
+
+      // requirementName
+      // 
+      public:
+      ::XMLSchema::string< char > const& requirementName () const;
+      ::XMLSchema::string< char >& requirementName ();
+      void requirementName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requirementName_;
+
+      // resourceName
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceName () const;
+      ::XMLSchema::string< char >& resourceName ();
+      void resourceName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceName_;
+
+      // resourceValue
+      // 
+      public:
+      ::CIAO::Config_Handlers::Any const& resourceValue () const;
+      ::CIAO::Config_Handlers::Any& resourceValue ();
+      void resourceValue (::CIAO::Config_Handlers::Any const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Any > resourceValue_;
+
+      public:
+      ConnectionResourceDeploymentDescription ();
+      ConnectionResourceDeploymentDescription (::XSCRT::XML::Element< char > const&);
+      ConnectionResourceDeploymentDescription (ConnectionResourceDeploymentDescription const& s);
+
+      ConnectionResourceDeploymentDescription&
+      operator= (ConnectionResourceDeploymentDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class PlanConnectionDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // source
+      // 
+      public:
+      bool source_p () const;
+      ::XMLSchema::string< char > const& source () const;
+      ::XMLSchema::string< char >& source ();
+      void source (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > source_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > deployRequirement_;
+
+      // externalEndpoint
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::iterator externalEndpoint_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > externalEndpoint_;
+
+      // internalEndpoint
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint >::iterator internalEndpoint_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::PlanSubcomponentPortEndpoint > internalEndpoint_;
+
+      // externalReference
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::iterator externalReference_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > externalReference_;
+
+      // deployedResource
+      // 
+      public:
+      bool deployedResource_p () const;
+      ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& deployedResource () const;
+      ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription& deployedResource ();
+      void deployedResource (::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ConnectionResourceDeploymentDescription > deployedResource_;
+
+      public:
+      PlanConnectionDescription ();
+      PlanConnectionDescription (::XSCRT::XML::Element< char > const&);
+      PlanConnectionDescription (PlanConnectionDescription const& s);
+
+      PlanConnectionDescription&
+      operator= (PlanConnectionDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ImplementationDependency : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // requiredType
+      // 
+      public:
+      ::XMLSchema::string< char > const& requiredType () const;
+      ::XMLSchema::string< char >& requiredType ();
+      void requiredType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requiredType_;
+
+      public:
+      ImplementationDependency ();
+      ImplementationDependency (::XSCRT::XML::Element< char > const&);
+      ImplementationDependency (ImplementationDependency const& s);
+
+      ImplementationDependency&
+      operator= (ImplementationDependency const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class Capability : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // resourceType
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceType () const;
+      ::XMLSchema::string< char >& resourceType ();
+      void resourceType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceType_;
+
+      // property
+      // 
+      public:
+      ::CIAO::Config_Handlers::SatisfierProperty const& property () const;
+      ::CIAO::Config_Handlers::SatisfierProperty& property ();
+      void property (::CIAO::Config_Handlers::SatisfierProperty const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SatisfierProperty > property_;
+
+      public:
+      Capability ();
+      Capability (::XSCRT::XML::Element< char > const&);
+      Capability (Capability const& s);
+
+      Capability&
+      operator= (Capability const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ImplementationRequirement : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // resourceUsage
+      // 
+      public:
+      ::CIAO::Config_Handlers::ResourceUsageKind const& resourceUsage () const;
+      ::CIAO::Config_Handlers::ResourceUsageKind& resourceUsage ();
+      void resourceUsage (::CIAO::Config_Handlers::ResourceUsageKind const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ResourceUsageKind > resourceUsage_;
+
+      // resourcePort
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourcePort () const;
+      ::XMLSchema::string< char >& resourcePort ();
+      void resourcePort (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourcePort_;
+
+      // componentPort
+      // 
+      public:
+      ::XMLSchema::string< char > const& componentPort () const;
+      ::XMLSchema::string< char >& componentPort ();
+      void componentPort (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > componentPort_;
+
+      // resourceType
+      // 
+      public:
+      ::XMLSchema::string< char > const& resourceType () const;
+      ::XMLSchema::string< char >& resourceType ();
+      void resourceType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > resourceType_;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // property
+      // 
+      public:
+      ::CIAO::Config_Handlers::Property const& property () const;
+      ::CIAO::Config_Handlers::Property& property ();
+      void property (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > property_;
+
+      public:
+      ImplementationRequirement ();
+      ImplementationRequirement (::XSCRT::XML::Element< char > const&);
+      ImplementationRequirement (ImplementationRequirement const& s);
+
+      ImplementationRequirement&
+      operator= (ImplementationRequirement const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentPackageReference : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // requiredUUID
+      // 
+      public:
+      ::XMLSchema::string< char > const& requiredUUID () const;
+      ::XMLSchema::string< char >& requiredUUID ();
+      void requiredUUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requiredUUID_;
+
+      // requiredName
+      // 
+      public:
+      ::XMLSchema::string< char > const& requiredName () const;
+      ::XMLSchema::string< char >& requiredName ();
+      void requiredName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requiredName_;
+
+      // requiredType
+      // 
+      public:
+      ::XMLSchema::string< char > const& requiredType () const;
+      ::XMLSchema::string< char >& requiredType ();
+      void requiredType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > requiredType_;
+
+      public:
+      ComponentPackageReference ();
+      ComponentPackageReference (::XSCRT::XML::Element< char > const&);
+      ComponentPackageReference (ComponentPackageReference const& s);
+
+      ComponentPackageReference&
+      operator= (ComponentPackageReference const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class SubcomponentPortEndpoint : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // portName
+      // 
+      public:
+      ::XMLSchema::string< char > const& portName () const;
+      ::XMLSchema::string< char >& portName ();
+      void portName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > portName_;
+
+      // instance
+      // 
+      public:
+      ::XMLSchema::IDREF< char > const& instance () const;
+      ::XMLSchema::IDREF< char >& instance ();
+      void instance (::XMLSchema::IDREF< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::IDREF< char > > instance_;
+
+      public:
+      SubcomponentPortEndpoint ();
+      SubcomponentPortEndpoint (::XSCRT::XML::Element< char > const&);
+      SubcomponentPortEndpoint (SubcomponentPortEndpoint const& s);
+
+      SubcomponentPortEndpoint&
+      operator= (SubcomponentPortEndpoint const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class AssemblyConnectionDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > deployRequirement_;
+
+      // externalEndpoint
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint >::iterator externalEndpoint_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ComponentExternalPortEndpoint > externalEndpoint_;
+
+      // internalEndpoint
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::SubcomponentPortEndpoint >::iterator internalEndpoint_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::SubcomponentPortEndpoint > internalEndpoint_;
+
+      // externalReference
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint >::iterator externalReference_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ExternalReferenceEndpoint > externalReference_;
+
+      public:
+      AssemblyConnectionDescription ();
+      AssemblyConnectionDescription (::XSCRT::XML::Element< char > const&);
+      AssemblyConnectionDescription (AssemblyConnectionDescription const& s);
+
+      AssemblyConnectionDescription&
+      operator= (AssemblyConnectionDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // BASIC_DEPLOYMENT_DATA_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Basic_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Handler.h
index 6c7089915b6..a8d31ea54f1 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/Basic_Handler.h
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Basic_Handler.h
@@ -11,7 +11,7 @@
 #ifndef BASIC_HANDLER_H
 #define BASIC_HANDLER_H
 
-#include "Deployment.h"
+#include "Config.h"
 
 #include "ace/SString.h"
 #include "ace/Null_Mutex.h"
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Deployment.h b/TAO/CIAO/DAnCE/Config_Handlers/Config.h
index a3fc3b72004..663396e1563 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/Deployment.h
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Config.h
@@ -1,6 +1,6 @@
 //==================================================================
 /**
- *  @file  Deployment.h
+ *  @file  Config.h
  *
  *  $Id$
  *
@@ -8,10 +8,10 @@
  */
 //=====================================================================
 
-#ifndef DEPLOYMENT_H
-#define DEPLOYMENT_H
+#ifndef CIAO_DANCE_CONFIG_H
+#define CIAO_DANCE_CONFIG_H
 
 #define BEGIN_DEPLOYMENT_NAMESPACE namespace CIAO { namespace Config_Handler {
 #define END_DEPLOYMENT_NAMESPACE }; };
 
-#endif // DEPLOYMENT_H
+#endif // CIAO_DANCE_CONFIG_H
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Config_Handlers.mpc b/TAO/CIAO/DAnCE/Config_Handlers/Config_Handlers.mpc
index 11a346a94cf..12ab9879d79 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/Config_Handlers.mpc
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Config_Handlers.mpc
@@ -47,3 +47,42 @@ project (Config_Handlers) : ciao_deployment_stub {
     XercesString.cpp
   }
 }
+
+project (XSC_Config_Handlers) : ciao_deployment_stub {
+
+  requires += dummy_label
+
+  sharedname = XSC_Config_Handlers
+  dynamicflags   = CONFIG_HANDLER_BUILD_DLL
+  macros   += XML_USE_PTHREADS
+  requires += exceptions
+  includes += $(XERCESCROOT)/include  .
+  libpaths += $(XERCESCROOT)/lib
+  libs     += xerces-c CIAO_DnC_Server TAO_IFR_Client
+
+  Source_Files {
+    Basic_Deployment_Data.cpp
+    ccd.cpp
+    cdd.cpp
+    cdp.cpp
+    cid.cpp
+    cpd.cpp
+    Deployment.cpp
+    iad.cpp
+    pcd.cpp
+    toplevel.cpp
+  }
+
+  Header_Files {
+    Basic_Deployment_Data.hpp
+    ccd.hpp
+    cdd.hpp
+    cdp.hpp
+    cid.hpp
+    cpd.hpp
+    Deployment.hpp
+    iad.hpp
+    pcd.hpp
+    toplevel.hpp
+  }
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Deployment.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Deployment.cpp
new file mode 100644
index 00000000000..be15143889d
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Deployment.cpp
@@ -0,0 +1,151 @@
+// $Id$
+#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< char > 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< char > 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< char > 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< char > 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< char > 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< char > 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< char > 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< char > e (d->getDocumentElement ());
+      if (e.name () == "topLevelPackageDescription")
+      {
+        ::CIAO::Config_Handlers::TopLevelPackageDescription r (e);
+        return r;
+      }
+
+      else
+      {
+        throw 1;
+      }
+    }
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Deployment.hpp b/TAO/CIAO/DAnCE/Config_Handlers/Deployment.hpp
new file mode 100644
index 00000000000..e4cd3aecdaf
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Deployment.hpp
@@ -0,0 +1,68 @@
+// $Id$
+#ifndef DEPLOYMENT_HPP
+#define DEPLOYMENT_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+#include "cpd.hpp"
+
+#include "cdd.hpp"
+
+#include "cdp.hpp"
+
+#include "pcd.hpp"
+
+#include "toplevel.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    ::CIAO::Config_Handlers::Domain
+    domain (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::DeploymentPlan
+    deploymentPlan (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::ImplementationArtifactDescription
+    implementationArtifactDescription (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription
+    componentInterfaceDescription (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::ComponentImplementationDescription
+    componentImplementationDescription (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::ComponentPackageDescription
+    componentPackageDescription (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::PackageConfiguration
+    packageConfiguration (xercesc::DOMDocument const*);
+
+    ::CIAO::Config_Handlers::TopLevelPackageDescription
+    topLevelPackageDescription (xercesc::DOMDocument const*);
+  }
+}
+
+#endif // DEPLOYMENT_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h
index 53bbbf5258f..bec9e523fe4 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h
@@ -13,7 +13,7 @@
 #define PROCESS_ELEMENT_H
 
 #include "ciao/DeploymentC.h"
-#include "Deployment.h"
+#include "Config.h"
 #include "Basic_Handler.h"
 #include "Config_Handler_export.h"
 #include "ace/SString.h"
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ccd.cpp b/TAO/CIAO/DAnCE/Config_Handlers/ccd.cpp
new file mode 100644
index 00000000000..2721776e2fd
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ccd.cpp
@@ -0,0 +1,555 @@
+// $Id$
+#include "ccd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // ComponentInterfaceDescription
+    // 
+
+    ComponentInterfaceDescription::
+    ComponentInterfaceDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    ComponentInterfaceDescription::
+    ComponentInterfaceDescription (::CIAO::Config_Handlers::ComponentInterfaceDescription const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    specificType_ (s.specificType_.get () ? new ::XMLSchema::string< char > (*s.specificType_) : 0),
+    supportedType_ (s.supportedType_.get () ? new ::XMLSchema::string< char > (*s.supportedType_) : 0),
+    idlFile_ (s.idlFile_.get () ? new ::XMLSchema::string< char > (*s.idlFile_) : 0),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    property_ (s.property_.get () ? new ::CIAO::Config_Handlers::ComponentPropertyDescription (*s.property_) : 0),
+    infoProperty_ (s.infoProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.infoProperty_) : 0),
+    contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< char > (*s.contentLocation_) : 0),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      if (specificType_.get ()) specificType_->container (this);
+      if (supportedType_.get ()) supportedType_->container (this);
+      if (idlFile_.get ()) idlFile_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      port_.reserve (s.port_.size ());
+      {
+        for (port_const_iterator i (s.port_.begin ());
+        i != s.port_.end ();
+        ++i) add_port (*i);
+      }
+
+      if (property_.get ()) property_->container (this);
+      if (infoProperty_.get ()) infoProperty_->container (this);
+      if (contentLocation_.get ()) contentLocation_->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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.specificType_.get ()) specificType (*(s.specificType_));
+      else specificType_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.supportedType_.get ()) supportedType (*(s.supportedType_));
+      else supportedType_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.idlFile_.get ()) idlFile (*(s.idlFile_));
+      else idlFile_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      port_.clear ();
+      port_.reserve (s.port_.size ());
+      {
+        for (port_const_iterator i (s.port_.begin ());
+        i != s.port_.end ();
+        ++i) add_port (*i);
+      }
+
+      if (s.property_.get ()) property (*(s.property_));
+      else property_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPropertyDescription > (0);
+
+      if (s.infoProperty_.get ()) infoProperty (*(s.infoProperty_));
+      else infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_));
+      else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      return *this;
+    }
+
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    label_p () const
+    {
+      return label_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    label ()
+    {
+      return *label_;
+    }
+
+    void ComponentInterfaceDescription::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void ComponentInterfaceDescription::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        UUID_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    specificType_p () const
+    {
+      return specificType_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    specificType () const
+    {
+      return *specificType_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    specificType ()
+    {
+      return *specificType_;
+    }
+
+    void ComponentInterfaceDescription::
+    specificType (::XMLSchema::string< char > const& e)
+    {
+      if (specificType_.get ())
+      {
+        *specificType_ = e;
+      }
+
+      else
+      {
+        specificType_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        specificType_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    supportedType_p () const
+    {
+      return supportedType_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    supportedType () const
+    {
+      return *supportedType_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    supportedType ()
+    {
+      return *supportedType_;
+    }
+
+    void ComponentInterfaceDescription::
+    supportedType (::XMLSchema::string< char > const& e)
+    {
+      if (supportedType_.get ())
+      {
+        *supportedType_ = e;
+      }
+
+      else
+      {
+        supportedType_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        supportedType_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    idlFile_p () const
+    {
+      return idlFile_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    idlFile () const
+    {
+      return *idlFile_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    idlFile ()
+    {
+      return *idlFile_;
+    }
+
+    void ComponentInterfaceDescription::
+    idlFile (::XMLSchema::string< char > const& e)
+    {
+      if (idlFile_.get ())
+      {
+        *idlFile_ = e;
+      }
+
+      else
+      {
+        idlFile_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        idlFile_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentInterfaceDescription::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentInterfaceDescription::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void ComponentInterfaceDescription::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // 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)
+    {
+      if (port_.capacity () < port_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ComponentPortDescription > v;
+        v.reserve (port_.size () + 1);
+
+        while (port_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ComponentPortDescription& t = port_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          port_.pop_back ();
+        }
+
+        port_.swap (v);
+      }
+
+      port_.push_back (e);
+      port_.back ().container (this);
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    property_p () const
+    {
+      return property_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPropertyDescription const& ComponentInterfaceDescription::
+    property () const
+    {
+      return *property_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPropertyDescription& ComponentInterfaceDescription::
+    property ()
+    {
+      return *property_;
+    }
+
+    void ComponentInterfaceDescription::
+    property (::CIAO::Config_Handlers::ComponentPropertyDescription const& e)
+    {
+      if (property_.get ())
+      {
+        *property_ = e;
+      }
+
+      else
+      {
+        property_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPropertyDescription > (new ::CIAO::Config_Handlers::ComponentPropertyDescription (e));
+        property_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    infoProperty_p () const
+    {
+      return infoProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentInterfaceDescription::
+    infoProperty () const
+    {
+      return *infoProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentInterfaceDescription::
+    infoProperty ()
+    {
+      return *infoProperty_;
+    }
+
+    void ComponentInterfaceDescription::
+    infoProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (infoProperty_.get ())
+      {
+        *infoProperty_ = e;
+      }
+
+      else
+      {
+        infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        infoProperty_->container (this);
+      }
+    }
+
+    // ComponentInterfaceDescription
+    // 
+    bool ComponentInterfaceDescription::
+    contentLocation_p () const
+    {
+      return contentLocation_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentInterfaceDescription::
+    contentLocation () const
+    {
+      return *contentLocation_;
+    }
+
+    ::XMLSchema::string< char >& ComponentInterfaceDescription::
+    contentLocation ()
+    {
+      return *contentLocation_;
+    }
+
+    void ComponentInterfaceDescription::
+    contentLocation (::XMLSchema::string< char > const& e)
+    {
+      if (contentLocation_.get ())
+      {
+        *contentLocation_ = e;
+      }
+
+      else
+      {
+        contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        contentLocation_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // ComponentInterfaceDescription
+    //
+
+    ComponentInterfaceDescription::
+    ComponentInterfaceDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > t (e);
+          UUID (t);
+        }
+
+        else if (n == "specificType")
+        {
+          ::XMLSchema::string< char > t (e);
+          specificType (t);
+        }
+
+        else if (n == "supportedType")
+        {
+          ::XMLSchema::string< char > t (e);
+          supportedType (t);
+        }
+
+        else if (n == "idlFile")
+        {
+          ::XMLSchema::string< char > t (e);
+          idlFile (t);
+        }
+
+        else if (n == "configProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          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);
+          property (t);
+        }
+
+        else if (n == "infoProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          infoProperty (t);
+        }
+
+        else if (n == "contentLocation")
+        {
+          ::XMLSchema::string< char > t (e);
+          contentLocation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ccd.hpp b/TAO/CIAO/DAnCE/Config_Handlers/ccd.hpp
new file mode 100644
index 00000000000..622334b2268
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ccd.hpp
@@ -0,0 +1,165 @@
+//$Id$
+#ifndef CCD_HPP
+#define CCD_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class ComponentInterfaceDescription;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class ComponentInterfaceDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // specificType
+      // 
+      public:
+      bool specificType_p () const;
+      ::XMLSchema::string< char > const& specificType () const;
+      ::XMLSchema::string< char >& specificType ();
+      void specificType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > specificType_;
+
+      // supportedType
+      // 
+      public:
+      bool supportedType_p () const;
+      ::XMLSchema::string< char > const& supportedType () const;
+      ::XMLSchema::string< char >& supportedType ();
+      void supportedType (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > supportedType_;
+
+      // idlFile
+      // 
+      public:
+      bool idlFile_p () const;
+      ::XMLSchema::string< char > const& idlFile () const;
+      ::XMLSchema::string< char >& idlFile ();
+      void idlFile (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > idlFile_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // port
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ComponentPortDescription >::iterator port_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ComponentPortDescription > port_;
+
+      // property
+      // 
+      public:
+      bool property_p () const;
+      ::CIAO::Config_Handlers::ComponentPropertyDescription const& property () const;
+      ::CIAO::Config_Handlers::ComponentPropertyDescription& property ();
+      void property (::CIAO::Config_Handlers::ComponentPropertyDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPropertyDescription > property_;
+
+      // infoProperty
+      // 
+      public:
+      bool infoProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& infoProperty () const;
+      ::CIAO::Config_Handlers::Property& infoProperty ();
+      void infoProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      // contentLocation
+      // 
+      public:
+      bool contentLocation_p () const;
+      ::XMLSchema::string< char > const& contentLocation () const;
+      ::XMLSchema::string< char >& contentLocation ();
+      void contentLocation (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > contentLocation_;
+
+      public:
+      ComponentInterfaceDescription ();
+      ComponentInterfaceDescription (::XSCRT::XML::Element< char > const&);
+      ComponentInterfaceDescription (ComponentInterfaceDescription const& s);
+
+      ComponentInterfaceDescription&
+      operator= (ComponentInterfaceDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // CCD_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cdd.cpp b/TAO/CIAO/DAnCE/Config_Handlers/cdd.cpp
new file mode 100644
index 00000000000..1fac6f758af
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cdd.cpp
@@ -0,0 +1,301 @@
+//$Id$
+#include "cdd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // Domain
+    // 
+
+    Domain::
+    Domain ()
+    :
+    label_ (new ::XMLSchema::string< char > ()),
+    UUID_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      label_->container (this);
+      UUID_->container (this);
+    }
+
+    Domain::
+    Domain (::CIAO::Config_Handlers::Domain const& s)
+    :
+    label_ (new ::XMLSchema::string< char > (*s.label_)),
+    UUID_ (new ::XMLSchema::string< char > (*s.UUID_)),
+    sharedResource_ (s.sharedResource_.get () ? new ::CIAO::Config_Handlers::SharedResource (*s.sharedResource_) : 0),
+    infoProperty_ (s.infoProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.infoProperty_) : 0),
+    regulator__ ()
+    {
+      label_->container (this);
+      UUID_->container (this);
+      if (sharedResource_.get ()) sharedResource_->container (this);
+      node_.reserve (s.node_.size ());
+      {
+        for (node_const_iterator i (s.node_.begin ());
+        i != s.node_.end ();
+        ++i) add_node (*i);
+      }
+
+      if (infoProperty_.get ()) infoProperty_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::Domain& Domain::
+    operator= (::CIAO::Config_Handlers::Domain const& s)
+    {
+      label (s.label ());
+
+      UUID (s.UUID ());
+
+      if (s.sharedResource_.get ()) sharedResource (*(s.sharedResource_));
+      else sharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SharedResource > (0);
+
+      node_.clear ();
+      node_.reserve (s.node_.size ());
+      {
+        for (node_const_iterator i (s.node_.begin ());
+        i != s.node_.end ();
+        ++i) add_node (*i);
+      }
+
+      if (s.infoProperty_.get ()) infoProperty (*(s.infoProperty_));
+      else infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      return *this;
+    }
+
+
+    // Domain
+    // 
+    ::XMLSchema::string< char > const& Domain::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& Domain::
+    label ()
+    {
+      return *label_;
+    }
+
+    void Domain::
+    label (::XMLSchema::string< char > const& e)
+    {
+      *label_ = e;
+    }
+
+    // Domain
+    // 
+    ::XMLSchema::string< char > const& Domain::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& Domain::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void Domain::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      *UUID_ = e;
+    }
+
+    // Domain
+    // 
+    bool Domain::
+    sharedResource_p () const
+    {
+      return sharedResource_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::SharedResource const& Domain::
+    sharedResource () const
+    {
+      return *sharedResource_;
+    }
+
+    ::CIAO::Config_Handlers::SharedResource& Domain::
+    sharedResource ()
+    {
+      return *sharedResource_;
+    }
+
+    void Domain::
+    sharedResource (::CIAO::Config_Handlers::SharedResource const& e)
+    {
+      if (sharedResource_.get ())
+      {
+        *sharedResource_ = e;
+      }
+
+      else
+      {
+        sharedResource_ = ::std::auto_ptr< ::CIAO::Config_Handlers::SharedResource > (new ::CIAO::Config_Handlers::SharedResource (e));
+        sharedResource_->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)
+    {
+      if (node_.capacity () < node_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::Node > v;
+        v.reserve (node_.size () + 1);
+
+        while (node_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::Node& t = node_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          node_.pop_back ();
+        }
+
+        node_.swap (v);
+      }
+
+      node_.push_back (e);
+      node_.back ().container (this);
+    }
+
+    // Domain
+    // 
+    bool Domain::
+    infoProperty_p () const
+    {
+      return infoProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& Domain::
+    infoProperty () const
+    {
+      return *infoProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& Domain::
+    infoProperty ()
+    {
+      return *infoProperty_;
+    }
+
+    void Domain::
+    infoProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (infoProperty_.get ())
+      {
+        *infoProperty_ = e;
+      }
+
+      else
+      {
+        infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        infoProperty_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // Domain
+    //
+
+    Domain::
+    Domain (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    label_ (new ::XMLSchema::string< char > ()),
+    UUID_ (new ::XMLSchema::string< char > ()),
+    regulator__ ()
+    {
+      label_->container (this);
+      UUID_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > t (e);
+          UUID (t);
+        }
+
+        else if (n == "sharedResource")
+        {
+          ::CIAO::Config_Handlers::SharedResource t (e);
+          sharedResource (t);
+        }
+
+        else if (n == "node")
+        {
+          ::CIAO::Config_Handlers::Node t (e);
+          add_node (t);
+        }
+
+        else if (n == "infoProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          infoProperty (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cdd.hpp b/TAO/CIAO/DAnCE/Config_Handlers/cdd.hpp
new file mode 100644
index 00000000000..a3834aa1303
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cdd.hpp
@@ -0,0 +1,108 @@
+// $Id$
+#ifndef CDD_HPP
+#define CDD_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class Domain;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class Domain : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // sharedResource
+      // 
+      public:
+      bool sharedResource_p () const;
+      ::CIAO::Config_Handlers::SharedResource const& sharedResource () const;
+      ::CIAO::Config_Handlers::SharedResource& sharedResource ();
+      void sharedResource (::CIAO::Config_Handlers::SharedResource const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SharedResource > sharedResource_;
+
+      // node
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::Node >::iterator node_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::Node > node_;
+
+      // infoProperty
+      // 
+      public:
+      bool infoProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& infoProperty () const;
+      ::CIAO::Config_Handlers::Property& infoProperty ();
+      void infoProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      public:
+      Domain ();
+      Domain (::XSCRT::XML::Element< char > const&);
+      Domain (Domain const& s);
+
+      Domain&
+      operator= (Domain const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // CDD_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cdp.cpp b/TAO/CIAO/DAnCE/Config_Handlers/cdp.cpp
new file mode 100644
index 00000000000..a4e63057eff
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cdp.cpp
@@ -0,0 +1,588 @@
+// $Id$
+#include "cdp.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // DeploymentPlan
+    // 
+
+    DeploymentPlan::
+    DeploymentPlan ()
+    :
+    realizes_ (new ::CIAO::Config_Handlers::ComponentInterfaceDescription ()),
+    implementation_ (new ::CIAO::Config_Handlers::MonolithicDeploymentDescription ()),
+    regulator__ ()
+    {
+      realizes_->container (this);
+      implementation_->container (this);
+    }
+
+    DeploymentPlan::
+    DeploymentPlan (::CIAO::Config_Handlers::DeploymentPlan const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    realizes_ (new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.realizes_)),
+    implementation_ (new ::CIAO::Config_Handlers::MonolithicDeploymentDescription (*s.implementation_)),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      realizes_->container (this);
+      implementation_->container (this);
+      instance_.reserve (s.instance_.size ());
+      {
+        for (instance_const_iterator i (s.instance_.begin ());
+        i != s.instance_.end ();
+        ++i) add_instance (*i);
+      }
+
+      connection_.reserve (s.connection_.size ());
+      {
+        for (connection_const_iterator i (s.connection_.begin ());
+        i != s.connection_.end ();
+        ++i) add_connection (*i);
+      }
+
+      dependsOn_.reserve (s.dependsOn_.size ());
+      {
+        for (dependsOn_const_iterator i (s.dependsOn_.begin ());
+        i != s.dependsOn_.end ();
+        ++i) add_dependsOn (*i);
+      }
+
+      artifact_.reserve (s.artifact_.size ());
+      {
+        for (artifact_const_iterator i (s.artifact_.begin ());
+        i != s.artifact_.end ();
+        ++i) add_artifact (*i);
+      }
+
+      infoProperty_.reserve (s.infoProperty_.size ());
+      {
+        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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      realizes (s.realizes ());
+
+      implementation (s.implementation ());
+
+      instance_.clear ();
+      instance_.reserve (s.instance_.size ());
+      {
+        for (instance_const_iterator i (s.instance_.begin ());
+        i != s.instance_.end ();
+        ++i) add_instance (*i);
+      }
+
+      connection_.clear ();
+      connection_.reserve (s.connection_.size ());
+      {
+        for (connection_const_iterator i (s.connection_.begin ());
+        i != s.connection_.end ();
+        ++i) add_connection (*i);
+      }
+
+      dependsOn_.clear ();
+      dependsOn_.reserve (s.dependsOn_.size ());
+      {
+        for (dependsOn_const_iterator i (s.dependsOn_.begin ());
+        i != s.dependsOn_.end ();
+        ++i) add_dependsOn (*i);
+      }
+
+      artifact_.clear ();
+      artifact_.reserve (s.artifact_.size ());
+      {
+        for (artifact_const_iterator i (s.artifact_.begin ());
+        i != s.artifact_.end ();
+        ++i) add_artifact (*i);
+      }
+
+      infoProperty_.clear ();
+      infoProperty_.reserve (s.infoProperty_.size ());
+      {
+        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< char > const& DeploymentPlan::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& DeploymentPlan::
+    label ()
+    {
+      return *label_;
+    }
+
+    void DeploymentPlan::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // DeploymentPlan
+    // 
+    bool DeploymentPlan::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& DeploymentPlan::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& DeploymentPlan::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void DeploymentPlan::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        UUID_->container (this);
+      }
+    }
+
+    // DeploymentPlan
+    // 
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription const& DeploymentPlan::
+    realizes () const
+    {
+      return *realizes_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription& DeploymentPlan::
+    realizes ()
+    {
+      return *realizes_;
+    }
+
+    void DeploymentPlan::
+    realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& e)
+    {
+      *realizes_ = e;
+    }
+
+    // DeploymentPlan
+    // 
+    ::CIAO::Config_Handlers::MonolithicDeploymentDescription const& DeploymentPlan::
+    implementation () const
+    {
+      return *implementation_;
+    }
+
+    ::CIAO::Config_Handlers::MonolithicDeploymentDescription& DeploymentPlan::
+    implementation ()
+    {
+      return *implementation_;
+    }
+
+    void DeploymentPlan::
+    implementation (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& e)
+    {
+      *implementation_ = e;
+    }
+
+    // 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)
+    {
+      if (instance_.capacity () < instance_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::InstanceDeploymentDescription > v;
+        v.reserve (instance_.size () + 1);
+
+        while (instance_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::InstanceDeploymentDescription& t = instance_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          instance_.pop_back ();
+        }
+
+        instance_.swap (v);
+      }
+
+      instance_.push_back (e);
+      instance_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (connection_.capacity () < connection_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::PlanConnectionDescription > v;
+        v.reserve (connection_.size () + 1);
+
+        while (connection_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::PlanConnectionDescription& t = connection_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          connection_.pop_back ();
+        }
+
+        connection_.swap (v);
+      }
+
+      connection_.push_back (e);
+      connection_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (dependsOn_.capacity () < dependsOn_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ImplementationDependency > v;
+        v.reserve (dependsOn_.size () + 1);
+
+        while (dependsOn_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ImplementationDependency& t = dependsOn_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          dependsOn_.pop_back ();
+        }
+
+        dependsOn_.swap (v);
+      }
+
+      dependsOn_.push_back (e);
+      dependsOn_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (artifact_.capacity () < artifact_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::ArtifactDeploymentDescription > v;
+        v.reserve (artifact_.size () + 1);
+
+        while (artifact_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::ArtifactDeploymentDescription& t = artifact_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          artifact_.pop_back ();
+        }
+
+        artifact_.swap (v);
+      }
+
+      artifact_.push_back (e);
+      artifact_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (infoProperty_.capacity () < infoProperty_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::Property > v;
+        v.reserve (infoProperty_.size () + 1);
+
+        while (infoProperty_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::Property& t = infoProperty_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          infoProperty_.pop_back ();
+        }
+
+        infoProperty_.swap (v);
+      }
+
+      infoProperty_.push_back (e);
+      infoProperty_.back ().container (this);
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // DeploymentPlan
+    //
+
+    DeploymentPlan::
+    DeploymentPlan (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    realizes_ (new ::CIAO::Config_Handlers::ComponentInterfaceDescription ()),
+    implementation_ (new ::CIAO::Config_Handlers::MonolithicDeploymentDescription ()),
+    regulator__ ()
+    {
+      realizes_->container (this);
+      implementation_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > 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);
+          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
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cdp.hpp b/TAO/CIAO/DAnCE/Config_Handlers/cdp.hpp
new file mode 100644
index 00000000000..de201bfca33
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cdp.hpp
@@ -0,0 +1,164 @@
+// $Id$
+#ifndef CDP_HPP
+#define CDP_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class DeploymentPlan;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "ccd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class DeploymentPlan : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // realizes
+      // 
+      public:
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription const& realizes () const;
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription& realizes ();
+      void realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > realizes_;
+
+      // implementation
+      // 
+      public:
+      ::CIAO::Config_Handlers::MonolithicDeploymentDescription const& implementation () const;
+      ::CIAO::Config_Handlers::MonolithicDeploymentDescription& implementation ();
+      void implementation (::CIAO::Config_Handlers::MonolithicDeploymentDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicDeploymentDescription > implementation_;
+
+      // instance
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::InstanceDeploymentDescription >::iterator instance_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::InstanceDeploymentDescription > instance_;
+
+      // connection
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::PlanConnectionDescription >::iterator connection_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::PlanConnectionDescription > connection_;
+
+      // dependsOn
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ImplementationDependency >::iterator dependsOn_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ImplementationDependency > dependsOn_;
+
+      // artifact
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::ArtifactDeploymentDescription >::iterator artifact_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::ArtifactDeploymentDescription > artifact_;
+
+      // infoProperty
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::Property >::iterator infoProperty_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      public:
+      DeploymentPlan ();
+      DeploymentPlan (::XSCRT::XML::Element< char > const&);
+      DeploymentPlan (DeploymentPlan const& s);
+
+      DeploymentPlan&
+      operator= (DeploymentPlan const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // CDP_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cid.cpp b/TAO/CIAO/DAnCE/Config_Handlers/cid.cpp
new file mode 100644
index 00000000000..2b5ea3712db
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cid.cpp
@@ -0,0 +1,1554 @@
+// $Id$
+#include "cid.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // SubcomponentInstantiationDescription
+    // 
+
+    SubcomponentInstantiationDescription::
+    SubcomponentInstantiationDescription ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    package_ (new ::CIAO::Config_Handlers::ComponentPackageDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      package_->container (this);
+    }
+
+    SubcomponentInstantiationDescription::
+    SubcomponentInstantiationDescription (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    package_ (new ::CIAO::Config_Handlers::ComponentPackageDescription (*s.package_)),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    selectRequirement_ (s.selectRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.selectRequirement_) : 0),
+    reference_ (s.reference_.get () ? new ::CIAO::Config_Handlers::ComponentPackageReference (*s.reference_) : 0),
+    id_ (s.id_.get () ? new ::XMLSchema::ID< char > (*s.id_) : 0),
+    regulator__ ()
+    {
+      name_->container (this);
+      package_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      if (selectRequirement_.get ()) selectRequirement_->container (this);
+      if (reference_.get ()) reference_->container (this);
+      if (id_.get ()) id_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::SubcomponentInstantiationDescription& SubcomponentInstantiationDescription::
+    operator= (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& s)
+    {
+      name (s.name ());
+
+      package (s.package ());
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.selectRequirement_.get ()) selectRequirement (*(s.selectRequirement_));
+      else selectRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      if (s.reference_.get ()) reference (*(s.reference_));
+      else reference_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (0);
+
+      if (s.id_.get ()) id (*(s.id_));
+      else id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (0);
+
+      return *this;
+    }
+
+
+    // SubcomponentInstantiationDescription
+    // 
+    ::XMLSchema::string< char > const& SubcomponentInstantiationDescription::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& SubcomponentInstantiationDescription::
+    name ()
+    {
+      return *name_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // SubcomponentInstantiationDescription
+    // 
+    ::CIAO::Config_Handlers::ComponentPackageDescription const& SubcomponentInstantiationDescription::
+    package () const
+    {
+      return *package_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageDescription& SubcomponentInstantiationDescription::
+    package ()
+    {
+      return *package_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    package (::CIAO::Config_Handlers::ComponentPackageDescription const& e)
+    {
+      *package_ = e;
+    }
+
+    // SubcomponentInstantiationDescription
+    // 
+    bool SubcomponentInstantiationDescription::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& SubcomponentInstantiationDescription::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& SubcomponentInstantiationDescription::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // SubcomponentInstantiationDescription
+    // 
+    bool SubcomponentInstantiationDescription::
+    selectRequirement_p () const
+    {
+      return selectRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& SubcomponentInstantiationDescription::
+    selectRequirement () const
+    {
+      return *selectRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& SubcomponentInstantiationDescription::
+    selectRequirement ()
+    {
+      return *selectRequirement_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    selectRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (selectRequirement_.get ())
+      {
+        *selectRequirement_ = e;
+      }
+
+      else
+      {
+        selectRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        selectRequirement_->container (this);
+      }
+    }
+
+    // SubcomponentInstantiationDescription
+    // 
+    bool SubcomponentInstantiationDescription::
+    reference_p () const
+    {
+      return reference_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageReference const& SubcomponentInstantiationDescription::
+    reference () const
+    {
+      return *reference_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageReference& SubcomponentInstantiationDescription::
+    reference ()
+    {
+      return *reference_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    reference (::CIAO::Config_Handlers::ComponentPackageReference const& e)
+    {
+      if (reference_.get ())
+      {
+        *reference_ = e;
+      }
+
+      else
+      {
+        reference_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (new ::CIAO::Config_Handlers::ComponentPackageReference (e));
+        reference_->container (this);
+      }
+    }
+
+    // SubcomponentInstantiationDescription
+    // 
+    bool SubcomponentInstantiationDescription::
+    id_p () const
+    {
+      return id_.get () != 0;
+    }
+
+    ::XMLSchema::ID< char > const& SubcomponentInstantiationDescription::
+    id () const
+    {
+      return *id_;
+    }
+
+    ::XMLSchema::ID< char >& SubcomponentInstantiationDescription::
+    id ()
+    {
+      return *id_;
+    }
+
+    void SubcomponentInstantiationDescription::
+    id (::XMLSchema::ID< char > const& e)
+    {
+      if (id_.get ())
+      {
+        *id_ = e;
+      }
+
+      else
+      {
+        id_ = ::std::auto_ptr< ::XMLSchema::ID< char > > (new ::XMLSchema::ID< char > (e));
+        id_->container (this);
+      }
+    }
+
+
+    // SubcomponentPropertyReference
+    // 
+
+    SubcomponentPropertyReference::
+    SubcomponentPropertyReference ()
+    :
+    propertyName_ (new ::XMLSchema::string< char > ()),
+    instance_ (new ::CIAO::Config_Handlers::SubcomponentInstantiationDescription ()),
+    regulator__ ()
+    {
+      propertyName_->container (this);
+      instance_->container (this);
+    }
+
+    SubcomponentPropertyReference::
+    SubcomponentPropertyReference (::CIAO::Config_Handlers::SubcomponentPropertyReference const& s)
+    :
+    propertyName_ (new ::XMLSchema::string< char > (*s.propertyName_)),
+    instance_ (new ::CIAO::Config_Handlers::SubcomponentInstantiationDescription (*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< char > const& SubcomponentPropertyReference::
+    propertyName () const
+    {
+      return *propertyName_;
+    }
+
+    ::XMLSchema::string< char >& SubcomponentPropertyReference::
+    propertyName ()
+    {
+      return *propertyName_;
+    }
+
+    void SubcomponentPropertyReference::
+    propertyName (::XMLSchema::string< char > const& e)
+    {
+      *propertyName_ = e;
+    }
+
+    // SubcomponentPropertyReference
+    // 
+    ::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& SubcomponentPropertyReference::
+    instance () const
+    {
+      return *instance_;
+    }
+
+    ::CIAO::Config_Handlers::SubcomponentInstantiationDescription& SubcomponentPropertyReference::
+    instance ()
+    {
+      return *instance_;
+    }
+
+    void SubcomponentPropertyReference::
+    instance (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& e)
+    {
+      *instance_ = e;
+    }
+
+
+    // AssemblyPropertyMapping
+    // 
+
+    AssemblyPropertyMapping::
+    AssemblyPropertyMapping ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    externalName_ (new ::XMLSchema::string< char > ()),
+    delegatesTo_ (new ::CIAO::Config_Handlers::SubcomponentPropertyReference ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      externalName_->container (this);
+      delegatesTo_->container (this);
+    }
+
+    AssemblyPropertyMapping::
+    AssemblyPropertyMapping (::CIAO::Config_Handlers::AssemblyPropertyMapping const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*s.name_)),
+    externalName_ (new ::XMLSchema::string< char > (*s.externalName_)),
+    delegatesTo_ (new ::CIAO::Config_Handlers::SubcomponentPropertyReference (*s.delegatesTo_)),
+    regulator__ ()
+    {
+      name_->container (this);
+      externalName_->container (this);
+      delegatesTo_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::AssemblyPropertyMapping& AssemblyPropertyMapping::
+    operator= (::CIAO::Config_Handlers::AssemblyPropertyMapping const& s)
+    {
+      name (s.name ());
+
+      externalName (s.externalName ());
+
+      delegatesTo (s.delegatesTo ());
+
+      return *this;
+    }
+
+
+    // AssemblyPropertyMapping
+    // 
+    ::XMLSchema::string< char > const& AssemblyPropertyMapping::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& AssemblyPropertyMapping::
+    name ()
+    {
+      return *name_;
+    }
+
+    void AssemblyPropertyMapping::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // AssemblyPropertyMapping
+    // 
+    ::XMLSchema::string< char > const& AssemblyPropertyMapping::
+    externalName () const
+    {
+      return *externalName_;
+    }
+
+    ::XMLSchema::string< char >& AssemblyPropertyMapping::
+    externalName ()
+    {
+      return *externalName_;
+    }
+
+    void AssemblyPropertyMapping::
+    externalName (::XMLSchema::string< char > const& e)
+    {
+      *externalName_ = e;
+    }
+
+    // AssemblyPropertyMapping
+    // 
+    ::CIAO::Config_Handlers::SubcomponentPropertyReference const& AssemblyPropertyMapping::
+    delegatesTo () const
+    {
+      return *delegatesTo_;
+    }
+
+    ::CIAO::Config_Handlers::SubcomponentPropertyReference& AssemblyPropertyMapping::
+    delegatesTo ()
+    {
+      return *delegatesTo_;
+    }
+
+    void AssemblyPropertyMapping::
+    delegatesTo (::CIAO::Config_Handlers::SubcomponentPropertyReference const& e)
+    {
+      *delegatesTo_ = e;
+    }
+
+
+    // ComponentAssemblyDescription
+    // 
+
+    ComponentAssemblyDescription::
+    ComponentAssemblyDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    ComponentAssemblyDescription::
+    ComponentAssemblyDescription (::CIAO::Config_Handlers::ComponentAssemblyDescription const& s)
+    :
+    externalProperty_ (s.externalProperty_.get () ? new ::CIAO::Config_Handlers::AssemblyPropertyMapping (*s.externalProperty_) : 0),
+    regulator__ ()
+    {
+      instance_.reserve (s.instance_.size ());
+      {
+        for (instance_const_iterator i (s.instance_.begin ());
+        i != s.instance_.end ();
+        ++i) add_instance (*i);
+      }
+
+      connection_.reserve (s.connection_.size ());
+      {
+        for (connection_const_iterator i (s.connection_.begin ());
+        i != s.connection_.end ();
+        ++i) add_connection (*i);
+      }
+
+      if (externalProperty_.get ()) externalProperty_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::ComponentAssemblyDescription& ComponentAssemblyDescription::
+    operator= (::CIAO::Config_Handlers::ComponentAssemblyDescription const& s)
+    {
+      instance_.clear ();
+      instance_.reserve (s.instance_.size ());
+      {
+        for (instance_const_iterator i (s.instance_.begin ());
+        i != s.instance_.end ();
+        ++i) add_instance (*i);
+      }
+
+      connection_.clear ();
+      connection_.reserve (s.connection_.size ());
+      {
+        for (connection_const_iterator i (s.connection_.begin ());
+        i != s.connection_.end ();
+        ++i) add_connection (*i);
+      }
+
+      if (s.externalProperty_.get ()) externalProperty (*(s.externalProperty_));
+      else externalProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::AssemblyPropertyMapping > (0);
+
+      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)
+    {
+      if (instance_.capacity () < instance_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription > v;
+        v.reserve (instance_.size () + 1);
+
+        while (instance_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::SubcomponentInstantiationDescription& t = instance_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          instance_.pop_back ();
+        }
+
+        instance_.swap (v);
+      }
+
+      instance_.push_back (e);
+      instance_.back ().container (this);
+    }
+
+    // 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)
+    {
+      if (connection_.capacity () < connection_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::AssemblyConnectionDescription > v;
+        v.reserve (connection_.size () + 1);
+
+        while (connection_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::AssemblyConnectionDescription& t = connection_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          connection_.pop_back ();
+        }
+
+        connection_.swap (v);
+      }
+
+      connection_.push_back (e);
+      connection_.back ().container (this);
+    }
+
+    // ComponentAssemblyDescription
+    // 
+    bool ComponentAssemblyDescription::
+    externalProperty_p () const
+    {
+      return externalProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::AssemblyPropertyMapping const& ComponentAssemblyDescription::
+    externalProperty () const
+    {
+      return *externalProperty_;
+    }
+
+    ::CIAO::Config_Handlers::AssemblyPropertyMapping& ComponentAssemblyDescription::
+    externalProperty ()
+    {
+      return *externalProperty_;
+    }
+
+    void ComponentAssemblyDescription::
+    externalProperty (::CIAO::Config_Handlers::AssemblyPropertyMapping const& e)
+    {
+      if (externalProperty_.get ())
+      {
+        *externalProperty_ = e;
+      }
+
+      else
+      {
+        externalProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::AssemblyPropertyMapping > (new ::CIAO::Config_Handlers::AssemblyPropertyMapping (e));
+        externalProperty_->container (this);
+      }
+    }
+
+
+    // MonolithicImplementationDescription
+    // 
+
+    MonolithicImplementationDescription::
+    MonolithicImplementationDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    MonolithicImplementationDescription::
+    MonolithicImplementationDescription (::CIAO::Config_Handlers::MonolithicImplementationDescription const& s)
+    :
+    execParameter_ (s.execParameter_.get () ? new ::CIAO::Config_Handlers::Property (*s.execParameter_) : 0),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::ImplementationRequirement (*s.deployRequirement_) : 0),
+    regulator__ ()
+    {
+      if (execParameter_.get ()) execParameter_->container (this);
+      primaryArtifact_.reserve (s.primaryArtifact_.size ());
+      {
+        for (primaryArtifact_const_iterator i (s.primaryArtifact_.begin ());
+        i != s.primaryArtifact_.end ();
+        ++i) add_primaryArtifact (*i);
+      }
+
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+    }
+
+    ::CIAO::Config_Handlers::MonolithicImplementationDescription& MonolithicImplementationDescription::
+    operator= (::CIAO::Config_Handlers::MonolithicImplementationDescription const& s)
+    {
+      if (s.execParameter_.get ()) execParameter (*(s.execParameter_));
+      else execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      primaryArtifact_.clear ();
+      primaryArtifact_.reserve (s.primaryArtifact_.size ());
+      {
+        for (primaryArtifact_const_iterator i (s.primaryArtifact_.begin ());
+        i != s.primaryArtifact_.end ();
+        ++i) add_primaryArtifact (*i);
+      }
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationRequirement > (0);
+
+      return *this;
+    }
+
+
+    // MonolithicImplementationDescription
+    // 
+    bool MonolithicImplementationDescription::
+    execParameter_p () const
+    {
+      return execParameter_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& MonolithicImplementationDescription::
+    execParameter () const
+    {
+      return *execParameter_;
+    }
+
+    ::CIAO::Config_Handlers::Property& MonolithicImplementationDescription::
+    execParameter ()
+    {
+      return *execParameter_;
+    }
+
+    void MonolithicImplementationDescription::
+    execParameter (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (execParameter_.get ())
+      {
+        *execParameter_ = e;
+      }
+
+      else
+      {
+        execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        execParameter_->container (this);
+      }
+    }
+
+    // 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)
+    {
+      if (primaryArtifact_.capacity () < primaryArtifact_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact > v;
+        v.reserve (primaryArtifact_.size () + 1);
+
+        while (primaryArtifact_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::NamedImplementationArtifact& t = primaryArtifact_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          primaryArtifact_.pop_back ();
+        }
+
+        primaryArtifact_.swap (v);
+      }
+
+      primaryArtifact_.push_back (e);
+      primaryArtifact_.back ().container (this);
+    }
+
+    // MonolithicImplementationDescription
+    // 
+    bool MonolithicImplementationDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ImplementationRequirement const& MonolithicImplementationDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::ImplementationRequirement& MonolithicImplementationDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void MonolithicImplementationDescription::
+    deployRequirement (::CIAO::Config_Handlers::ImplementationRequirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationRequirement > (new ::CIAO::Config_Handlers::ImplementationRequirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+
+    // ComponentImplementationDescription
+    // 
+
+    ComponentImplementationDescription::
+    ComponentImplementationDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    ComponentImplementationDescription::
+    ComponentImplementationDescription (::CIAO::Config_Handlers::ComponentImplementationDescription const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    implements_ (s.implements_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.implements_) : 0),
+    assemblyImpl_ (s.assemblyImpl_.get () ? new ::CIAO::Config_Handlers::ComponentAssemblyDescription (*s.assemblyImpl_) : 0),
+    monolithicImpl_ (s.monolithicImpl_.get () ? new ::CIAO::Config_Handlers::MonolithicImplementationDescription (*s.monolithicImpl_) : 0),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    capability_ (s.capability_.get () ? new ::CIAO::Config_Handlers::Capability (*s.capability_) : 0),
+    dependsOn_ (s.dependsOn_.get () ? new ::CIAO::Config_Handlers::ImplementationDependency (*s.dependsOn_) : 0),
+    infoProperty_ (s.infoProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.infoProperty_) : 0),
+    contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< char > (*s.contentLocation_) : 0),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      if (implements_.get ()) implements_->container (this);
+      if (assemblyImpl_.get ()) assemblyImpl_->container (this);
+      if (monolithicImpl_.get ()) monolithicImpl_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      if (capability_.get ()) capability_->container (this);
+      if (dependsOn_.get ()) dependsOn_->container (this);
+      if (infoProperty_.get ()) infoProperty_->container (this);
+      if (contentLocation_.get ()) contentLocation_->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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (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);
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.capability_.get ()) capability (*(s.capability_));
+      else capability_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Capability > (0);
+
+      if (s.dependsOn_.get ()) dependsOn (*(s.dependsOn_));
+      else dependsOn_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationDependency > (0);
+
+      if (s.infoProperty_.get ()) infoProperty (*(s.infoProperty_));
+      else infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_));
+      else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      return *this;
+    }
+
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    label_p () const
+    {
+      return label_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentImplementationDescription::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& ComponentImplementationDescription::
+    label ()
+    {
+      return *label_;
+    }
+
+    void ComponentImplementationDescription::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentImplementationDescription::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& ComponentImplementationDescription::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void ComponentImplementationDescription::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        UUID_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    implements_p () const
+    {
+      return implements_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ComponentImplementationDescription::
+    implements () const
+    {
+      return *implements_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription& ComponentImplementationDescription::
+    implements ()
+    {
+      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_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentAssemblyDescription& ComponentImplementationDescription::
+    assemblyImpl ()
+    {
+      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_;
+    }
+
+    ::CIAO::Config_Handlers::MonolithicImplementationDescription& ComponentImplementationDescription::
+    monolithicImpl ()
+    {
+      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
+    // 
+    bool ComponentImplementationDescription::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentImplementationDescription::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentImplementationDescription::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void ComponentImplementationDescription::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    capability_p () const
+    {
+      return capability_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Capability const& ComponentImplementationDescription::
+    capability () const
+    {
+      return *capability_;
+    }
+
+    ::CIAO::Config_Handlers::Capability& ComponentImplementationDescription::
+    capability ()
+    {
+      return *capability_;
+    }
+
+    void ComponentImplementationDescription::
+    capability (::CIAO::Config_Handlers::Capability const& e)
+    {
+      if (capability_.get ())
+      {
+        *capability_ = e;
+      }
+
+      else
+      {
+        capability_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Capability > (new ::CIAO::Config_Handlers::Capability (e));
+        capability_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    dependsOn_p () const
+    {
+      return dependsOn_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ImplementationDependency const& ComponentImplementationDescription::
+    dependsOn () const
+    {
+      return *dependsOn_;
+    }
+
+    ::CIAO::Config_Handlers::ImplementationDependency& ComponentImplementationDescription::
+    dependsOn ()
+    {
+      return *dependsOn_;
+    }
+
+    void ComponentImplementationDescription::
+    dependsOn (::CIAO::Config_Handlers::ImplementationDependency const& e)
+    {
+      if (dependsOn_.get ())
+      {
+        *dependsOn_ = e;
+      }
+
+      else
+      {
+        dependsOn_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationDependency > (new ::CIAO::Config_Handlers::ImplementationDependency (e));
+        dependsOn_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    infoProperty_p () const
+    {
+      return infoProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentImplementationDescription::
+    infoProperty () const
+    {
+      return *infoProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentImplementationDescription::
+    infoProperty ()
+    {
+      return *infoProperty_;
+    }
+
+    void ComponentImplementationDescription::
+    infoProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (infoProperty_.get ())
+      {
+        *infoProperty_ = e;
+      }
+
+      else
+      {
+        infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        infoProperty_->container (this);
+      }
+    }
+
+    // ComponentImplementationDescription
+    // 
+    bool ComponentImplementationDescription::
+    contentLocation_p () const
+    {
+      return contentLocation_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentImplementationDescription::
+    contentLocation () const
+    {
+      return *contentLocation_;
+    }
+
+    ::XMLSchema::string< char >& ComponentImplementationDescription::
+    contentLocation ()
+    {
+      return *contentLocation_;
+    }
+
+    void ComponentImplementationDescription::
+    contentLocation (::XMLSchema::string< char > const& e)
+    {
+      if (contentLocation_.get ())
+      {
+        *contentLocation_ = e;
+      }
+
+      else
+      {
+        contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        contentLocation_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // SubcomponentInstantiationDescription
+    //
+
+    SubcomponentInstantiationDescription::
+    SubcomponentInstantiationDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    package_ (new ::CIAO::Config_Handlers::ComponentPackageDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      package_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "package")
+        {
+          ::CIAO::Config_Handlers::ComponentPackageDescription t (e);
+          package (t);
+        }
+
+        else if (n == "configProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          configProperty (t);
+        }
+
+        else if (n == "selectRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          selectRequirement (t);
+        }
+
+        else if (n == "reference")
+        {
+          ::CIAO::Config_Handlers::ComponentPackageReference t (e);
+          reference (t);
+        }
+
+        else 
+        {
+        }
+      }
+
+      while (p.more_attributes ())
+      {
+        ::XSCRT::XML::Attribute< char > a (p.next_attribute ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (a.name ()));
+        if (n == "id")
+        {
+          ::XMLSchema::ID< char > t (a);
+          id (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // SubcomponentPropertyReference
+    //
+
+    SubcomponentPropertyReference::
+    SubcomponentPropertyReference (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    propertyName_ (new ::XMLSchema::string< char > ()),
+    instance_ (new ::CIAO::Config_Handlers::SubcomponentInstantiationDescription ()),
+    regulator__ ()
+    {
+      propertyName_->container (this);
+      instance_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "propertyName")
+        {
+          ::XMLSchema::string< char > t (e);
+          propertyName (t);
+        }
+
+        else if (n == "instance")
+        {
+          ::CIAO::Config_Handlers::SubcomponentInstantiationDescription t (e);
+          instance (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // AssemblyPropertyMapping
+    //
+
+    AssemblyPropertyMapping::
+    AssemblyPropertyMapping (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    externalName_ (new ::XMLSchema::string< char > ()),
+    delegatesTo_ (new ::CIAO::Config_Handlers::SubcomponentPropertyReference ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      externalName_->container (this);
+      delegatesTo_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "externalName")
+        {
+          ::XMLSchema::string< char > t (e);
+          externalName (t);
+        }
+
+        else if (n == "delegatesTo")
+        {
+          ::CIAO::Config_Handlers::SubcomponentPropertyReference t (e);
+          delegatesTo (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentAssemblyDescription
+    //
+
+    ComponentAssemblyDescription::
+    ComponentAssemblyDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > 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);
+          externalProperty (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // MonolithicImplementationDescription
+    //
+
+    MonolithicImplementationDescription::
+    MonolithicImplementationDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "execParameter")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          execParameter (t);
+        }
+
+        else if (n == "primaryArtifact")
+        {
+          ::CIAO::Config_Handlers::NamedImplementationArtifact t (e);
+          add_primaryArtifact (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::ImplementationRequirement t (e);
+          deployRequirement (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentImplementationDescription
+    //
+
+    ComponentImplementationDescription::
+    ComponentImplementationDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > 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);
+          configProperty (t);
+        }
+
+        else if (n == "capability")
+        {
+          ::CIAO::Config_Handlers::Capability t (e);
+          capability (t);
+        }
+
+        else if (n == "dependsOn")
+        {
+          ::CIAO::Config_Handlers::ImplementationDependency t (e);
+          dependsOn (t);
+        }
+
+        else if (n == "infoProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          infoProperty (t);
+        }
+
+        else if (n == "contentLocation")
+        {
+          ::XMLSchema::string< char > t (e);
+          contentLocation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cid.hpp b/TAO/CIAO/DAnCE/Config_Handlers/cid.hpp
new file mode 100644
index 00000000000..d3659edbe7d
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cid.hpp
@@ -0,0 +1,445 @@
+// $Id$
+#ifndef CID_HPP
+#define CID_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class SubcomponentInstantiationDescription;
+    class SubcomponentPropertyReference;
+    class AssemblyPropertyMapping;
+    class ComponentAssemblyDescription;
+    class MonolithicImplementationDescription;
+    class ComponentImplementationDescription;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+#include "cpd.hpp"
+
+#include "iad.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class SubcomponentInstantiationDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // package
+      // 
+      public:
+      ::CIAO::Config_Handlers::ComponentPackageDescription const& package () const;
+      ::CIAO::Config_Handlers::ComponentPackageDescription& package ();
+      void package (::CIAO::Config_Handlers::ComponentPackageDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > package_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // selectRequirement
+      // 
+      public:
+      bool selectRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& selectRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& selectRequirement ();
+      void selectRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > selectRequirement_;
+
+      // reference
+      // 
+      public:
+      bool reference_p () const;
+      ::CIAO::Config_Handlers::ComponentPackageReference const& reference () const;
+      ::CIAO::Config_Handlers::ComponentPackageReference& reference ();
+      void reference (::CIAO::Config_Handlers::ComponentPackageReference const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > reference_;
+
+      // id
+      // 
+      public:
+      bool id_p () const;
+      ::XMLSchema::ID< char > const& id () const;
+      ::XMLSchema::ID< char >& id ();
+      void id (::XMLSchema::ID< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::ID< char > > id_;
+
+      public:
+      SubcomponentInstantiationDescription ();
+      SubcomponentInstantiationDescription (::XSCRT::XML::Element< char > const&);
+      SubcomponentInstantiationDescription (SubcomponentInstantiationDescription const& s);
+
+      SubcomponentInstantiationDescription&
+      operator= (SubcomponentInstantiationDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class SubcomponentPropertyReference : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // propertyName
+      // 
+      public:
+      ::XMLSchema::string< char > const& propertyName () const;
+      ::XMLSchema::string< char >& propertyName ();
+      void propertyName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > propertyName_;
+
+      // instance
+      // 
+      public:
+      ::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& instance () const;
+      ::CIAO::Config_Handlers::SubcomponentInstantiationDescription& instance ();
+      void instance (::CIAO::Config_Handlers::SubcomponentInstantiationDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription > instance_;
+
+      public:
+      SubcomponentPropertyReference ();
+      SubcomponentPropertyReference (::XSCRT::XML::Element< char > const&);
+      SubcomponentPropertyReference (SubcomponentPropertyReference const& s);
+
+      SubcomponentPropertyReference&
+      operator= (SubcomponentPropertyReference const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class AssemblyPropertyMapping : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // externalName
+      // 
+      public:
+      ::XMLSchema::string< char > const& externalName () const;
+      ::XMLSchema::string< char >& externalName ();
+      void externalName (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > externalName_;
+
+      // delegatesTo
+      // 
+      public:
+      ::CIAO::Config_Handlers::SubcomponentPropertyReference const& delegatesTo () const;
+      ::CIAO::Config_Handlers::SubcomponentPropertyReference& delegatesTo ();
+      void delegatesTo (::CIAO::Config_Handlers::SubcomponentPropertyReference const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::SubcomponentPropertyReference > delegatesTo_;
+
+      public:
+      AssemblyPropertyMapping ();
+      AssemblyPropertyMapping (::XSCRT::XML::Element< char > const&);
+      AssemblyPropertyMapping (AssemblyPropertyMapping const& s);
+
+      AssemblyPropertyMapping&
+      operator= (AssemblyPropertyMapping const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentAssemblyDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // instance
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription >::iterator instance_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::SubcomponentInstantiationDescription > instance_;
+
+      // connection
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::AssemblyConnectionDescription >::iterator connection_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::AssemblyConnectionDescription > connection_;
+
+      // externalProperty
+      // 
+      public:
+      bool externalProperty_p () const;
+      ::CIAO::Config_Handlers::AssemblyPropertyMapping const& externalProperty () const;
+      ::CIAO::Config_Handlers::AssemblyPropertyMapping& externalProperty ();
+      void externalProperty (::CIAO::Config_Handlers::AssemblyPropertyMapping const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::AssemblyPropertyMapping > externalProperty_;
+
+      public:
+      ComponentAssemblyDescription ();
+      ComponentAssemblyDescription (::XSCRT::XML::Element< char > const&);
+      ComponentAssemblyDescription (ComponentAssemblyDescription const& s);
+
+      ComponentAssemblyDescription&
+      operator= (ComponentAssemblyDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class MonolithicImplementationDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // execParameter
+      // 
+      public:
+      bool execParameter_p () const;
+      ::CIAO::Config_Handlers::Property const& execParameter () const;
+      ::CIAO::Config_Handlers::Property& execParameter ();
+      void execParameter (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > execParameter_;
+
+      // primaryArtifact
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact >::iterator primaryArtifact_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact > primaryArtifact_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::ImplementationRequirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::ImplementationRequirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::ImplementationRequirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationRequirement > deployRequirement_;
+
+      public:
+      MonolithicImplementationDescription ();
+      MonolithicImplementationDescription (::XSCRT::XML::Element< char > const&);
+      MonolithicImplementationDescription (MonolithicImplementationDescription const& s);
+
+      MonolithicImplementationDescription&
+      operator= (MonolithicImplementationDescription const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentImplementationDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // implements
+      // 
+      public:
+      bool implements_p () const;
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription const& implements () const;
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription& implements ();
+      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;
+      ::CIAO::Config_Handlers::ComponentAssemblyDescription& assemblyImpl ();
+      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;
+      ::CIAO::Config_Handlers::MonolithicImplementationDescription& monolithicImpl ();
+      void monolithicImpl (::CIAO::Config_Handlers::MonolithicImplementationDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::MonolithicImplementationDescription > monolithicImpl_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // capability
+      // 
+      public:
+      bool capability_p () const;
+      ::CIAO::Config_Handlers::Capability const& capability () const;
+      ::CIAO::Config_Handlers::Capability& capability ();
+      void capability (::CIAO::Config_Handlers::Capability const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Capability > capability_;
+
+      // dependsOn
+      // 
+      public:
+      bool dependsOn_p () const;
+      ::CIAO::Config_Handlers::ImplementationDependency const& dependsOn () const;
+      ::CIAO::Config_Handlers::ImplementationDependency& dependsOn ();
+      void dependsOn (::CIAO::Config_Handlers::ImplementationDependency const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationDependency > dependsOn_;
+
+      // infoProperty
+      // 
+      public:
+      bool infoProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& infoProperty () const;
+      ::CIAO::Config_Handlers::Property& infoProperty ();
+      void infoProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      // contentLocation
+      // 
+      public:
+      bool contentLocation_p () const;
+      ::XMLSchema::string< char > const& contentLocation () const;
+      ::XMLSchema::string< char >& contentLocation ();
+      void contentLocation (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > contentLocation_;
+
+      public:
+      ComponentImplementationDescription ();
+      ComponentImplementationDescription (::XSCRT::XML::Element< char > const&);
+      ComponentImplementationDescription (ComponentImplementationDescription const& s);
+
+      ComponentImplementationDescription&
+      operator= (ComponentImplementationDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // CID_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cpd.cpp b/TAO/CIAO/DAnCE/Config_Handlers/cpd.cpp
new file mode 100644
index 00000000000..93ffc86d1d3
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cpd.cpp
@@ -0,0 +1,507 @@
+// $Id$
+#include "cpd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // PackagedComponentImplementation
+    // 
+
+    PackagedComponentImplementation::
+    PackagedComponentImplementation ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    referencedImplementation_ (new ::CIAO::Config_Handlers::ComponentImplementationDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      referencedImplementation_->container (this);
+    }
+
+    PackagedComponentImplementation::
+    PackagedComponentImplementation (::CIAO::Config_Handlers::PackagedComponentImplementation const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*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< char > const& PackagedComponentImplementation::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& PackagedComponentImplementation::
+    name ()
+    {
+      return *name_;
+    }
+
+    void PackagedComponentImplementation::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // PackagedComponentImplementation
+    // 
+    ::CIAO::Config_Handlers::ComponentImplementationDescription const& PackagedComponentImplementation::
+    referencedImplementation () const
+    {
+      return *referencedImplementation_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentImplementationDescription& PackagedComponentImplementation::
+    referencedImplementation ()
+    {
+      return *referencedImplementation_;
+    }
+
+    void PackagedComponentImplementation::
+    referencedImplementation (::CIAO::Config_Handlers::ComponentImplementationDescription const& e)
+    {
+      *referencedImplementation_ = e;
+    }
+
+
+    // ComponentPackageDescription
+    // 
+
+    ComponentPackageDescription::
+    ComponentPackageDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    ComponentPackageDescription::
+    ComponentPackageDescription (::CIAO::Config_Handlers::ComponentPackageDescription const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    realizes_ (s.realizes_.get () ? new ::CIAO::Config_Handlers::ComponentInterfaceDescription (*s.realizes_) : 0),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    implementation_ (s.implementation_.get () ? new ::CIAO::Config_Handlers::PackagedComponentImplementation (*s.implementation_) : 0),
+    infoProperty_ (s.infoProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.infoProperty_) : 0),
+    contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< char > (*s.contentLocation_) : 0),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      if (realizes_.get ()) realizes_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      if (implementation_.get ()) implementation_->container (this);
+      if (infoProperty_.get ()) infoProperty_->container (this);
+      if (contentLocation_.get ()) contentLocation_->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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.realizes_.get ()) realizes (*(s.realizes_));
+      else realizes_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > (0);
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.implementation_.get ()) implementation (*(s.implementation_));
+      else implementation_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackagedComponentImplementation > (0);
+
+      if (s.infoProperty_.get ()) infoProperty (*(s.infoProperty_));
+      else infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_));
+      else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      return *this;
+    }
+
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    label_p () const
+    {
+      return label_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentPackageDescription::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageDescription::
+    label ()
+    {
+      return *label_;
+    }
+
+    void ComponentPackageDescription::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentPackageDescription::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageDescription::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void ComponentPackageDescription::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        UUID_->container (this);
+      }
+    }
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    realizes_p () const
+    {
+      return realizes_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription const& ComponentPackageDescription::
+    realizes () const
+    {
+      return *realizes_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentInterfaceDescription& ComponentPackageDescription::
+    realizes ()
+    {
+      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
+    // 
+    bool ComponentPackageDescription::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentPackageDescription::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentPackageDescription::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void ComponentPackageDescription::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    implementation_p () const
+    {
+      return implementation_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::PackagedComponentImplementation const& ComponentPackageDescription::
+    implementation () const
+    {
+      return *implementation_;
+    }
+
+    ::CIAO::Config_Handlers::PackagedComponentImplementation& ComponentPackageDescription::
+    implementation ()
+    {
+      return *implementation_;
+    }
+
+    void ComponentPackageDescription::
+    implementation (::CIAO::Config_Handlers::PackagedComponentImplementation const& e)
+    {
+      if (implementation_.get ())
+      {
+        *implementation_ = e;
+      }
+
+      else
+      {
+        implementation_ = ::std::auto_ptr< ::CIAO::Config_Handlers::PackagedComponentImplementation > (new ::CIAO::Config_Handlers::PackagedComponentImplementation (e));
+        implementation_->container (this);
+      }
+    }
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    infoProperty_p () const
+    {
+      return infoProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ComponentPackageDescription::
+    infoProperty () const
+    {
+      return *infoProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ComponentPackageDescription::
+    infoProperty ()
+    {
+      return *infoProperty_;
+    }
+
+    void ComponentPackageDescription::
+    infoProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (infoProperty_.get ())
+      {
+        *infoProperty_ = e;
+      }
+
+      else
+      {
+        infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        infoProperty_->container (this);
+      }
+    }
+
+    // ComponentPackageDescription
+    // 
+    bool ComponentPackageDescription::
+    contentLocation_p () const
+    {
+      return contentLocation_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ComponentPackageDescription::
+    contentLocation () const
+    {
+      return *contentLocation_;
+    }
+
+    ::XMLSchema::string< char >& ComponentPackageDescription::
+    contentLocation ()
+    {
+      return *contentLocation_;
+    }
+
+    void ComponentPackageDescription::
+    contentLocation (::XMLSchema::string< char > const& e)
+    {
+      if (contentLocation_.get ())
+      {
+        *contentLocation_ = e;
+      }
+
+      else
+      {
+        contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        contentLocation_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // PackagedComponentImplementation
+    //
+
+    PackagedComponentImplementation::
+    PackagedComponentImplementation (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    referencedImplementation_ (new ::CIAO::Config_Handlers::ComponentImplementationDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      referencedImplementation_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "referencedImplementation")
+        {
+          ::CIAO::Config_Handlers::ComponentImplementationDescription t (e);
+          referencedImplementation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ComponentPackageDescription
+    //
+
+    ComponentPackageDescription::
+    ComponentPackageDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > 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);
+          configProperty (t);
+        }
+
+        else if (n == "implementation")
+        {
+          ::CIAO::Config_Handlers::PackagedComponentImplementation t (e);
+          implementation (t);
+        }
+
+        else if (n == "infoProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          infoProperty (t);
+        }
+
+        else if (n == "contentLocation")
+        {
+          ::XMLSchema::string< char > t (e);
+          contentLocation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/cpd.hpp b/TAO/CIAO/DAnCE/Config_Handlers/cpd.hpp
new file mode 100644
index 00000000000..9d9292e8682
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/cpd.hpp
@@ -0,0 +1,169 @@
+// $Id$
+#ifndef CPD_HPP
+#define CPD_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class PackagedComponentImplementation;
+    class ComponentPackageDescription;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "ccd.hpp"
+
+#include "cid.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class PackagedComponentImplementation : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // referencedImplementation
+      // 
+      public:
+      ::CIAO::Config_Handlers::ComponentImplementationDescription const& referencedImplementation () const;
+      ::CIAO::Config_Handlers::ComponentImplementationDescription& referencedImplementation ();
+      void referencedImplementation (::CIAO::Config_Handlers::ComponentImplementationDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentImplementationDescription > referencedImplementation_;
+
+      public:
+      PackagedComponentImplementation ();
+      PackagedComponentImplementation (::XSCRT::XML::Element< char > const&);
+      PackagedComponentImplementation (PackagedComponentImplementation const& s);
+
+      PackagedComponentImplementation&
+      operator= (PackagedComponentImplementation const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ComponentPackageDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // realizes
+      // 
+      public:
+      bool realizes_p () const;
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription const& realizes () const;
+      ::CIAO::Config_Handlers::ComponentInterfaceDescription& realizes ();
+      void realizes (::CIAO::Config_Handlers::ComponentInterfaceDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentInterfaceDescription > realizes_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // implementation
+      // 
+      public:
+      bool implementation_p () const;
+      ::CIAO::Config_Handlers::PackagedComponentImplementation const& implementation () const;
+      ::CIAO::Config_Handlers::PackagedComponentImplementation& implementation ();
+      void implementation (::CIAO::Config_Handlers::PackagedComponentImplementation const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::PackagedComponentImplementation > implementation_;
+
+      // infoProperty
+      // 
+      public:
+      bool infoProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& infoProperty () const;
+      ::CIAO::Config_Handlers::Property& infoProperty ();
+      void infoProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      // contentLocation
+      // 
+      public:
+      bool contentLocation_p () const;
+      ::XMLSchema::string< char > const& contentLocation () const;
+      ::XMLSchema::string< char >& contentLocation ();
+      void contentLocation (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > contentLocation_;
+
+      public:
+      ComponentPackageDescription ();
+      ComponentPackageDescription (::XSCRT::XML::Element< char > const&);
+      ComponentPackageDescription (ComponentPackageDescription const& s);
+
+      ComponentPackageDescription&
+      operator= (ComponentPackageDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // CPD_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/iad.cpp b/TAO/CIAO/DAnCE/Config_Handlers/iad.cpp
new file mode 100644
index 00000000000..4615031d2ab
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/iad.cpp
@@ -0,0 +1,605 @@
+// $Id$
+#include "iad.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // NamedImplementationArtifact
+    // 
+
+    NamedImplementationArtifact::
+    NamedImplementationArtifact ()
+    :
+    name_ (new ::XMLSchema::string< char > ()),
+    referencedArtifact_ (new ::CIAO::Config_Handlers::ImplementationArtifactDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      referencedArtifact_->container (this);
+    }
+
+    NamedImplementationArtifact::
+    NamedImplementationArtifact (::CIAO::Config_Handlers::NamedImplementationArtifact const& s)
+    :
+    name_ (new ::XMLSchema::string< char > (*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< char > const& NamedImplementationArtifact::
+    name () const
+    {
+      return *name_;
+    }
+
+    ::XMLSchema::string< char >& NamedImplementationArtifact::
+    name ()
+    {
+      return *name_;
+    }
+
+    void NamedImplementationArtifact::
+    name (::XMLSchema::string< char > const& e)
+    {
+      *name_ = e;
+    }
+
+    // NamedImplementationArtifact
+    // 
+    ::CIAO::Config_Handlers::ImplementationArtifactDescription const& NamedImplementationArtifact::
+    referencedArtifact () const
+    {
+      return *referencedArtifact_;
+    }
+
+    ::CIAO::Config_Handlers::ImplementationArtifactDescription& NamedImplementationArtifact::
+    referencedArtifact ()
+    {
+      return *referencedArtifact_;
+    }
+
+    void NamedImplementationArtifact::
+    referencedArtifact (::CIAO::Config_Handlers::ImplementationArtifactDescription const& e)
+    {
+      *referencedArtifact_ = e;
+    }
+
+
+    // ImplementationArtifactDescription
+    // 
+
+    ImplementationArtifactDescription::
+    ImplementationArtifactDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    ImplementationArtifactDescription::
+    ImplementationArtifactDescription (::CIAO::Config_Handlers::ImplementationArtifactDescription const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    execParameter_ (s.execParameter_.get () ? new ::CIAO::Config_Handlers::Property (*s.execParameter_) : 0),
+    deployRequirement_ (s.deployRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.deployRequirement_) : 0),
+    infoProperty_ (s.infoProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.infoProperty_) : 0),
+    contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< char > (*s.contentLocation_) : 0),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      location_.reserve (s.location_.size ());
+      {
+        for (location_const_iterator i (s.location_.begin ());
+        i != s.location_.end ();
+        ++i) add_location (*i);
+      }
+
+      if (execParameter_.get ()) execParameter_->container (this);
+      if (deployRequirement_.get ()) deployRequirement_->container (this);
+      dependsOn_.reserve (s.dependsOn_.size ());
+      {
+        for (dependsOn_const_iterator i (s.dependsOn_.begin ());
+        i != s.dependsOn_.end ();
+        ++i) add_dependsOn (*i);
+      }
+
+      if (infoProperty_.get ()) infoProperty_->container (this);
+      if (contentLocation_.get ()) contentLocation_->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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      location_.clear ();
+      location_.reserve (s.location_.size ());
+      {
+        for (location_const_iterator i (s.location_.begin ());
+        i != s.location_.end ();
+        ++i) add_location (*i);
+      }
+
+      if (s.execParameter_.get ()) execParameter (*(s.execParameter_));
+      else execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.deployRequirement_.get ()) deployRequirement (*(s.deployRequirement_));
+      else deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      dependsOn_.clear ();
+      dependsOn_.reserve (s.dependsOn_.size ());
+      {
+        for (dependsOn_const_iterator i (s.dependsOn_.begin ());
+        i != s.dependsOn_.end ();
+        ++i) add_dependsOn (*i);
+      }
+
+      if (s.infoProperty_.get ()) infoProperty (*(s.infoProperty_));
+      else infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_));
+      else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      return *this;
+    }
+
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    label_p () const
+    {
+      return label_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ImplementationArtifactDescription::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationArtifactDescription::
+    label ()
+    {
+      return *label_;
+    }
+
+    void ImplementationArtifactDescription::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ImplementationArtifactDescription::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationArtifactDescription::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void ImplementationArtifactDescription::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (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< char > const& e)
+    {
+      if (location_.capacity () < location_.size () + 1)
+      {
+        ::std::vector< ::XMLSchema::string< char > > v;
+        v.reserve (location_.size () + 1);
+
+        while (location_.size ())
+        {
+          //@@ VC6
+          ::XMLSchema::string< char >& t = location_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          location_.pop_back ();
+        }
+
+        location_.swap (v);
+      }
+
+      location_.push_back (e);
+      location_.back ().container (this);
+    }
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    execParameter_p () const
+    {
+      return execParameter_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ImplementationArtifactDescription::
+    execParameter () const
+    {
+      return *execParameter_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ImplementationArtifactDescription::
+    execParameter ()
+    {
+      return *execParameter_;
+    }
+
+    void ImplementationArtifactDescription::
+    execParameter (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (execParameter_.get ())
+      {
+        *execParameter_ = e;
+      }
+
+      else
+      {
+        execParameter_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        execParameter_->container (this);
+      }
+    }
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    deployRequirement_p () const
+    {
+      return deployRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& ImplementationArtifactDescription::
+    deployRequirement () const
+    {
+      return *deployRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& ImplementationArtifactDescription::
+    deployRequirement ()
+    {
+      return *deployRequirement_;
+    }
+
+    void ImplementationArtifactDescription::
+    deployRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (deployRequirement_.get ())
+      {
+        *deployRequirement_ = e;
+      }
+
+      else
+      {
+        deployRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        deployRequirement_->container (this);
+      }
+    }
+
+    // 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)
+    {
+      if (dependsOn_.capacity () < dependsOn_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact > v;
+        v.reserve (dependsOn_.size () + 1);
+
+        while (dependsOn_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::NamedImplementationArtifact& t = dependsOn_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          dependsOn_.pop_back ();
+        }
+
+        dependsOn_.swap (v);
+      }
+
+      dependsOn_.push_back (e);
+      dependsOn_.back ().container (this);
+    }
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    infoProperty_p () const
+    {
+      return infoProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& ImplementationArtifactDescription::
+    infoProperty () const
+    {
+      return *infoProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& ImplementationArtifactDescription::
+    infoProperty ()
+    {
+      return *infoProperty_;
+    }
+
+    void ImplementationArtifactDescription::
+    infoProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (infoProperty_.get ())
+      {
+        *infoProperty_ = e;
+      }
+
+      else
+      {
+        infoProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        infoProperty_->container (this);
+      }
+    }
+
+    // ImplementationArtifactDescription
+    // 
+    bool ImplementationArtifactDescription::
+    contentLocation_p () const
+    {
+      return contentLocation_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& ImplementationArtifactDescription::
+    contentLocation () const
+    {
+      return *contentLocation_;
+    }
+
+    ::XMLSchema::string< char >& ImplementationArtifactDescription::
+    contentLocation ()
+    {
+      return *contentLocation_;
+    }
+
+    void ImplementationArtifactDescription::
+    contentLocation (::XMLSchema::string< char > const& e)
+    {
+      if (contentLocation_.get ())
+      {
+        *contentLocation_ = e;
+      }
+
+      else
+      {
+        contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        contentLocation_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // NamedImplementationArtifact
+    //
+
+    NamedImplementationArtifact::
+    NamedImplementationArtifact (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    name_ (new ::XMLSchema::string< char > ()),
+    referencedArtifact_ (new ::CIAO::Config_Handlers::ImplementationArtifactDescription ()),
+    regulator__ ()
+    {
+      name_->container (this);
+      referencedArtifact_->container (this);
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "name")
+        {
+          ::XMLSchema::string< char > t (e);
+          name (t);
+        }
+
+        else if (n == "referencedArtifact")
+        {
+          ::CIAO::Config_Handlers::ImplementationArtifactDescription t (e);
+          referencedArtifact (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+
+    // ImplementationArtifactDescription
+    //
+
+    ImplementationArtifactDescription::
+    ImplementationArtifactDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > t (e);
+          UUID (t);
+        }
+
+        else if (n == "location")
+        {
+          ::XMLSchema::string< char > t (e);
+          add_location (t);
+        }
+
+        else if (n == "execParameter")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          execParameter (t);
+        }
+
+        else if (n == "deployRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          deployRequirement (t);
+        }
+
+        else if (n == "dependsOn")
+        {
+          ::CIAO::Config_Handlers::NamedImplementationArtifact t (e);
+          add_dependsOn (t);
+        }
+
+        else if (n == "infoProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          infoProperty (t);
+        }
+
+        else if (n == "contentLocation")
+        {
+          ::XMLSchema::string< char > t (e);
+          contentLocation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/iad.hpp b/TAO/CIAO/DAnCE/Config_Handlers/iad.hpp
new file mode 100644
index 00000000000..a94ef2fd5a0
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/iad.hpp
@@ -0,0 +1,184 @@
+// $Id$
+#ifndef IAD_HPP
+#define IAD_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class NamedImplementationArtifact;
+    class ImplementationArtifactDescription;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class NamedImplementationArtifact : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // name
+      // 
+      public:
+      ::XMLSchema::string< char > const& name () const;
+      ::XMLSchema::string< char >& name ();
+      void name (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > name_;
+
+      // referencedArtifact
+      // 
+      public:
+      ::CIAO::Config_Handlers::ImplementationArtifactDescription const& referencedArtifact () const;
+      ::CIAO::Config_Handlers::ImplementationArtifactDescription& referencedArtifact ();
+      void referencedArtifact (::CIAO::Config_Handlers::ImplementationArtifactDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ImplementationArtifactDescription > referencedArtifact_;
+
+      public:
+      NamedImplementationArtifact ();
+      NamedImplementationArtifact (::XSCRT::XML::Element< char > const&);
+      NamedImplementationArtifact (NamedImplementationArtifact const& s);
+
+      NamedImplementationArtifact&
+      operator= (NamedImplementationArtifact const& s);
+
+      private:
+      char regulator__;
+    };
+
+    class ImplementationArtifactDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // location
+      // 
+      public:
+      typedef ::std::vector< ::XMLSchema::string< char > >::iterator location_iterator;
+      typedef ::std::vector< ::XMLSchema::string< char > >::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< char > const& );
+
+      protected:
+      ::std::vector< ::XMLSchema::string< char > > location_;
+
+      // execParameter
+      // 
+      public:
+      bool execParameter_p () const;
+      ::CIAO::Config_Handlers::Property const& execParameter () const;
+      ::CIAO::Config_Handlers::Property& execParameter ();
+      void execParameter (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > execParameter_;
+
+      // deployRequirement
+      // 
+      public:
+      bool deployRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& deployRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& deployRequirement ();
+      void deployRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > deployRequirement_;
+
+      // dependsOn
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact >::iterator dependsOn_iterator;
+      typedef ::std::vector< ::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& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::NamedImplementationArtifact > dependsOn_;
+
+      // infoProperty
+      // 
+      public:
+      bool infoProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& infoProperty () const;
+      ::CIAO::Config_Handlers::Property& infoProperty ();
+      void infoProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > infoProperty_;
+
+      // contentLocation
+      // 
+      public:
+      bool contentLocation_p () const;
+      ::XMLSchema::string< char > const& contentLocation () const;
+      ::XMLSchema::string< char >& contentLocation ();
+      void contentLocation (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > contentLocation_;
+
+      public:
+      ImplementationArtifactDescription ();
+      ImplementationArtifactDescription (::XSCRT::XML::Element< char > const&);
+      ImplementationArtifactDescription (ImplementationArtifactDescription const& s);
+
+      ImplementationArtifactDescription&
+      operator= (ImplementationArtifactDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // IAD_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/pcd.cpp b/TAO/CIAO/DAnCE/Config_Handlers/pcd.cpp
new file mode 100644
index 00000000000..bcae0ddb3a8
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/pcd.cpp
@@ -0,0 +1,391 @@
+// $Id$
+#include "pcd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // PackageConfiguration
+    // 
+
+    PackageConfiguration::
+    PackageConfiguration ()
+    :
+    regulator__ ()
+    {
+    }
+
+    PackageConfiguration::
+    PackageConfiguration (::CIAO::Config_Handlers::PackageConfiguration const& s)
+    :
+    label_ (s.label_.get () ? new ::XMLSchema::string< char > (*s.label_) : 0),
+    UUID_ (s.UUID_.get () ? new ::XMLSchema::string< char > (*s.UUID_) : 0),
+    basePackage_ (s.basePackage_.get () ? new ::CIAO::Config_Handlers::ComponentPackageDescription (*s.basePackage_) : 0),
+    reference_ (s.reference_.get () ? new ::CIAO::Config_Handlers::ComponentPackageReference (*s.reference_) : 0),
+    selectRequirement_ (s.selectRequirement_.get () ? new ::CIAO::Config_Handlers::Requirement (*s.selectRequirement_) : 0),
+    configProperty_ (s.configProperty_.get () ? new ::CIAO::Config_Handlers::Property (*s.configProperty_) : 0),
+    contentLocation_ (s.contentLocation_.get () ? new ::XMLSchema::string< char > (*s.contentLocation_) : 0),
+    regulator__ ()
+    {
+      if (label_.get ()) label_->container (this);
+      if (UUID_.get ()) UUID_->container (this);
+      if (basePackage_.get ()) basePackage_->container (this);
+      if (reference_.get ()) reference_->container (this);
+      if (selectRequirement_.get ()) selectRequirement_->container (this);
+      if (configProperty_.get ()) configProperty_->container (this);
+      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< char > > (0);
+
+      if (s.UUID_.get ()) UUID (*(s.UUID_));
+      else UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      if (s.basePackage_.get ()) basePackage (*(s.basePackage_));
+      else basePackage_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > (0);
+
+      if (s.reference_.get ()) reference (*(s.reference_));
+      else reference_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (0);
+
+      if (s.selectRequirement_.get ()) selectRequirement (*(s.selectRequirement_));
+      else selectRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (0);
+
+      if (s.configProperty_.get ()) configProperty (*(s.configProperty_));
+      else configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (0);
+
+      if (s.contentLocation_.get ()) contentLocation (*(s.contentLocation_));
+      else contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (0);
+
+      return *this;
+    }
+
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    label_p () const
+    {
+      return label_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& PackageConfiguration::
+    label () const
+    {
+      return *label_;
+    }
+
+    ::XMLSchema::string< char >& PackageConfiguration::
+    label ()
+    {
+      return *label_;
+    }
+
+    void PackageConfiguration::
+    label (::XMLSchema::string< char > const& e)
+    {
+      if (label_.get ())
+      {
+        *label_ = e;
+      }
+
+      else
+      {
+        label_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        label_->container (this);
+      }
+    }
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    UUID_p () const
+    {
+      return UUID_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& PackageConfiguration::
+    UUID () const
+    {
+      return *UUID_;
+    }
+
+    ::XMLSchema::string< char >& PackageConfiguration::
+    UUID ()
+    {
+      return *UUID_;
+    }
+
+    void PackageConfiguration::
+    UUID (::XMLSchema::string< char > const& e)
+    {
+      if (UUID_.get ())
+      {
+        *UUID_ = e;
+      }
+
+      else
+      {
+        UUID_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        UUID_->container (this);
+      }
+    }
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    basePackage_p () const
+    {
+      return basePackage_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageDescription const& PackageConfiguration::
+    basePackage () const
+    {
+      return *basePackage_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageDescription& PackageConfiguration::
+    basePackage ()
+    {
+      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::
+    reference_p () const
+    {
+      return reference_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageReference const& PackageConfiguration::
+    reference () const
+    {
+      return *reference_;
+    }
+
+    ::CIAO::Config_Handlers::ComponentPackageReference& PackageConfiguration::
+    reference ()
+    {
+      return *reference_;
+    }
+
+    void PackageConfiguration::
+    reference (::CIAO::Config_Handlers::ComponentPackageReference const& e)
+    {
+      if (reference_.get ())
+      {
+        *reference_ = e;
+      }
+
+      else
+      {
+        reference_ = ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > (new ::CIAO::Config_Handlers::ComponentPackageReference (e));
+        reference_->container (this);
+      }
+    }
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    selectRequirement_p () const
+    {
+      return selectRequirement_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Requirement const& PackageConfiguration::
+    selectRequirement () const
+    {
+      return *selectRequirement_;
+    }
+
+    ::CIAO::Config_Handlers::Requirement& PackageConfiguration::
+    selectRequirement ()
+    {
+      return *selectRequirement_;
+    }
+
+    void PackageConfiguration::
+    selectRequirement (::CIAO::Config_Handlers::Requirement const& e)
+    {
+      if (selectRequirement_.get ())
+      {
+        *selectRequirement_ = e;
+      }
+
+      else
+      {
+        selectRequirement_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > (new ::CIAO::Config_Handlers::Requirement (e));
+        selectRequirement_->container (this);
+      }
+    }
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    configProperty_p () const
+    {
+      return configProperty_.get () != 0;
+    }
+
+    ::CIAO::Config_Handlers::Property const& PackageConfiguration::
+    configProperty () const
+    {
+      return *configProperty_;
+    }
+
+    ::CIAO::Config_Handlers::Property& PackageConfiguration::
+    configProperty ()
+    {
+      return *configProperty_;
+    }
+
+    void PackageConfiguration::
+    configProperty (::CIAO::Config_Handlers::Property const& e)
+    {
+      if (configProperty_.get ())
+      {
+        *configProperty_ = e;
+      }
+
+      else
+      {
+        configProperty_ = ::std::auto_ptr< ::CIAO::Config_Handlers::Property > (new ::CIAO::Config_Handlers::Property (e));
+        configProperty_->container (this);
+      }
+    }
+
+    // PackageConfiguration
+    // 
+    bool PackageConfiguration::
+    contentLocation_p () const
+    {
+      return contentLocation_.get () != 0;
+    }
+
+    ::XMLSchema::string< char > const& PackageConfiguration::
+    contentLocation () const
+    {
+      return *contentLocation_;
+    }
+
+    ::XMLSchema::string< char >& PackageConfiguration::
+    contentLocation ()
+    {
+      return *contentLocation_;
+    }
+
+    void PackageConfiguration::
+    contentLocation (::XMLSchema::string< char > const& e)
+    {
+      if (contentLocation_.get ())
+      {
+        *contentLocation_ = e;
+      }
+
+      else
+      {
+        contentLocation_ = ::std::auto_ptr< ::XMLSchema::string< char > > (new ::XMLSchema::string< char > (e));
+        contentLocation_->container (this);
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // PackageConfiguration
+    //
+
+    PackageConfiguration::
+    PackageConfiguration (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "label")
+        {
+          ::XMLSchema::string< char > t (e);
+          label (t);
+        }
+
+        else if (n == "UUID")
+        {
+          ::XMLSchema::string< char > t (e);
+          UUID (t);
+        }
+
+        else if (n == "basePackage")
+        {
+          ::CIAO::Config_Handlers::ComponentPackageDescription t (e);
+          basePackage (t);
+        }
+
+        else if (n == "reference")
+        {
+          ::CIAO::Config_Handlers::ComponentPackageReference t (e);
+          reference (t);
+        }
+
+        else if (n == "selectRequirement")
+        {
+          ::CIAO::Config_Handlers::Requirement t (e);
+          selectRequirement (t);
+        }
+
+        else if (n == "configProperty")
+        {
+          ::CIAO::Config_Handlers::Property t (e);
+          configProperty (t);
+        }
+
+        else if (n == "contentLocation")
+        {
+          ::XMLSchema::string< char > t (e);
+          contentLocation (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/pcd.hpp b/TAO/CIAO/DAnCE/Config_Handlers/pcd.hpp
new file mode 100644
index 00000000000..2b76f3cfdcc
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/pcd.hpp
@@ -0,0 +1,131 @@
+// $Id$
+#ifndef PCD_HPP
+#define PCD_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class PackageConfiguration;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "Basic_Deployment_Data.hpp"
+
+#include "cpd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class PackageConfiguration : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // label
+      // 
+      public:
+      bool label_p () const;
+      ::XMLSchema::string< char > const& label () const;
+      ::XMLSchema::string< char >& label ();
+      void label (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > label_;
+
+      // UUID
+      // 
+      public:
+      bool UUID_p () const;
+      ::XMLSchema::string< char > const& UUID () const;
+      ::XMLSchema::string< char >& UUID ();
+      void UUID (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > UUID_;
+
+      // basePackage
+      // 
+      public:
+      bool basePackage_p () const;
+      ::CIAO::Config_Handlers::ComponentPackageDescription const& basePackage () const;
+      ::CIAO::Config_Handlers::ComponentPackageDescription& basePackage ();
+      void basePackage (::CIAO::Config_Handlers::ComponentPackageDescription const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageDescription > basePackage_;
+
+      // reference
+      // 
+      public:
+      bool reference_p () const;
+      ::CIAO::Config_Handlers::ComponentPackageReference const& reference () const;
+      ::CIAO::Config_Handlers::ComponentPackageReference& reference ();
+      void reference (::CIAO::Config_Handlers::ComponentPackageReference const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::ComponentPackageReference > reference_;
+
+      // selectRequirement
+      // 
+      public:
+      bool selectRequirement_p () const;
+      ::CIAO::Config_Handlers::Requirement const& selectRequirement () const;
+      ::CIAO::Config_Handlers::Requirement& selectRequirement ();
+      void selectRequirement (::CIAO::Config_Handlers::Requirement const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Requirement > selectRequirement_;
+
+      // configProperty
+      // 
+      public:
+      bool configProperty_p () const;
+      ::CIAO::Config_Handlers::Property const& configProperty () const;
+      ::CIAO::Config_Handlers::Property& configProperty ();
+      void configProperty (::CIAO::Config_Handlers::Property const& );
+
+      protected:
+      ::std::auto_ptr< ::CIAO::Config_Handlers::Property > configProperty_;
+
+      // contentLocation
+      // 
+      public:
+      bool contentLocation_p () const;
+      ::XMLSchema::string< char > const& contentLocation () const;
+      ::XMLSchema::string< char >& contentLocation ();
+      void contentLocation (::XMLSchema::string< char > const& );
+
+      protected:
+      ::std::auto_ptr< ::XMLSchema::string< char > > contentLocation_;
+
+      public:
+      PackageConfiguration ();
+      PackageConfiguration (::XSCRT::XML::Element< char > const&);
+      PackageConfiguration (PackageConfiguration const& s);
+
+      PackageConfiguration&
+      operator= (PackageConfiguration const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // PCD_HPP
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/toplevel.cpp b/TAO/CIAO/DAnCE/Config_Handlers/toplevel.cpp
new file mode 100644
index 00000000000..5cc0c37b532
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/toplevel.cpp
@@ -0,0 +1,140 @@
+// $Id$
+#include "toplevel.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // TopLevelPackageDescription
+    // 
+
+    TopLevelPackageDescription::
+    TopLevelPackageDescription ()
+    :
+    regulator__ ()
+    {
+    }
+
+    TopLevelPackageDescription::
+    TopLevelPackageDescription (::CIAO::Config_Handlers::TopLevelPackageDescription const& s)
+    :
+    regulator__ ()
+    {
+      package_.reserve (s.package_.size ());
+      {
+        for (package_const_iterator i (s.package_.begin ());
+        i != s.package_.end ();
+        ++i) add_package (*i);
+      }
+    }
+
+    ::CIAO::Config_Handlers::TopLevelPackageDescription& TopLevelPackageDescription::
+    operator= (::CIAO::Config_Handlers::TopLevelPackageDescription const& s)
+    {
+      package_.clear ();
+      package_.reserve (s.package_.size ());
+      {
+        for (package_const_iterator i (s.package_.begin ());
+        i != s.package_.end ();
+        ++i) add_package (*i);
+      }
+
+      return *this;
+    }
+
+
+    // TopLevelPackageDescription
+    // 
+    TopLevelPackageDescription::package_iterator TopLevelPackageDescription::
+    begin_package ()
+    {
+      return package_.begin ();
+    }
+
+    TopLevelPackageDescription::package_iterator TopLevelPackageDescription::
+    end_package ()
+    {
+      return package_.end ();
+    }
+
+    TopLevelPackageDescription::package_const_iterator TopLevelPackageDescription::
+    begin_package () const
+    {
+      return package_.begin ();
+    }
+
+    TopLevelPackageDescription::package_const_iterator TopLevelPackageDescription::
+    end_package () const
+    {
+      return package_.end ();
+    }
+
+    void TopLevelPackageDescription::
+    add_package (::CIAO::Config_Handlers::PackageConfiguration const& e)
+    {
+      if (package_.capacity () < package_.size () + 1)
+      {
+        ::std::vector< ::CIAO::Config_Handlers::PackageConfiguration > v;
+        v.reserve (package_.size () + 1);
+
+        while (package_.size ())
+        {
+          //@@ VC6
+          ::CIAO::Config_Handlers::PackageConfiguration& t = package_.back ();
+          t.container (0);
+          v.push_back (t);
+          v.back ().container (this);
+          package_.pop_back ();
+        }
+
+        package_.swap (v);
+      }
+
+      package_.push_back (e);
+      package_.back ().container (this);
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    // TopLevelPackageDescription
+    //
+
+    TopLevelPackageDescription::
+    TopLevelPackageDescription (::XSCRT::XML::Element< char > const& e)
+    :
+    Base__ (e),
+    regulator__ ()
+    {
+
+      ::XSCRT::Parser< char > p (e);
+
+      while (p.more_elements ())
+      {
+        ::XSCRT::XML::Element< char > e (p.next_element ());
+        ::std::basic_string< char > n (::XSCRT::XML::uq_name (e.name ()));
+
+        if (n == "package")
+        {
+          ::CIAO::Config_Handlers::PackageConfiguration t (e);
+          add_package (t);
+        }
+
+        else 
+        {
+        }
+      }
+    }
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/toplevel.hpp b/TAO/CIAO/DAnCE/Config_Handlers/toplevel.hpp
new file mode 100644
index 00000000000..c2f860ea87f
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/toplevel.hpp
@@ -0,0 +1,66 @@
+// $Id$
+#ifndef TOPLEVEL_HPP
+#define TOPLEVEL_HPP
+
+// Forward declarations.
+//
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class TopLevelPackageDescription;
+  }
+}
+
+#include <memory>
+#include <vector>
+#include <XSCRT/XMLSchema.hpp>
+#include <XSCRT/Parser.hpp>
+
+#include "pcd.hpp"
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+    class TopLevelPackageDescription : public ::XSCRT::Type
+    {
+      //@@ VC6 anathema
+      typedef ::XSCRT::Type Base__;
+
+      // package
+      // 
+      public:
+      typedef ::std::vector< ::CIAO::Config_Handlers::PackageConfiguration >::iterator package_iterator;
+      typedef ::std::vector< ::CIAO::Config_Handlers::PackageConfiguration >::const_iterator package_const_iterator;
+      package_iterator begin_package ();
+      package_iterator end_package ();
+      package_const_iterator begin_package () const;
+      package_const_iterator end_package () const;
+      void add_package (::CIAO::Config_Handlers::PackageConfiguration const& );
+
+      protected:
+      ::std::vector< ::CIAO::Config_Handlers::PackageConfiguration > package_;
+
+      public:
+      TopLevelPackageDescription ();
+      TopLevelPackageDescription (::XSCRT::XML::Element< char > const&);
+      TopLevelPackageDescription (TopLevelPackageDescription const& s);
+
+      TopLevelPackageDescription&
+      operator= (TopLevelPackageDescription const& s);
+
+      private:
+      char regulator__;
+    };
+  }
+}
+
+namespace CIAO
+{
+  namespace Config_Handlers
+  {
+  }
+}
+
+#endif // TOPLEVEL_HPP