Thu Jul 1 15:54:15 2004 Jaiganesh B <jai@dre.vanderbilt.edu>

43 files changed, 4998 insertions, 0 deletions

diff --git a/TAO/CIAO/ChangeLog b/TAO/CIAO/ChangeLog
index 5f1f76e12e0..ffcb2d4a6f1 100644
--- a/TAO/CIAO/ChangeLog
+++ b/TAO/CIAO/ChangeLog
@@ -1,3 +1,52 @@
+Thu Jul  1 15:54:15 2004  Jaiganesh B  <jai@dre.vanderbilt.edu>
+
+        * DAnCE/Config_Handlers/Domain_Handler.cpp:
+        * DAnCE/Config_Handlers/Domain_Handler.h:
+        * DAnCE/Config_Handlers/ERE_Handler.cpp:
+        * DAnCE/Config_Handlers/ERE_Handler.h:
+        * DDAnCE/Config_Handlers/IAD_Handler.h
+        * DAnCE/Config_Handlers/IAD_Handler.cpp:
+        * DAnCE/Config_Handlers/ID_Handler.cpp:
+        * DAnCE/Config_Handlers/ID_Handler.h:
+        * DAnCE/Config_Handlers/IR_Handler.cpp:
+        * DAnCE/Config_Handlers/IR_Handler.h:
+        * DAnCE/Config_Handlers/MID_Handler.cpp:
+        * DAnCE/Config_Handlers/MID_Handler.h:
+        * DAnCE/Config_Handlers/NIA_Handler.cpp:
+        * DAnCE/Config_Handlers/NIA_Handler.h:
+        * DAnCE/Config_Handlers/PCI_Handler.cpp:
+        * DAnCE/Config_Handlers/PCI_Handler.h:
+        * DAnCE/Config_Handlers/PC_Handler.cpp:
+        * DAnCE/Config_Handlers/PC_Handler.h:
+        * DAnCE/Config_Handlers/Plan_Handler.cpp:
+        * DAnCE/Config_Handlers/Plan_Handler.h:
+        * DAnCE/Config_Handlers/Process_Element.cpp:
+        * DAnCE/Config_Handlers/Process_Element.h:
+        * DAnCE/Config_Handlers/Process_Element_T.cpp:
+        * DAnCE/Config_Handlers/Process_Element_T.h:
+        * DAnCE/Config_Handlers/Property_Handler.cpp:
+        * DAnCE/Config_Handlers/Property_Handler.h:
+        * DAnCE/Config_Handlers/RS_Handler.cpp:
+        * DAnCE/Config_Handlers/RS_Handler.h:
+        * DAnCE/Config_Handlers/RUK_Handler.cpp:
+        * DAnCE/Config_Handlers/RUK_Handler.h:
+        * DAnCE/Config_Handlers/Requirement_Handler.cpp:
+        * DAnCE/Config_Handlers/Requirement_Handler.h:
+        * DAnCE/Config_Handlers/SPK_Handler.cpp:
+        * DAnCE/Config_Handlers/SPK_Handler.h:
+        * DAnCE/Config_Handlers/SP_Handler.cpp:
+        * DAnCE/Config_Handlers/SP_Handler.h:
+        * DAnCE/Config_Handlers/TPD_Handler.cpp:
+        * DAnCE/Config_Handlers/TPD_Handler.h:
+        * DAnCE/Config_Handlers/Utils.cpp:
+        * DAnCE/Config_Handlers/Utils.h:
+        * DAnCE/Config_Handlers/XercesString.cpp:
+        * DAnCE/Config_Handlers/XercesString.h:
+
+          First cut check-in for XML handlers.
+
+
+
 Thu Jul  1 15:51:14 2004  Jaiganesh B  <jai@dre.vanderbilt.edu>
 
         * DAnCE/DomainApplicationManager/Deployment_Configuration.cpp:
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.cpp
new file mode 100644
index 00000000000..5d6d1456e07
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.cpp
@@ -0,0 +1,403 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "Domain_Handler.h"
+#include "Property_Handler.h"
+#include "SP_Handler.h"
+#include "Process_Element.h"
+#include "Utils.h"
+#include <iostream>
+#include "string.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the Domain type and populate the IDL structure
+void Domain_Handler::process_domain (Deployment::Domain& domain)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName ());
+
+      if (node_name == XStr (ACE_TEXT ("Deployment:Domain")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string
+             (this->iter_, node_name, "UUID", domain.UUID));
+      else if
+        (CIAO::Config_Handler::Utils::process_string
+             (this->iter_, node_name, "label", domain.label));
+      else if
+        (process_sequence_local<Deployment::SharedResource>
+           (this->doc_, this->iter_, node,
+            node_name, "sharedResource", domain.sharedResource,
+            this, &Domain_Handler::process_sr));
+      else if
+        (process_sequence_local<Deployment::Node>
+           (this->doc_, this->iter_, node,
+            node_name, "node", domain.node,
+            this, &Domain_Handler::process_node));
+      else if
+        (process_sequence_local<Deployment::Interconnect>
+           (this->doc_, this->iter_, node,
+            node_name, "interconnect", domain.interconnect,
+            this, &Domain_Handler::process_interconnect));
+      else if
+        (process_sequence_local<Deployment::Bridge>
+           (this->doc_, this->iter_, node,
+            node_name, "bridge", domain.bridge,
+            this, &Domain_Handler::process_bridge));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "infoProperty", domain.infoProperty,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else
+        {
+          // ??? How did we get here ???
+          ACE_THROW (CORBA::INTERNAL());
+        }
+    }
+
+  this->update_node_refs (domain);
+  this->update_ic_refs (domain);
+  this->update_bridge_refs (domain);
+  this->update_sr_refs (domain);
+
+  return;
+}
+
+void Domain_Handler::process_node (DOMNodeIterator* iter,
+                                   Deployment::Node& domain_node)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr
+               (ACE_TEXT ("Deployment:Node")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string
+               (iter, node_name, "name", domain_node.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string
+               (iter, node_name, "label", domain_node.label));
+      else if
+        (process_sequence_local<Deployment::Resource>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "resource", domain_node.resource,
+            this, &Domain_Handler::process_resource));
+      else if
+        (process_reference_seq (node, node_name, "connection",
+                                domain_node.connectionRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_reference_seq (node, node_name, "sharedResource",
+                                domain_node.sharedResourceRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Domain_Handler::process_resource (DOMNodeIterator* iter,
+                                       Deployment::Resource& domain_resource)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr
+               (ACE_TEXT ("Deployment:Resource")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string
+             (iter, node_name, "name", domain_resource.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq
+           (iter, node_name, "resourceType", domain_resource.resourceType));
+      else if
+        (process_sequence_common<Deployment::SatisfierProperty>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "property", domain_resource.property,
+            &SP_Handler::process_SatisfierProperty,
+            this->id_map_));
+      else
+        {
+          node = iter->previousNode ();
+          break;
+        }
+    }
+}
+
+void Domain_Handler::process_bridge (DOMNodeIterator* iter,
+                                     Deployment::Bridge& domain_bridge)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+          
+      if (node_name == XStr
+               (ACE_TEXT ("Deployment:Bridge")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "name", domain_bridge.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "label", domain_bridge.label));
+      else if
+        (process_reference_seq (node, node_name, "connect",
+                                domain_bridge.connectRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_sequence_local<Deployment::Resource>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "resource", domain_bridge.resource,
+            this, &Domain_Handler::process_resource));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+
+void Domain_Handler::process_interconnect (DOMNodeIterator* iter,
+                                           Deployment::Interconnect& domain_ic)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr
+               (ACE_TEXT ("Deployment:Interconnect")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "name", domain_ic.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "label", domain_ic.label));
+      else if
+        (process_reference_seq (node, node_name, "connect",
+                                domain_ic.connectRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_reference_seq (node, node_name, "connection",
+                                domain_ic.connectionRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_sequence_local<Deployment::Resource>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "resource", domain_ic.resource,
+            this, &Domain_Handler::process_resource));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+
+void Domain_Handler::process_sr (DOMNodeIterator* iter,
+                                 Deployment::SharedResource& domain_sr)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+          
+      if (node_name == XStr
+               (ACE_TEXT ("Deployment:SharedResource")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "name", domain_sr.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+              (iter, node_name, "resourceType", 
+               domain_sr.resourceType));
+      else if
+        (process_reference_seq (node, node_name, "node",
+                                domain_sr.nodeRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_sequence_common<Deployment::SatisfierProperty>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "property", domain_sr.property,
+            &SP_Handler::process_SatisfierProperty,
+            this->id_map_));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Domain_Handler::update_node_refs (Deployment::Domain& domain)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < domain.node.length (); ++x)
+    {
+      for (y = 0; y < domain.node[x].connectionRef.length (); ++y)
+        {
+          ref_value =  domain.node[x].connectionRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.node[x].connectionRef[y] = orig_value;
+                }
+            }
+        }
+
+      for (y = 0; y < domain.node[x].sharedResourceRef.length (); ++y)
+        {
+          ref_value = domain.node[x].sharedResourceRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.node[x].sharedResourceRef[y] = orig_value;
+                }
+            }
+        }
+
+    }
+}
+
+void Domain_Handler::update_ic_refs (Deployment::Domain& domain)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < domain.interconnect.length (); ++x)
+    {
+      for (y = 0; y < domain.interconnect[x].connectionRef.length (); ++y)
+        {
+          ref_value = domain.interconnect[x].connectionRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.interconnect[x].connectionRef[y] = orig_value;
+                }
+            }
+        }
+
+      for (y = 0; y < domain.interconnect[x].connectRef.length (); ++y)
+        {
+          ref_value = domain.interconnect[x].connectRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.interconnect[x].connectRef[y] = orig_value;
+                }
+            }
+        }
+    }
+}
+
+void Domain_Handler::update_bridge_refs (Deployment::Domain& domain)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < domain.bridge.length (); ++x)
+    {
+      for (y = 0; y < domain.bridge[x].connectRef.length (); ++y)
+        {
+          ref_value = domain.bridge[x].connectRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.bridge[x].connectRef[y] = orig_value;
+                }
+            }
+        }
+    }
+}
+
+void Domain_Handler::update_sr_refs (Deployment::Domain& domain)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < domain.sharedResource.length (); ++x)
+    {
+      for (y = 0; y < domain.sharedResource[x].nodeRef.length (); ++y)
+        {
+          ref_value = domain.sharedResource[x].nodeRef[y];
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  domain.sharedResource[x].nodeRef[y] = orig_value;
+                }
+            }
+        }
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.h
new file mode 100644
index 00000000000..a29e7cf7fd1
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Domain_Handler.h
@@ -0,0 +1,127 @@
+//==================================================================
+/**
+ *  @file  Domain_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ */
+//=====================================================================
+#ifndef DOMAIN_HANDLER_H
+#define DOMAIN_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "Basic_Handler.h"
+#include "XercesString.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_main.h"
+#include "tao/Exception.h"
+#include "XercesString.h"
+#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMInputSource;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMNamedNodeMap;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class Domain_Handler
+ *
+ * @brief Handler class for <Domain> type
+ *
+ * This class is within the Target Data Model subpackage of the
+ * Deployment & Configuration package.
+ *
+ * This class defines handler methods to parse the aforementioned type
+ * in the description files. The corresponding CORBA IDL type for this
+ * element is returned.
+ */
+
+class Config_Handler_Export Domain_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  Domain_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  Domain_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  Domain_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the Domain type
+  void process_domain (Deployment::Domain& domain);
+
+  /// process the node attribute
+  void process_node (DOMNodeIterator* iter,
+                     Deployment::Node& domain_node);
+
+  /// process the node attribute
+  void process_bridge (DOMNodeIterator* iter,
+                       Deployment::Bridge& domain_bridge);
+
+  /// process the node attribute
+  void process_interconnect (DOMNodeIterator* iter,
+                             Deployment::Interconnect& domain_ic);
+
+  /// process the resource attribute
+  void process_resource (DOMNodeIterator* iter,
+                         Deployment::Resource& domain_resource);
+
+  /// process the node attribute
+  void process_sr (DOMNodeIterator* iter,
+                   Deployment::SharedResource& domain_sr);
+
+  /// update node refs
+  void update_node_refs (Deployment::Domain& domain);
+
+  /// update ic refs
+  void update_ic_refs (Deployment::Domain& domain);
+
+  /// update bridge refs
+  void update_bridge_refs (Deployment::Domain& domain);
+
+  /// update sr refs
+  void update_sr_refs (Deployment::Domain& domain);
+
+  /// process IDREFs
+  void process_refs (DOMNamedNodeMap* named_node_map);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* DOMAIN_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.cpp
new file mode 100644
index 00000000000..9251ab3adb5
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.cpp
@@ -0,0 +1,27 @@
+//$Id$
+
+#include "ERE_Handler.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Utils;
+
+void
+CIAO::Config_Handler::ERE_Handler::
+process_ExternalReferenceEndpoint (DOMNodeIterator * iter,
+                                   Deployment::ExternalReferenceEndpoint &ret_struct)
+{
+  //Check if the Schema IDs for both the elements match
+  DOMNode * node = iter->nextNode ();
+  XStr name (node->getNodeName ());
+
+  if (name != XStr (ACE_TEXT ("location")))
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "Config_Handlers::ERE_Handler::process_ExternalRefEndPoint \
+                   element mismatch expected <location>"));
+      ACE_THROW (CORBA::INTERNAL ());
+    }
+
+  // Populate the structure
+  ret_struct.location = Utils::parse_string (iter);
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.h
new file mode 100644
index 00000000000..3fdafe87009
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ERE_Handler.h
@@ -0,0 +1,63 @@
+
+//==================================================================
+/**
+ *  @file  ERE_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef ERE_HANDLER_H
+#define ERE_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class ERE_Handler
+     *
+     * @brief Handler class for <ExternalReferenceEndpoint> tag
+     *
+     * This class defines handler methods to parse the aforementioned type
+     * in the descriptor files. The corresponding CORBA IDL type for this
+     * element is returned.
+     */
+
+    class Config_Handler_Export ERE_Handler
+    {
+    public:
+      static void  
+        process_ExternalReferenceEndpoint (DOMNodeIterator * iter,
+                                           Deployment::ExternalReferenceEndpoint &ret_struct);
+      // process <ExternalReferenceEndpoint> definitions in the descriptor
+      // files
+
+    };
+  }
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* ERE_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.cpp
new file mode 100644
index 00000000000..9e4ff47cf28
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.cpp
@@ -0,0 +1,73 @@
+//$Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "Property_Handler.h"
+#include "Requirement_Handler.h"
+#include "NIA_Handler.h"
+#include "IAD_Handler.h"
+#include "Utils.h"
+#include "Process_Element.h"
+#include <iostream>
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+void IAD_Handler::process_ImplementationArtifactDescription
+(::Deployment::ImplementationArtifactDescription &iad)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+             (ACE_TEXT ("Deployment:ImplementationArtifactDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "label", iad.label));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "UUID", iad.UUID));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+              (this->iter_, node_name, "location", 
+               iad.location));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "execParameter", iad.execParameter,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else if
+        (process_sequence_common<Deployment::Requirement>
+           (node->getOwnerDocument(), this->iter_, node,
+            node_name, "deployRequirement", iad.deployRequirement,
+            &Requirement_Handler::process_Requirement,
+            this->id_map_));
+      else if
+        (process_sequence_remote<Deployment::NamedImplementationArtifact, 
+                                 NIA_Handler>
+           (this->doc_, this->iter_, node,
+            node_name, "dependsOn", iad.dependsOn,
+            &NIA_Handler::process_NamedImplementationArtifact, this->id_map_));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "infoProperty", iad.infoProperty,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else
+        {
+          this->iter_->previousNode ();
+          return;
+        }
+    }
+  return;
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.h
new file mode 100644
index 00000000000..a46de1d885f
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/IAD_Handler.h
@@ -0,0 +1,99 @@
+//==================================================================
+/**
+ *  @file  IAD_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef IAD_HANDLER_H
+#define IAD_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "ace/SString.h"
+#include "ace/Hash_Map_Manager.h"
+#include "ace/Null_Mutex.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_main.h"
+#include "tao/Exception.h"
+#include "XercesString.h"
+#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMInputSource;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMNamedNodeMap;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class IAD_Handler
+ *
+ * @brief Handler class for <ImplementationArtifactDescription> tag
+ *
+ * This class defines handler methods to parse the
+ * ImplementationArtifactDescription type
+ * in the descriptor files. The corresponding CORBA IDL type for this
+ * element is returned.
+ */
+
+class Config_Handler_Export IAD_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  IAD_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  IAD_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  IAD_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the component package description
+  void process_ImplementationArtifactDescription
+    (::Deployment::ImplementationArtifactDescription &iad);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* IAD_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.cpp
new file mode 100644
index 00000000000..71f700f596e
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.cpp
@@ -0,0 +1,28 @@
+//$Id$
+
+#include "ID_Handler.h"
+#include "tao/Exception.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Utils;
+
+void
+CIAO::Config_Handler::ID_Handler::
+process_ImplementationDependency (DOMNodeIterator * iter,
+                                  Deployment::ImplementationDependency &ret_struct)
+{
+  //Check if the Schema IDs for both the elements match
+  DOMNode * node = iter->nextNode ();
+  XStr name (node->getNodeName ());
+
+  if (name != XStr (ACE_TEXT ("elementType")))
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "Config_Handlers::ID_Handler::process_ImplDependency \
+                   element mismatch expected <elementType>"));
+      ACE_THROW (CORBA::INTERNAL ());
+    }
+
+  // Populate the structure
+  ret_struct.requiredType = Utils::parse_string (iter);
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.h
new file mode 100644
index 00000000000..ef7f9c5c86d
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ID_Handler.h
@@ -0,0 +1,64 @@
+//==================================================================
+/**
+ *  @file  ID_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef ID_HANDLER_H
+#define ID_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class ID_Handler
+     *
+     * @brief Handler class for <ImplementationDependency> type
+     *
+     * This class defines handler methods to parse Implementation
+     * Dependency types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     * KNOWN ISSUE:
+     * The IDL mapping for this type defines a struct containing a
+     * string type. However, the schema defines an unbounded string.
+     * Currently, this Handler handles what the IDL requires as this is
+     * valid via the schema definition also.
+     *
+     */
+    class Config_Handler_Export ID_Handler
+    {
+    public:
+      static void
+        process_ImplementationDependency (DOMNodeIterator * iter,
+                                          Deployment::ImplementationDependency &ret_struct);
+      // process elements of type Implementation Dependency definitions in
+      // the descriptor files
+
+    };
+  }
+
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* ID_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.cpp
new file mode 100644
index 00000000000..d4255b5555e
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.cpp
@@ -0,0 +1,58 @@
+//$Id$
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "IAD_Handler.h"
+#include "IR_Handler.h"
+#include "RUK_Handler.h"
+#include "Utils.h"
+#include "Utils.h"
+#include "Process_Element.h"
+#include "Property_Handler.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+void IR_Handler::process_ImplementationRequirement
+(::Deployment::ImplementationRequirement &ir)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+        (ACE_TEXT ("Deployment:ImplementationRequirement")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (this->iter_, node_name, "resourcePort", 
+              ir.resourcePort));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "componentPort", 
+               ir.componentPort));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "resourceType", 
+               ir.resourceType));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "name", ir.name));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "Property", ir.property,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else
+        {
+          this->iter_->previousNode ();
+          return;
+        }
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.h
new file mode 100644
index 00000000000..9e159ed2636
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/IR_Handler.h
@@ -0,0 +1,106 @@
+//==================================================================
+/**
+ *  @file  IR_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef IR_HANDLER_H
+#define IR_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+#include "RUK_Handler.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class IR_Handler
+ *
+ * @brief Handler class for <ImplementationRequirement> type
+ *
+ * This class defines handler methods to parse Implementation
+ * Requirement types in the descriptor files. The corresponding
+ * CORBA IDL type for the schema element is returned.
+ *
+ */
+
+class Config_Handler_Export IR_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  IR_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  IR_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  IR_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the package configuration
+  void process_ImplementationRequirement (::Deployment::ImplementationRequirement &ir);
+
+protected:
+  /// Process the resourceUsage attribute
+  void process_resourceUsage (const XMLCh* name, ::Deployment::ImplementationRequirement &ir);
+
+  /// Process the resourcePort attribute
+  void process_resourcePort (const XMLCh* name, ::Deployment::ImplementationRequirement &ir);
+
+  /// Process the componentPort attribute
+  void process_componentPort (const XMLCh* name, ::Deployment::ImplementationRequirement &ir);
+
+  /*
+   * Derived from Requirement
+   */
+
+  /// Process the label attribute
+  void process_name (const XMLCh* name, ::Deployment::ImplementationRequirement &ir);
+
+  /// Process the label attribute
+  void process_resourceType (const XMLCh* name, ::Deployment::ImplementationRequirement &ir);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* IR_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.cpp
new file mode 100644
index 00000000000..bce6afd2e7a
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.cpp
@@ -0,0 +1,54 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "Property_Handler.h"
+#include "Requirement_Handler.h"
+#include "NIA_Handler.h"
+#include "MID_Handler.h"
+#include "IR_Handler.h"
+#include "Process_Element.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+void MID_Handler::process_MonolithicImplementationDescription
+              (::Deployment::MonolithicImplementationDescription &mid)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+      if (node_name == XStr 
+               (ACE_TEXT ("Deployment:MonolithicImplementationDescription")))
+        {
+        }
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "execParameter", mid.execParameter,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else if
+        (process_sequence_remote<Deployment::NamedImplementationArtifact, 
+                                 NIA_Handler>
+           (this->doc_, this->iter_, node,
+            node_name, "primaryArtifact", mid.primaryArtifact,
+            &NIA_Handler::process_NamedImplementationArtifact, 
+            this->id_map_));
+      else if
+        (process_sequence_remote<Deployment::ImplementationRequirement, 
+                                 IR_Handler>
+           (this->doc_, this->iter_, node,
+            node_name, "deployRequirement", mid.deployRequirement,
+            &IR_Handler::process_ImplementationRequirement, this->id_map_));
+      else
+        {
+          this->iter_->previousNode ();
+          return;
+        }
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.h
new file mode 100644
index 00000000000..17c3a2c4a3d
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/MID_Handler.h
@@ -0,0 +1,116 @@
+// $Id$
+
+#ifndef MID_HANDLER_H
+#define MID_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "ace/SString.h"
+#include "ace/Hash_Map_Manager.h"
+#include "ace/Null_Mutex.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_main.h"
+#include "tao/Exception.h"
+#include "XercesString.h"
+#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMInputSource;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMNamedNodeMap;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class MID_Handler
+ *
+ * @brief Handler class for <MonolithicImplementationDescription> type
+ *
+ * This class defines handler methods to parse Monolithic Implementation
+ * Descroption types in the descriptor files. The corresponding
+ * CORBA IDL type for the schema element is returned.
+ *
+ */
+
+class Config_Handler_Export MID_Handler: public Basic_Handler
+{
+public:
+
+  MID_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  MID_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  MID_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  void process_MonolithicImplementationDescription (::Deployment::MonolithicImplementationDescription &mid);
+
+protected:
+  /// process exec parameter element
+  void process_exec_parameter_element (DOMNode* node,
+                                       DOMDocument* doc, DOMNodeIterator* iter,
+                                       Deployment::MonolithicImplementationDescription& mid);
+
+  /// process attributes for property element
+  void process_attributes_for_property (DOMNamedNodeMap* named_node_map,
+                                        DOMDocument* doc,
+                                        DOMNodeIterator* iter,
+                                        int value,
+                                        Deployment::Property& ccd_property);
+
+  /// process attributes for deploy requirement
+  void process_attributes_for_deploy_requirement (DOMNamedNodeMap* nm,
+                                                  DOMDocument* doc,
+                                                  DOMNodeIterator* iter,
+                                                  int value,
+                                                  Deployment::ImplementationRequirement& req);
+
+  /// process attributes for NIA
+  void process_attributes_for_nia (DOMNamedNodeMap* nm,
+                                   DOMDocument* doc,
+                                   DOMNodeIterator* iter,
+                                   int value,
+                                   Deployment::NamedImplementationArtifact& nia);
+
+  /// process IDREFS
+  void process_refs (DOMNamedNodeMap* named_node_map);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* MID_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.cpp
new file mode 100644
index 00000000000..11db8839207
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.cpp
@@ -0,0 +1,44 @@
+//$Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "IAD_Handler.h"
+#include "NIA_Handler.h"
+#include "Utils.h"
+#include "Process_Element.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+void NIA_Handler::process_NamedImplementationArtifact
+(::Deployment::NamedImplementationArtifact &nia)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+      if (node_name == XStr 
+               (ACE_TEXT ("Deployment:NamedImplementationArtifact")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+               (this->iter_, node_name, "name", nia.name));
+      else if
+        (process_element_remote<Deployment::ImplementationArtifactDescription,
+                                IAD_Handler>
+           (this->doc_, this->iter_, node,
+            node_name, "referencedArtifact", nia.referencedArtifact,
+            &IAD_Handler::process_ImplementationArtifactDescription, 
+            this->id_map_));
+      else
+       {
+         this->iter_->previousNode ();
+         return;
+       }
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.h
new file mode 100644
index 00000000000..38ad44beed2
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/NIA_Handler.h
@@ -0,0 +1,84 @@
+//==================================================================
+/**
+ *  @file  NIA_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef NIA_HANDLER_H
+#define NIA_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class NIA_Handler
+ *
+ * @brief Handler class for <NamedImplementationArtifact> type
+ *
+ * This class defines handler methods to parse Named Implementation
+ * Artifact types in the descriptor files. The corresponding
+ * CORBA IDL type for the schema element is returned.
+ *
+ */
+
+class Config_Handler_Export NIA_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  NIA_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  NIA_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  NIA_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the package configuration
+  void process_NamedImplementationArtifact (::Deployment::NamedImplementationArtifact &nia);
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* NIA_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.cpp
new file mode 100644
index 00000000000..e26a73dab27
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.cpp
@@ -0,0 +1,47 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "CompImplDesc_Handler.h"
+#include "PCI_Handler.h"
+#include "Utils.h"
+#include "Process_Element.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+void PCI_Handler::process_PackagedComponentImplementation
+                      (::Deployment::PackagedComponentImplementation &pci)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+            (ACE_TEXT ("Deployment:PackagedComponentImplementation")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (this->iter_, node_name, "name", pci.name));
+      else if
+        (process_element_remote<Deployment::ComponentImplementationDescription,
+                                CompImplDesc_Handler>
+           (this->doc_, this->iter_, node,
+            node_name, "referencedImplementation", 
+            pci.referencedImplementation,
+            &CompImplDesc_Handler::process_ComponentImplementationDescription, 
+            this->id_map_));
+      else
+        {
+          this->iter_->previousNode ();
+          return;
+        }
+    }
+  return;
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.h
new file mode 100644
index 00000000000..841db0fc0a6
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/PCI_Handler.h
@@ -0,0 +1,87 @@
+//==================================================================
+/**
+ *  @file  PCI_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author George Edwards <g.edwards@vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef PCI_HANDLER_H
+#define PCI_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+#include "Basic_Handler.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class PCI_Handler
+ *
+ * @brief Handler class for <PackagedComponentImplementation> type 
+ *
+ * This class is within the Component Data Model subpackage of the
+ * Deployment & Configuration package.
+ *
+ * This class defines handler methods to parse the aforementioned type
+ * in the description files. The corresponding CORBA IDL type for this
+ * element is returned.
+ */
+
+class Config_Handler_Export PCI_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  PCI_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  PCI_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  PCI_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the package configuration
+  void process_PackagedComponentImplementation (::Deployment::PackagedComponentImplementation &pci);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* PCI_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.cpp
new file mode 100644
index 00000000000..25804bd71c3
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.cpp
@@ -0,0 +1,75 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "Property_Handler.h"
+#include "Requirement_Handler.h"
+#include "CPR_Handler.h"
+#include "CompPkgDesc_Handler.h"
+#include "PC_Handler.h"
+#include "Process_Element.h"
+#include "Utils.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+void PC_Handler::process_PackageConfiguration
+                    (::Deployment::PackageConfiguration &pc)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName());
+      if (node_name == XStr 
+                    (ACE_TEXT ("Deployment:PackageConfiguration")))
+        {
+        }
+      else if (CIAO::Config_Handler::Utils::process_string 
+                  (this->iter_, node_name, "label", pc.label))
+        {
+        }
+      else if (CIAO::Config_Handler::Utils::process_string 
+                  (this->iter_, node_name, "UUID", pc.UUID))
+        {
+        }
+      else if (process_sequence_remote
+                 <Deployment::ComponentPackageDescription,
+                  CompPkgDesc_Handler>
+                     (this->doc_, this->iter_, node,
+                      node_name, "basePackage", pc.basePackage,
+                     &CompPkgDesc_Handler::process_ComponentPackageDescription,
+                      this->id_map_))
+        {
+        }
+      else if (process_sequence_remote
+                <Deployment::ComponentPackageReference, CPR_Handler>
+                   (this->doc_, this->iter_, node,
+                    node_name, "reference", pc.reference,
+                    &CPR_Handler::process_ComponentPackageReference,
+                    this->id_map_))
+        {
+        }
+      else if (process_sequence_common
+             <Deployment::Requirement>
+                (this->doc_, this->iter_, node,
+                 node_name, "selectRequirement", pc.selectRequirement,
+                 &Requirement_Handler::process_Requirement,this->id_map_))
+        {
+        }
+      else if (process_sequence_common<Deployment::Property>
+            (this->doc_, this->iter_, node,
+             node_name, "configProperty", pc.configProperty,
+             &Property_Handler::process_Property, this->id_map_))
+        {
+        }
+      else
+        {
+          ACE_THROW (CORBA::INTERNAL());
+        }
+    }
+    return;
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.h
new file mode 100644
index 00000000000..224f298f0a4
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/PC_Handler.h
@@ -0,0 +1,91 @@
+//==================================================================
+/**
+ *  @file  PC_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author George Edwards <g.edwards@vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef PC_HANDLER_H
+#define PC_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class PC_Handler
+ *
+ * @brief Handler class for <PackageConfiguration> type 
+ *
+ * This class is within the Component Data Model subpackage of the
+ * Deployment & Configuration package.
+ *
+ * This class defines handler methods to parse the aforementioned type
+ * in the description files. The corresponding CORBA IDL type for this
+ * element is returned.
+ */
+
+class Config_Handler_Export PC_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  PC_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  PC_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  PC_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the package configuration
+  void process_PackageConfiguration (::Deployment::PackageConfiguration &pc);
+
+  /// Process the specializedConfig attribute
+  void process_specializedConfig
+  (const XMLCh* specializedConfig, ::Deployment::PackageConfiguration &pc);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* PC_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.cpp
new file mode 100644
index 00000000000..bf4b22c2c3f
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.cpp
@@ -0,0 +1,624 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "Plan_Handler.h"
+#include "ID_Handler.h"
+#include "CompIntrDesc_Handler.h"
+#include "Property_Handler.h"
+#include "SP_Handler.h"
+#include "Requirement_Handler.h"
+#include "Any_Handler.h"
+#include "RUK_Handler.h"
+#include "CEPE_Handler.h"
+#include "ERE_Handler.h"
+#include "CPK_Handler.h"
+#include "Process_Element.h"
+#include "Utils.h"
+#include <iostream>
+#include "string.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the DeploymentPlan type and populate the IDL structure
+void Plan_Handler::process_plan(Deployment::DeploymentPlan& plan)
+{
+  for (DOMNode* node = this->iter_->nextNode();
+       node != 0;
+       node = this->iter_->nextNode())
+    {
+      XStr node_name (node->getNodeName ());
+
+
+      if (node_name == XStr
+          (ACE_TEXT ("Deployment:DeploymentPlan")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (this->iter_, node_name, "label", plan.label));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (this->iter_, node_name, "UUID", plan.UUID));
+      else if
+        (process_element<Deployment::ComponentInterfaceDescription>
+           (this->doc_, this->iter_, node,
+            node_name, "realizes", plan.realizes,
+            this, &Plan_Handler::process_ccd,
+            this->id_map_));
+      else if
+        (process_sequence_local<Deployment::MonolithicDeploymentDescription>
+           (this->doc_, this->iter_, node,
+            node_name, "implementation", plan.implementation,
+            this, &Plan_Handler::process_mdd));
+      else if
+        (process_sequence_local<Deployment::InstanceDeploymentDescription>
+           (this->doc_, this->iter_, node,
+            node_name, "instance", plan.instance,
+            this, &Plan_Handler::process_idd));
+      else if
+        (process_sequence_local<Deployment::PlanConnectionDescription>
+           (this->doc_, this->iter_, node,
+            node_name, "connection", plan.connection,
+            this, &Plan_Handler::process_pcd));
+      else if
+        (process_sequence_local<Deployment::PlanPropertyMapping>
+           (this->doc_, this->iter_, node,
+            node_name, "externalProperty", plan.externalProperty,
+            this, &Plan_Handler::process_ppm));
+      else if
+        (process_sequence_common<Deployment::ImplementationDependency>
+           (this->doc_, this->iter_, node,
+            node_name, "dependsOn", plan.dependsOn,
+            &ID_Handler::process_ImplementationDependency, this->id_map_));
+      else if
+        (process_sequence_local<Deployment::ArtifactDeploymentDescription>
+           (this->doc_, this->iter_, node,
+            node_name, "artifact", plan.artifact,
+            this, &Plan_Handler::process_add));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (this->doc_, this->iter_, node,
+            node_name, "infoProperty", plan.infoProperty,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else
+        {
+          // ??? How did we get here ???
+          ACE_THROW (CORBA::INTERNAL());
+        }
+    }
+
+  this->update_mdd_refs (plan);
+  this->update_idd_refs (plan);
+  this->update_pspe_refs (plan);
+  this->update_pspr_refs (plan);
+  return;
+}
+
+void Plan_Handler::process_rdd (DOMNodeIterator* iter,
+                                Deployment::
+                                ResourceDeploymentDescription& rdd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+                  (ACE_TEXT ("Deployment:ResourceDeploymentDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "requirementName", 
+               rdd.requirementName));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "resourceName", rdd.resourceName));
+      else if (node_name == XStr (ACE_TEXT ("resourceValue")))
+        {
+          Any_Handler::process_Any (iter, rdd.resourceValue);
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_irdd (DOMNodeIterator* iter,
+                                 Deployment::
+                                 InstanceResourceDeploymentDescription &irdd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+                (ACE_TEXT ("Deployment:InstanceResourceDeploymentDescription")))
+        {
+        }
+      else if (node_name == "resourceUsage")
+        {
+          RUK_Handler::process_ResourceUsageKind (iter, irdd.resourceUsage);
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+            (iter, node_name, "requirementName", 
+             irdd.requirementName));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "resourceName", irdd.resourceName));
+      else if (node_name == XStr (ACE_TEXT ("resourceValue")))
+        {
+          Any_Handler::process_Any (iter, irdd.resourceValue);
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_add (DOMNodeIterator* iter,
+                                Deployment::ArtifactDeploymentDescription& add)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+          (ACE_TEXT ("Deployment:ArtifactDeploymentDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+               (iter, node_name, "name", add.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+               (iter, node_name, "location", add.location));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+               (iter, node_name, "node", add.node));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+               (iter, node_name, "source", add.source));
+      else if
+        (process_sequence_common<Deployment::Property>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "execParameter", add.execParameter,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else if
+        (process_sequence_common<Deployment::Requirement>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "deployRequirement", add.deployRequirement,
+            &Requirement_Handler::process_Requirement,
+            this->id_map_));
+      else if
+        (process_sequence_local<Deployment::ResourceDeploymentDescription>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "deployedResource", add.deployedResource,
+            this, &Plan_Handler::process_rdd));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_idd (DOMNodeIterator* iter,
+                                Deployment::InstanceDeploymentDescription& idd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+                    (ACE_TEXT ("Deployment:InstanceDeploymentDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "name", idd.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "node", idd.node));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+              (iter, node_name, "source", idd.source));
+      else if
+        (process_reference (node, node_name, "implementation",
+                            idd.implementationRef, 
+                            this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_sequence_common<Deployment::Property>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "configProperty", idd.configProperty,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else if
+        (process_sequence_local<Deployment::
+                                InstanceResourceDeploymentDescription>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "deployedResource", idd.deployedResource,
+            this, &Plan_Handler::process_irdd));
+      else if
+        (process_sequence_local<Deployment::
+                                InstanceResourceDeploymentDescription>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "deployedSharedResource", idd.deployedSharedResource,
+            this, &Plan_Handler::process_irdd));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_mdd (DOMNodeIterator* iter,
+                                Deployment::MonolithicDeploymentDescription&
+                                mdd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+                 (ACE_TEXT ("Deployment:MonolithicDeploymentDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "name", mdd.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+             (iter, node_name, "source", mdd.source));
+      else if
+        (process_reference_seq (node, node_name, "artifact",
+                                mdd.artifactRef,
+                                this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else if
+        (process_sequence_common<Deployment::Property>
+           (node->getOwnerDocument(), this->iter_, node,
+            node_name, "execParameter", mdd.execParameter,
+            &Property_Handler::process_Property,
+            this->id_map_));
+      else if
+        (process_sequence_common<Deployment::Requirement>
+           (node->getOwnerDocument(), this->iter_, node,
+            node_name, "deployRequirement", mdd.deployRequirement,
+            &Requirement_Handler::process_Requirement,
+            this->id_map_));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_ccd (DOMNodeIterator* iter,
+                                Deployment::ComponentInterfaceDescription&
+                                cid)
+{
+  CompIntrDesc_Handler handler (iter, false);
+  handler.process_ComponentInterfaceDescription (cid);
+}
+
+void Plan_Handler::process_pspr (DOMNodeIterator* iter,
+                                 Deployment::PlanSubcomponentPropertyReference&                                  pspr)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+             (ACE_TEXT ("Deployment:PlanSubcomponentPropertyReference")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "propertyName", pspr.propertyName));
+      else if
+        (process_reference (node, node_name, "instance", pspr.instanceRef, 
+                            this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_pspe (DOMNodeIterator* iter,
+                                 Deployment::PlanSubcomponentPortEndpoint& pspe)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+            (ACE_TEXT ("Deployment:PlanSubcomponentPortEndpoint")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "portName", pspe.portName));
+      else if
+        (CIAO::Config_Handler::Utils::process_boolean 
+              (iter, node_name, "provider", pspe.provider));
+      else if (node_name == XStr (ACE_TEXT ("kind")))
+        {
+          CPK_Handler::process_CCMComponentPortKind (iter, pspe.kind);
+        }
+      else if
+        (process_reference (node, node_name, "instance",
+                            pspe.instanceRef,
+                            this->index_, this->idref_map_))
+        {
+          this->index_ = this->index_ + 1;
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+    
+void Plan_Handler::process_ppm(DOMNodeIterator* iter,
+                               Deployment::PlanPropertyMapping& ppm)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+            (ACE_TEXT ("Deployment:PlanPropertyMapping")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "name", ppm.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+              (iter, node_name, "source", ppm.source));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "externalName", ppm.externalName));
+      else if
+        (process_sequence_local<Deployment::PlanSubcomponentPropertyReference>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "delegatesTo", ppm.delegatesTo,
+            this, &Plan_Handler::process_pspr));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_crdd (DOMNodeIterator* iter,
+                                 Deployment::
+                                 ConnectionResourceDeploymentDescription& crdd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+            (ACE_TEXT ("Deployment:ConnectionResourceDeploymentDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "targetName", crdd.targetName));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+             (iter, node_name, "requirementName", 
+              crdd.requirementName));
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+            (iter, node_name, "resourceName", crdd.resourceName));
+      else if (node_name == XStr (ACE_TEXT ("resourceValue")))
+        {
+          Any_Handler::process_Any (iter, crdd.resourceValue);
+        }
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::process_pcd (DOMNodeIterator* iter,
+                                Deployment::PlanConnectionDescription& pcd)
+{
+  for (DOMNode* node = iter->nextNode();
+       node != 0;
+       node = iter->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+
+      if (node_name == XStr 
+             (ACE_TEXT ("Deployment:PlanConnectionDescription")))
+        {
+        }
+      else if
+        (CIAO::Config_Handler::Utils::process_string 
+              (iter, node_name, "name", pcd.name));
+      else if
+        (CIAO::Config_Handler::Utils::process_string_seq 
+              (iter, node_name, "source", pcd.source));
+      else if
+        (process_sequence_common<Deployment::Requirement>
+           (node->getOwnerDocument(), this->iter_, node,
+            node_name, "deployRequirement", pcd.deployRequirement,
+            &Requirement_Handler::process_Requirement,
+            this->id_map_));
+      else if
+        (process_sequence_common<Deployment::ComponentExternalPortEndpoint>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "externalEndpoint", pcd.externalEndpoint,
+            &CEPE_Handler::process_ComponentExternalPortEndpoint,
+            this->id_map_));
+      else if
+        (process_sequence_local<Deployment::PlanSubcomponentPortEndpoint>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "internalEndpoint", pcd.internalEndpoint,
+            this, &Plan_Handler::process_pspe));
+      else if
+        (process_sequence_common<Deployment::ExternalReferenceEndpoint>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "externalReference", pcd.externalReference,
+            &ERE_Handler::process_ExternalReferenceEndpoint,
+            this->id_map_));
+      else if
+        (process_sequence_local<Deployment::
+                                ConnectionResourceDeploymentDescription>
+           (node->getOwnerDocument(), iter, node,
+            node_name, "deployedResource", pcd.deployedResource,
+            this, &Plan_Handler::process_crdd));
+      else
+        {
+          iter->previousNode();
+          return;
+        }
+    }
+}
+
+void Plan_Handler::update_mdd_refs (Deployment::DeploymentPlan& plan)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < plan.implementation.length (); ++x)
+    {
+      for (y = 0; y < plan.implementation[x].artifactRef.length (); ++y)
+        {
+          ref_value = plan.implementation[x].artifactRef[y];
+          //ACE_DEBUG ((LM_DEBUG, "ref_value in ADD is %d \n", ref_value));
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  plan.implementation[x].artifactRef[y] = orig_value;
+                }
+            }
+        }
+    }
+}
+
+void Plan_Handler::update_idd_refs (Deployment::DeploymentPlan& plan)
+{
+  CORBA::ULong x;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < plan.instance.length (); ++x)
+    {
+      ref_value = plan.instance[x].implementationRef;
+          //ACE_DEBUG ((LM_DEBUG, "ref_value in MDD is %d \n", ref_value));
+      if (idref_map_.find (ref_value, ref_name) == 0)
+        {
+          if (id_map_.find (ref_name, orig_value) == 0)
+            {
+              plan.instance[x].implementationRef = orig_value;
+            }
+        }
+    }
+}
+
+void Plan_Handler::update_pspe_refs (Deployment::DeploymentPlan& plan)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < plan.connection.length (); ++x)
+    {
+      for (y = 0; y < plan.connection[x].internalEndpoint.length (); ++y)
+        {
+          ref_value = plan.connection[x].internalEndpoint[y].
+            instanceRef;
+          //ACE_DEBUG ((LM_DEBUG, "ref_value in IDD is %d \n", ref_value));
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  plan.connection[x].internalEndpoint[y].
+                    instanceRef = orig_value;
+                }
+            }
+        }
+    }
+}
+
+void Plan_Handler::update_pspr_refs (Deployment::DeploymentPlan& plan)
+{
+  CORBA::ULong x;
+  CORBA::ULong y;
+  int ref_value;
+  int orig_value;
+  ACE_TString ref_name;
+
+  for (x = 0; x < plan.externalProperty.length (); ++x)
+    {
+      for (y = 0; y < plan.externalProperty[x].delegatesTo.length (); ++y)
+        {
+          ref_value = plan.externalProperty[x].delegatesTo[y].
+            instanceRef;
+          if (idref_map_.find (ref_value, ref_name) == 0)
+            {
+              if (id_map_.find (ref_name, orig_value) == 0)
+                {
+                  plan.externalProperty[x].delegatesTo[y].
+                    instanceRef = orig_value;
+                }
+            }
+        }
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.h
new file mode 100644
index 00000000000..3983e4f1faf
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Plan_Handler.h
@@ -0,0 +1,251 @@
+//==================================================================
+/**
+ *  @file  Plan_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ */
+//=====================================================================
+#ifndef PLAN_HANDLER_H
+#define PLAN_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Basic_Handler.h"
+#include "Config_Handler_export.h"
+#include "ace/SString.h"
+#include "ace/Hash_Map_Manager.h"
+#include "ace/Null_Mutex.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_main.h"
+#include "tao/Exception.h"
+#include "XercesString.h"
+#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMInputSource;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMNamedNodeMap;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class Plan_Handler
+ *
+ * @brief Handler class for <DeploymentPlan> type
+ *
+ */
+
+class Config_Handler_Export Plan_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  Plan_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  Plan_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  Plan_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the plan type
+  void process_plan (Deployment::DeploymentPlan& plan);
+
+  /// process cid
+  void process_ccd (DOMNodeIterator* iter,
+                    Deployment::ComponentInterfaceDescription& cid);
+
+  /// process pspr
+  void process_pspr (DOMNodeIterator* iter,
+                     Deployment::PlanSubcomponentPropertyReference& pspr);
+
+  /// process pspe
+  void process_pspe (DOMNodeIterator* iter,
+                     Deployment::PlanSubcomponentPortEndpoint& pspe);
+
+  /// process add
+  void process_add (DOMNodeIterator* iter,
+                    Deployment::ArtifactDeploymentDescription& add);
+
+  /// process con
+  void process_pcd (DOMNodeIterator* iter,
+                    Deployment::PlanConnectionDescription& con);
+
+  /// process external property
+  void process_ppm (DOMNodeIterator* iter,
+                    Deployment::PlanPropertyMapping& ppm);
+
+  /// process idd
+  void process_idd (DOMNodeIterator* iter,
+                    Deployment::InstanceDeploymentDescription& idd);
+
+  /// process mdd
+  void process_mdd (DOMNodeIterator* iter,
+                    Deployment::MonolithicDeploymentDescription& mdd);
+
+  /// process rdd
+  void process_rdd (DOMNodeIterator* iter,
+                    Deployment::ResourceDeploymentDescription& rdd);
+
+  /// process crdd
+  void process_crdd (DOMNodeIterator* iter,
+                     Deployment::ConnectionResourceDeploymentDescription& crdd);
+  /// process irdd
+  void process_irdd (DOMNodeIterator* iter,
+                     Deployment::InstanceResourceDeploymentDescription &irdd);
+
+  /// process the add name
+  void process_add_name (const XMLCh* name,
+                         Deployment::ArtifactDeploymentDescription& add);
+
+  /// process the pspr property name
+  void process_pspr_prop_name (const XMLCh* name,
+                               Deployment::PlanSubcomponentPropertyReference& pspr);
+
+  /// process the pspe port name
+  void process_pspe_port_name (const XMLCh* name,
+                               Deployment::PlanSubcomponentPortEndpoint& pspe);
+
+  /// process the pspe provider
+  void process_pspe_provider (const XMLCh* value,
+                              Deployment::PlanSubcomponentPortEndpoint& pspe);
+
+  /// process the idd name
+  void process_idd_name (const XMLCh* name,
+                         Deployment::InstanceDeploymentDescription& idd);
+
+  /// process the ppm  name
+  void process_ppm_name (const XMLCh* name,
+                         Deployment::PlanPropertyMapping& ppm);
+
+  /// process the ppm external name
+  void process_ppm_ext_name (const XMLCh* name,
+                             Deployment::PlanPropertyMapping& ppm);
+
+  /// process the idd node
+  void process_idd_node (const XMLCh* node,
+                         Deployment::InstanceDeploymentDescription& idd);
+
+  /// process the idd source
+  void process_idd_source (const XMLCh* source,
+                           Deployment::InstanceDeploymentDescription& idd);
+
+  /// process the add location
+  void process_add_location (const XMLCh* location,
+                             Deployment::ArtifactDeploymentDescription& add);
+
+  /// process the add source
+  void process_add_source (const XMLCh* source,
+                           Deployment::ArtifactDeploymentDescription& add);
+
+  /// process the add node
+  void process_add_node (const XMLCh* node,
+                         Deployment::ArtifactDeploymentDescription& add);
+
+  /// process the mdd source
+  void process_mdd_source (const XMLCh* source,
+                           Deployment::MonolithicDeploymentDescription& mdd);
+
+  /// process the ppm source
+  void process_ppm_source (const XMLCh* source,
+                           Deployment::PlanPropertyMapping& ppm);
+
+  /// process the pcd source
+  void process_pcd_source (const XMLCh* source,
+                           Deployment::PlanConnectionDescription& pcd);
+
+  /// process the pcd name
+  void process_pcd_name (const XMLCh* name,
+                         Deployment::PlanConnectionDescription& pcd);
+
+  /// process the add node
+  void process_mdd_name (const XMLCh* name,
+                         Deployment::MonolithicDeploymentDescription& mdd);
+
+  /// process the rdd req name
+  void process_rdd_req_name (const XMLCh* name,
+                             Deployment::ResourceDeploymentDescription& rdd);
+
+  /// process the rdd res name
+  void process_rdd_res_name (const XMLCh* name,
+                             Deployment::ResourceDeploymentDescription& rdd);
+
+  /// process the irdd res name
+  void process_irdd_res_name (const XMLCh* name,
+                              Deployment::InstanceResourceDeploymentDescription &irdd);
+
+  /// process the crdd res name
+  void process_crdd_res_name (const XMLCh* name,
+                              Deployment::ConnectionResourceDeploymentDescription& crdd);
+
+  /// process the crdd req name
+  void process_crdd_req_name (const XMLCh* name,
+                              Deployment::ConnectionResourceDeploymentDescription& crdd);
+
+  /// process the crdd target name
+  void process_crdd_target_name (const XMLCh* name,
+                                 Deployment::ConnectionResourceDeploymentDescription& crdd);
+
+  /// process the irdd req name
+  void process_irdd_req_name (const XMLCh* name,
+                              Deployment::InstanceResourceDeploymentDescription &irdd);
+
+  /// process the irdd res usage
+  void process_irdd_res_usage (const XMLCh* name,
+                               Deployment::InstanceResourceDeploymentDescription &irdd);
+
+  /// process references
+  void process_refs (DOMNamedNodeMap* named_node_map);
+
+  /// update mdd refs
+  void update_mdd_refs (Deployment::DeploymentPlan& plan);
+
+  /// update idd refs
+  void update_idd_refs (Deployment::DeploymentPlan& plan);
+
+  /// update pspe refs
+  void update_pspe_refs (Deployment::DeploymentPlan& plan);
+
+  /// update pspr refs
+  void update_pspr_refs (Deployment::DeploymentPlan& plan);
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* PLAN_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.cpp
new file mode 100644
index 00000000000..9bfb99b7cb2
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.cpp
@@ -0,0 +1,121 @@
+//==================================================================
+/**
+ *  @file Process_Element.cpp
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#include "Process_Element.h"
+#include "ace/Auto_Ptr.h"
+#include "Utils.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/*
+ *  Process references
+ */
+
+void
+process_refs(DOMNode*& node,
+             CORBA::ULongSeq& seq,
+             int& index,
+             IDREF_MAP& idref_map)
+{
+  CORBA::ULong i (seq.length ());
+  seq.length (i + 1);
+  seq[i] = index;
+  if (node->hasAttributes())
+    {
+      DOMNamedNodeMap* named_node_map = node->getAttributes ();
+      //auto_ptr<DOMNamedNodeMap> cleanup_nodemap (named_node_map);
+      
+      int length = named_node_map->getLength ();
+      
+      for (int j = 0; j < length; j++)
+        {
+          DOMNode* attribute_node = named_node_map->item (j);
+          XStr strattrnodename (attribute_node->getNodeName ());
+          char* aceattrnodevalue_ch = XMLString::transcode
+            (attribute_node->getNodeValue ());
+          ACE_TString aceattrnodevalue = aceattrnodevalue_ch;
+          XMLString::release (&aceattrnodevalue_ch);
+          if (strattrnodename == XStr (ACE_TEXT ("xmi:idref")))
+            {
+              //index = index + 1;
+              idref_map.bind (index, aceattrnodevalue);
+            }
+        }
+    }
+}
+
+void
+process_ref(DOMNode*& node,
+            CORBA::ULong& ref,
+            int& index,
+            IDREF_MAP& idref_map)
+{
+  ref = index;
+  if (node->hasAttributes ())
+    {
+      DOMNamedNodeMap* named_node_map = node->getAttributes ();
+      //auto_ptr<DOMNamedNodeMap> cleanup_nodemap (named_node_map);
+      
+      int length = named_node_map->getLength ();
+      
+      for (int j = 0; j < length; j++)
+        {
+          DOMNode* attribute_node = named_node_map->item (j);
+          XStr strattrnodename (attribute_node->getNodeName ());
+          char* aceattrnodevalue_ch = XMLString::transcode
+            (attribute_node->getNodeValue ());
+          ACE_TString aceattrnodevalue = aceattrnodevalue_ch;
+          XMLString::release (&aceattrnodevalue_ch);
+          if (strattrnodename == XStr (ACE_TEXT ("xmi:idref")))
+            {
+              //index = index + 1;
+              idref_map.bind (index, aceattrnodevalue);
+            }
+        }
+    }
+}
+
+/*
+ *  Process function for references
+ */
+
+bool
+process_reference_seq (DOMNode* node,
+                      XStr& node_name, const char* name,
+                      CORBA::ULongSeq& seq,
+                      int& index,
+                      IDREF_MAP& idref_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+      process_refs (node, seq, index, idref_map);
+
+  return result;
+}
+
+// Process reference
+bool
+process_reference (DOMNode* node,
+                   XStr& node_name, const char* name,
+                   CORBA::ULong& ref,
+                   int& index,
+                   IDREF_MAP& idref_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+  
+  if (result == true)
+    process_ref (node, ref, index, idref_map);
+
+  return result;
+}
+
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h
new file mode 100644
index 00000000000..c60c1e14b75
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element.h
@@ -0,0 +1,192 @@
+//==================================================================
+/**
+ *  @file Process_Element.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ *          Jaiganesh Balasubramanian  <jai@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef PROCESS_ELEMENT_H
+#define PROCESS_ELEMENT_H
+
+#include "DeploymentC.h"
+#include "Deployment.h"
+#include "Basic_Handler.h"
+#include "Config_Handler_export.h"
+#include "ace/SString.h"
+#include "ace/Hash_Map_Manager.h"
+#include "ace/Null_Mutex.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_main.h"
+#include "tao/Exception.h"
+#include "XercesString.h"
+#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMInputSource;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMNamedNodeMap;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+// ID map type definition
+typedef ACE_Hash_Map_Manager<ACE_TString, int, ACE_Null_Mutex> REF_MAP;
+typedef ACE_Hash_Map_Iterator<ACE_TString, int, ACE_Null_Mutex> REF_ITER;
+typedef ACE_Hash_Map_Manager<int, ACE_TString, ACE_Null_Mutex> IDREF_MAP;
+
+template <typename DATA>
+class Process_Function 
+{
+public:
+  virtual void call(DOMDocument*, DOMNodeIterator*, DATA&)=0;
+
+  void operator() (DOMDocument* doc, DOMNodeIterator* iter, DATA& data)
+  {
+    call(doc, iter, data);
+  }
+};
+
+/*
+ *  Wrapper class for the process member functions.
+ */
+
+template <typename OBJ, typename DATA>
+class Process_Member_Function: public Process_Function<DATA> 
+{
+public:
+  typedef void (OBJ::*func_type) (DOMNodeIterator*, DATA&);
+  typedef DATA data_type;
+
+  Process_Member_Function(OBJ& obj, func_type f)
+    : obj_(&obj), f_(f)
+  {
+  }
+
+  Process_Member_Function(OBJ* obj, func_type f)
+    : obj_(obj), f_(f)
+  {
+  }
+
+  virtual void call(DOMDocument* doc, DOMNodeIterator* iter, DATA& data)
+  {
+    obj_->set_doc (doc);
+    obj_->set_iter (iter);
+    (obj_->*f_) (iter, data);
+  }
+
+private:
+  OBJ* obj_;
+  func_type f_;
+};
+
+/*
+ *  Wrapper class for the process member functions which does not have 
+    DOMNodeIterator parameter
+ */
+
+template <typename OBJ, typename DATA>
+class Process_Member_Function_Remote: public Process_Function<DATA> 
+{
+public:
+  typedef void (OBJ::*func_type) (DATA&);
+  typedef DATA data_type;
+
+  Process_Member_Function_Remote(OBJ& obj, func_type f)
+    : obj_(&obj), f_(f)
+  {
+  }
+
+  Process_Member_Function_Remote(OBJ* obj, func_type f)
+    : obj_(obj), f_(f)
+  {
+  }
+
+  virtual void call(DOMDocument* doc, DOMNodeIterator* iter, DATA& data)
+  {
+    obj_->set_iter(iter);
+    obj_->set_doc(doc);
+    (obj_->*f_) (data);
+  }
+
+private:
+  OBJ* obj_;
+  func_type f_;
+};
+
+/*
+ *  Wrapper class for the static process member functions.
+ */
+
+template <typename DATA>
+class Process_Static_Function: public Process_Function<DATA> 
+{
+public:
+  typedef void (*func_type) (DOMNodeIterator*, DATA&);
+  typedef DATA data_type;
+
+  Process_Static_Function(func_type f)
+    : f_(f)
+  {
+  }
+
+  virtual void call(DOMDocument*, DOMNodeIterator* iter, DATA& data)
+  {
+    (*f_) (iter, data);
+  }
+
+private:
+  func_type f_;
+};
+
+// Processes reference sequences
+bool
+process_reference_seq (DOMNode* node,
+                       XStr& node_name, const char* name,
+                       CORBA::ULongSeq& seq,
+                       int& index,
+                       IDREF_MAP& idref_map);
+
+// Process reference
+bool
+process_reference (DOMNode* node,
+                   XStr& node_name, const char* name,
+                   CORBA::ULong& ref,
+                   int& index,
+                   IDREF_MAP& idref_map);
+
+END_DEPLOYMENT_NAMESPACE
+
+#include "Process_Element_T.h"
+
+#endif // PROCESS_ELEMENT_H
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.cpp
new file mode 100644
index 00000000000..56d0f530315
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.cpp
@@ -0,0 +1,294 @@
+//=====================================================================
+/**
+ *  @file Process_Element_T.cpp
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ *          Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#include "Process_Element_T.h"
+#include "Config_Handlers/Config_Error_Handler.h"
+#include "ace/Auto_Ptr.h"
+#include "Utils.h"
+#include <iostream>
+#include <memory>
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+class parser_error { };
+
+template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_local(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                       XStr& node_name, const char* name,
+                       SEQUENCE& seq, OBJECT* obj, FUNCTION func)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      Process_Member_Function<OBJECT, DATA>
+        pf(obj, func);
+      process_sequential_element (node, doc, iter, seq, &pf, obj->id_map());
+    }
+
+  return result;
+}
+
+template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_remote(DOMDocument* doc, DOMNodeIterator* iter, DOMNode*
+node,
+                        XStr& node_name, const char* name,
+                        SEQUENCE& seq, FUNCTION func,
+                        REF_MAP& id_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      OBJECT obj (doc, iter, false);
+
+      Process_Member_Function_Remote<OBJECT, DATA>
+        pf(obj, func);
+      process_sequential_element (node, doc, iter, seq, &pf, id_map);
+    }
+
+  return result;
+}
+
+template<typename DATA, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_common(DOMDocument* doc, DOMNodeIterator* iter, DOMNode*
+node,
+                        XStr& node_name, const char* name,
+                        SEQUENCE& seq, FUNCTION func,
+                        REF_MAP& id_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      Process_Static_Function<DATA>
+        pf(func);
+      process_sequential_element (node, doc, iter, seq, &pf, id_map);
+    }
+
+  return result;
+}
+
+template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
+bool
+process_element(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                XStr& node_name, const char* name,
+                ELEMENT& elem, OBJECT* obj, FUNCTION func,
+                REF_MAP& id_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      if (node->hasAttributes ())
+        {
+          DOMNamedNodeMap* named_node_map = node->getAttributes ();
+          int length = named_node_map->getLength ();
+
+          Process_Member_Function<OBJECT, DATA>
+            pf(obj, func);
+
+          if (length == 1)
+              pf(doc, iter, elem);
+          else
+              process_element_attributes(named_node_map, doc, iter, 0, elem,
+&pf, id_map);
+        }
+    }
+
+  return result;
+}
+
+template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
+bool
+process_element_remote(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                       XStr& node_name, const char *name,
+                       ELEMENT& elem, FUNCTION func,
+                       REF_MAP& id_map)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      OBJECT obj (iter, false);
+
+      if (node->hasAttributes ())
+        {
+          DOMNamedNodeMap* named_node_map = node->getAttributes ();
+          int length = named_node_map->getLength ();
+
+          Process_Member_Function_Remote<OBJECT, DATA>
+            pf(&obj, func);
+
+          if (length == 1)
+              pf(doc, iter, elem);
+          else
+              process_element_attributes(named_node_map, doc, iter, 0, elem,
+&pf, id_map);
+        }
+    }
+
+  return result;
+}
+
+template <typename VALUE, typename DATA>
+void process_element_attributes(DOMNamedNodeMap* named_node_map,
+                                DOMDocument* doc,
+                                DOMNodeIterator* iter,
+                                VALUE value,
+                                DATA& data,
+                                Process_Function <DATA>* func,
+                                REF_MAP& id_map)
+{
+  char* final_url_ch;
+  try
+    {
+      // the number of attributes
+      int length = named_node_map->getLength();
+      // iterate the attributes
+      for (int j = 0; j < length; ++j)
+        {
+          DOMNode* attribute_node = named_node_map->item (j);
+          XStr strattrnodename (attribute_node->getNodeName ());
+          char* aceattrnodevalue_ch =
+            XMLString::transcode (attribute_node->getNodeValue ());
+          ACE_TString aceattrnodevalue = aceattrnodevalue_ch;
+          XMLString::release (&aceattrnodevalue_ch);
+
+          // if xmi::id is given process the element and bind the value
+          if (strattrnodename == XStr (ACE_TEXT ("xmi:id")))
+            {
+              (*func) (doc, iter, data);
+              id_map.bind (aceattrnodevalue, value);
+            }
+          // if href is given find out the referenced position
+          // and process the element
+          else if (strattrnodename == XStr (ACE_TEXT ("href")))
+            {
+              XMLURL xml_url (aceattrnodevalue.c_str ());
+              XMLURL result (aceattrnodevalue.c_str ());
+              std::string url_string = aceattrnodevalue.c_str ();
+              char* doc_path_ch =
+                XMLString::transcode ( doc->getDocumentURI ());
+              ACE_TString doc_path = doc_path_ch;
+              XMLString::release (&doc_path_ch);
+              XMLCh* rel_str =
+                (XMLString::transcode (doc_path.c_str ()));
+              result.makeRelativeTo
+                (rel_str);
+              final_url_ch =
+                XMLString::transcode (result.getURLText ());
+              ACE_TString final_url = final_url_ch;
+              XMLString::release (&final_url_ch);
+              XMLString::release (&rel_str);
+
+              DOMDocument* href_doc;
+
+              std::auto_ptr<DOMBuilder> parser (
+                      CIAO::Config_Handler::Utils::create_parser  ());
+
+              CIAO::Config_Handler::Config_Error_Handler handler;
+              parser->setErrorHandler(&handler);
+                      
+              if (xml_url.isRelative ())
+                {
+                  href_doc = parser->parseURI (final_url.c_str ());
+                  if (handler.getErrors ())
+                    {
+                      ACE_DEBUG ((LM_DEBUG, "XML descriptor error\n"));
+                      //throw parser_error ();
+                      throw DOMException ();
+                    }
+                }
+              else
+                {
+                  href_doc = parser->parseURI (url_string.c_str ());
+                  if (handler.getErrors ())
+                    {
+                      ACE_DEBUG ((LM_DEBUG, "XML descriptor error\n"));
+                      //throw parser_error ();
+                      throw DOMException ();
+                    }
+                }
+
+              DOMDocumentTraversal* traverse = href_doc;
+              DOMNode* root = (href_doc->getDocumentElement ());
+              unsigned long filter = DOMNodeFilter::SHOW_ELEMENT |
+                DOMNodeFilter::SHOW_TEXT;
+              DOMNodeIterator* href_iter = traverse->createNodeIterator
+                (root,
+                 filter,
+                 0,
+                 true);
+              href_iter->nextNode ();
+              (*func) (href_doc, href_iter, data);
+            }
+        }
+    }
+  catch (const DOMException& e)
+    {
+      const unsigned int maxChars = 2047;
+      XMLCh errText[maxChars + 1];
+
+      ACE_ERROR ((LM_ERROR, "\nException occured while parsing %s: \
+                  \n",final_url_ch));
+      ACE_ERROR ((LM_ERROR, "DOMException code: %d\n ", e.code));
+      if (DOMImplementation::loadDOMExceptionMsg (e.code, errText, maxChars))
+        {
+          char* message = XMLString::transcode (errText);
+          ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+          ACE_ERROR ((LM_ERROR, "Message is: %s\n", message));
+        }
+      ACE_ERROR ((LM_ERROR, "Caught DOM exception\n\n"));
+      return;
+    }
+  catch (...)
+    {
+      ACE_DEBUG ((LM_DEBUG, "Caught unknown exception\n\n"));
+      return;
+    }
+}
+
+template <typename SEQUENCE, typename DATA>
+void
+process_sequential_element (DOMNode* node,
+                            DOMDocument* doc,
+                            DOMNodeIterator* iter,
+                            SEQUENCE& seq,
+                            Process_Function <DATA>* func,
+                            REF_MAP& id_map)
+{
+  if (node->hasAttributes ())
+    {
+      // the size of the sequence
+      CORBA::ULong i = seq.length ();
+
+      // add 1 to the size of the sequence
+      seq.length (i + 1);
+
+      // fetch attributes
+      DOMNamedNodeMap* named_node_map = node->getAttributes ();
+
+      // the number of attributes the element have
+      int length = named_node_map->getLength();
+      // if there is no other attribute but 'version'
+
+      if (length == 1) // call directly the static process_ method
+        (*func) (doc, iter, seq[i]);
+      else             // Check the xmi::id & href attributes
+        process_element_attributes(named_node_map, doc, iter, i, seq[i], func, id_map);
+    }
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.h b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.h
new file mode 100644
index 00000000000..693f0338a47
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Process_Element_T.h
@@ -0,0 +1,90 @@
+//==================================================================
+/**
+ *  @file Process_Element_T.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ *          Jaiganesh Balasubramanian  <jai@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef PROCESS_ELEMENT_T_H
+#define PROCESS_ELEMENT_T_H
+
+#include "Process_Element.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+// processes sequence - not for common elements, process function is a 
+// member of "this" -
+template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_local(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                      XStr& node_name, const char* name,
+                      SEQUENCE& seq, OBJECT* obj, FUNCTION func);
+
+// processes sequence - not for common elements, process function is not a 
+// member of "this" -
+template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_remote(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                        XStr& node_name, const char* name,
+                        SEQUENCE& seq, FUNCTION func,
+                        REF_MAP& id_map);
+
+// Processes sequence - common elements -
+template<typename DATA, typename SEQUENCE, typename FUNCTION>
+bool
+process_sequence_common(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                        XStr& node_name, const char* name,
+                        SEQUENCE& seq, FUNCTION func,
+                        REF_MAP& id_map);
+
+//  Process function for non-sequential elements
+template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
+bool
+process_element(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                XStr& node_name, const char* name,
+                ELEMENT& elem, OBJECT* obj, FUNCTION func,
+                REF_MAP& id_map);
+
+// Process function for non-sequential non-local elements
+template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
+bool
+process_element_remote(DOMDocument* doc, DOMNodeIterator* iter, DOMNode* node,
+                       XStr& node_name, const char* name,
+                       ELEMENT& elem, OBJECT* obj, FUNCTION func,
+                       REF_MAP& id_map);
+
+template <typename SEQUENCE, typename DATA>
+void
+process_sequential_element (DOMNode* node,
+                            DOMDocument* doc,
+                            DOMNodeIterator* iter,
+                            SEQUENCE& seq,
+                            Process_Function <DATA>* func,
+                            REF_MAP& id_map);
+
+template <typename VALUE, typename DATA>
+void process_element_attributes (DOMNamedNodeMap* named_node_map,
+                                 DOMDocument* doc, DOMNodeIterator* iter,
+                                 VALUE value, DATA& data,
+                                 Process_Function <DATA>* func,
+                                 REF_MAP& id_map);
+
+END_DEPLOYMENT_NAMESPACE
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "Process_Element_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Process_Element_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#endif // PROCESS_ELEMENT_H
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.cpp
new file mode 100644
index 00000000000..1272ad9dcc6
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.cpp
@@ -0,0 +1,81 @@
+//$Id$
+
+#include "Property_Handler.h"
+#include "Any_Handler.h"
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Utils;
+using CIAO::Config_Handler::Any_Handler;
+
+void
+CIAO::Config_Handler::Property_Handler::process_Property (DOMNodeIterator * iter,
+                                                          Deployment::Property &property)
+{
+  int valid_name = 0, valid_value = 0;
+  for (DOMNode * node = iter->nextNode (); node != 0; node = iter->nextNode ())
+    {
+      //Check if the Schema IDs for both the elements match
+      XStr name (node->getNodeName ());
+      if (name == XStr (ACE_TEXT ("name")))
+        {
+          valid_name = 1;
+          property.name = Utils::parse_string (iter);
+        }
+      else if (name == XStr (ACE_TEXT ("value")))
+        {
+          valid_value = 1;
+          if (node->hasAttributes ())
+            {
+              xercesc::DOMNamedNodeMap * named_node_map = 
+                node->getAttributes ();
+              int length = named_node_map->getLength ();
+              if (length > 1)
+                {
+                  for (int j = 0; j < length; j++)
+                    {
+                      DOMNode * attr_node = named_node_map->item (j);
+                      XStr attr_node_name = attr_node->getNodeName ();
+                      char*  attr_node_value_ch = 
+                        XMLString::transcode (attr_node->getNodeValue ());
+                      ACE_TString attr_node_value = attr_node_value_ch;
+                      XMLString::release (&attr_node_value_ch);
+                      if (attr_node_name = XStr (ACE_TEXT ("href")))
+                        {
+                          XMLURL url (attr_node_value.c_str ());
+                          DOMNodeIterator * value_iter = 
+                            Utils::parse_href_tag (url, 
+                                                   node->getOwnerDocument ());
+                          // Get to the root-node
+                          value_iter->nextNode ();
+
+                          // Process the value node present there
+                          Any_Handler::process_Any (value_iter, 
+                                                    property.value);
+                        }
+                    }
+                }
+              else if (length == 1)
+                Any_Handler::process_Any (iter, property.value);
+            }
+          else
+            // Process the value associated
+            Any_Handler::process_Any (iter, property.value);
+        }
+      else 
+        {
+          if (! valid_name || ! valid_value)
+            {
+              ACE_DEBUG ((LM_DEBUG, "Config_Handlers::Property_Handler::\
+                          process_Property element mismatch expected <name> \
+                          or <value>"));
+              ACE_THROW (CORBA::INTERNAL ());
+            }
+
+          // Processed one element more go back one and exit
+          iter->previousNode ();
+          break;
+        }
+    }/* End Outer for */
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.h
new file mode 100644
index 00000000000..3367a2e1348
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Property_Handler.h
@@ -0,0 +1,57 @@
+//==================================================================
+/**
+ *  @file  Property_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//===================================================================
+
+#ifndef PROPERTY_HANDLER_H
+#define PROPERTY_HANDLER_H
+
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class Property_Handler
+     *
+     * @brief Handler class for <Property> type
+     *
+     * This class defines handler methods to parse Property
+     * types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+    class Config_Handler_Export Property_Handler
+    {
+    public:
+      static void process_Property (DOMNodeIterator * iter,
+                                    Deployment::Property &property);
+      // process elements of type Property definitions in
+      // the descriptor files
+
+    };
+  }
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* PROPERTY_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.cpp
new file mode 100644
index 00000000000..f27f02c2d7b
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.cpp
@@ -0,0 +1,128 @@
+//$Id$
+
+#include "RS_Handler.h"
+#include "SP_Handler.h"
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "Utils.h"
+
+void
+CIAO::Config_Handler::RS_Handler::
+process_RequirementSatisfier (DOMNodeIterator * iter,
+                              Deployment::RequirementSatisfier &ret_struct)
+{
+  // boolean to represent valid <RequirementSatisfier> definition
+  int valid_name = 0, valid_resourceType = 0, valid_property  = 0;
+
+  for (DOMNode * node = iter->nextNode (); ; node = iter->nextNode ())
+    {
+      XStr name (node->getNodeName ());
+      if (name == XStr (ACE_TEXT ("name")))
+        {
+          ret_struct.name = CIAO::Config_Handler::Utils::parse_string (iter);
+          valid_name = 1;
+        }
+      else if (name == XStr (ACE_TEXT ("resourceType")))
+        {
+          valid_resourceType = 1;
+          // Requirement: Atleast one <resourceType> definition present
+          ::CORBA::StringSeq_var res_seq = 0;
+          ACE_NEW_THROW_EX (res_seq,
+                            ::CORBA::StringSeq (1),
+                            CORBA::NO_MEMORY ());
+          res_seq->length (0);
+
+          while (name == XStr (ACE_TEXT ("resourceType")))
+            {
+              ::CORBA::ULong index = res_seq->length ();
+              res_seq->length (res_seq->length () + 1);
+              res_seq [index] = 
+                CIAO::Config_Handler::Utils::parse_string (iter);
+              name = node->getNodeName ();
+            }
+
+          // On exit go one step back to faciliate parsing next tag
+          iter->previousNode ();
+
+          // Assign this sequence to the Return Structure
+          ret_struct.resourceType = res_seq;
+        }
+
+      else if (name == XStr (ACE_TEXT ("property")))
+        {
+          valid_property = 1;
+          Deployment::SatisfierProperties_var property_seq = 0;
+          DOMNodeIterator * property_iter = 0;
+          ACE_NEW_THROW_EX (property_seq,
+                            Deployment::SatisfierProperties,
+                            CORBA::NO_MEMORY ());
+          property_seq->length (0);
+          while (name == XStr (ACE_TEXT ("property")))
+            {
+              // Check for <href> tags 
+              if (node->hasAttributes ())
+                {
+                  xercesc::DOMNamedNodeMap * named_node_map = 
+                    node->getAttributes ();
+                  int length = named_node_map->getLength ();
+                  if (length > 1)
+                    {
+                      for (int j = 0; j < length; j++)
+                        {
+                          DOMNode * attr_node = named_node_map->item (j);
+                          XStr attr_node_name = attr_node->getNodeName ();
+                          char*  attr_node_value_ch =
+                            XMLString::transcode (attr_node->getNodeValue ());
+                          ACE_TString attr_node_value = attr_node_value_ch;
+                          XMLString::release (&attr_node_value_ch);
+                          if (attr_node_name = XStr (ACE_TEXT ("href")))
+                            {
+                              XMLURL url (attr_node_value.c_str ());
+                              DOMNodeIterator * value_iter =
+                                Utils::parse_href_tag (url, 
+                                                       node->getOwnerDocument ());
+                              // Get to the root-node
+                              value_iter->nextNode ();
+
+                              // Process the property href tag
+                              property_iter = value_iter;
+                            }
+                        }
+                    } 
+                } 
+              else
+                property_iter = iter;
+
+              // Copy the property onto the sequence
+              ::CORBA::ULong index = property_seq->length ();
+              property_seq->length (property_seq->length () + 1);
+              CIAO::Config_Handler::SP_Handler::
+                process_SatisfierProperty (property_iter,
+                                           property_seq [index]);
+
+              // Get next node
+              iter->nextNode ();
+              name = node->getNodeName ();
+            }
+
+          // On exit go one step back to faciliate parsing next tag
+          iter->previousNode ();
+
+          // Copy the sequence to return structure
+          ret_struct.property = property_seq;
+        }
+      else
+        {
+          if (! valid_name || ! valid_resourceType || ! valid_property)
+            ACE_DEBUG ((LM_DEBUG, "Config_Handlers::RS_Handler::process_ \
+                        RequirementSatisfier element mismatch expected <name>,\
+                        <resourceType> <property>\n"));
+          // On exit go one step back as one might have processed the next 
+          // valid tag
+          iter->previousNode ();
+
+          // Exit out of the for loop
+          break;
+        }
+    }
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.h
new file mode 100644
index 00000000000..11d858b4141
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/RS_Handler.h
@@ -0,0 +1,57 @@
+//==================================================================
+/**
+ *  @file  RS_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//==================================================================
+
+#ifndef RS_HANDLER_H
+#define RS_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class RS_Handler
+     *
+     * @brief Handler class for <RequirementSatisfier> type
+     *
+     * This class defines handler methods to parse RequirementSatisfier
+     * types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+    class Config_Handler_Export RS_Handler
+    {
+    public:
+      static void
+        process_RequirementSatisfier (DOMNodeIterator * iter,
+                                      Deployment::RequirementSatisfier &ret_struct);
+      // process elements of type RequirementSatisfier definitions in
+      // the descriptor files
+
+    };
+  }
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* ID_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.cpp
new file mode 100644
index 00000000000..08f390824dc
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.cpp
@@ -0,0 +1,61 @@
+//==================================================================
+/**
+ *  @file  RUK_Handler.cpp
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+
+#include "IAD_Handler.h"
+#include "RUK_Handler.h"
+#include "Utils.h"
+
+#include <iostream>
+
+using std::cerr;
+using std::endl;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /*
+     * Class ResourceUsageKind_Handler
+     */
+
+     void RUK_Handler::process_ResourceUsageKind
+        (DOMNodeIterator *iter, ::Deployment::ResourceUsageKind &kind)
+     {
+       // -- ResourceUsageKind enum
+       XStr none                    ("None");
+       XStr instance_uses_resource  ("InstanceUsesResource");
+       XStr resource_uses_instance  ("ResourceUsesInstance");
+       XStr port_uses_resource      ("PortUsesResource");
+       XStr resource_uses_port      ("ResourceUsesPort");
+       
+       XStr kind_str = XStr (Utils::parse_string (iter));
+       if (kind_str == none)
+	 kind = Deployment::None;
+       else if (kind_str = instance_uses_resource)
+	 kind = Deployment::InstanceUsesResource;
+       else if (kind_str == resource_uses_instance)
+	 kind = Deployment::ResourceUsesInstance;
+       else if (kind_str == port_uses_resource)
+	 kind = Deployment::PortUsesResource;
+       else if (kind_str == resource_uses_port)
+	 kind = Deployment::ResourceUsesPort;
+       
+       // Something wrong here.. Throw exception
+       ACE_DEBUG ((LM_DEBUG,
+		   "Config_Handler::RUK_Handler::process_ResourceUsageKind \
+                    illegal <ResourceUsageKind> value found \n"));
+       ACE_THROW (CORBA::INTERNAL ());
+     }
+  }
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.h
new file mode 100644
index 00000000000..70536e39072
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/RUK_Handler.h
@@ -0,0 +1,77 @@
+//==================================================================
+/**
+ *  @file  RUK_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef RUK_HANDLER_H
+#define RUK_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+namespace CIAO 
+{
+  namespace Config_Handler
+  {
+
+    /**
+     * @class RUK_Handler
+     *
+     * @brief Handler class for <ResourceUsageKind> type
+     *
+     * This class defines handler methods to parse ResourceUsage
+     * Kind types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+
+    class Config_Handler_Export RUK_Handler {
+    public:
+
+      /// Process elements of type ResourceUsageKind definitions in
+      /// the description files.
+      static void
+	process_ResourceUsageKind (DOMNodeIterator *iter, ::Deployment::ResourceUsageKind &kind);
+    };
+    
+  }
+
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* RUK_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.cpp
new file mode 100644
index 00000000000..bc5b1fcb56a
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.cpp
@@ -0,0 +1,113 @@
+//$Id$
+
+#include "Requirement_Handler.h"
+#include "Property_Handler.h"
+#include "tao/Exception.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Property_Handler;
+
+void
+CIAO::Config_Handler::Requirement_Handler::process_Requirement (DOMNodeIterator * iter,
+                                                                Deployment::Requirement &ret_struct)
+{
+  int valid_resourceType = 0, valid_property = 0, valid_name = 0;
+  for (DOMNode * node = iter->nextNode (); 
+       node != 0; 
+       node = iter->nextNode ())
+    {
+      XStr name (node->getNodeName ());
+      if (name == XStr (ACE_TEXT ("resourceType")))
+        {
+          valid_resourceType = 1;
+          // Populate the structure
+          ret_struct.resourceType = 
+            CIAO::Config_Handler::Utils::parse_string (iter);
+        }
+      else if (name == XStr (ACE_TEXT ("property")))
+        {
+          Deployment::Properties_var properties = 0;
+          ACE_NEW_THROW_EX (properties,
+                            Deployment::Properties,
+                            CORBA::NO_MEMORY ());
+          properties->length (0);
+
+          for (node = iter->nextNode ();
+               name == XStr (ACE_TEXT ("property"));
+               iter->nextNode ())
+            {
+              // Increment length of sequence
+              ::CORBA::ULong index = properties->length ();
+              properties->length (properties->length () + 1);
+              DOMNodeIterator * property_iter = 0;
+
+              // Check for <href> tags
+              if (node->hasAttributes ())
+                {
+                  xercesc::DOMNamedNodeMap * named_node_map =
+                    node->getAttributes ();
+                  int length = named_node_map->getLength ();
+
+                  if (length > 1)
+                    {
+                      for (int j = 0; j < length; j++)
+                        {
+                          DOMNode * attr_node = named_node_map->item (j);
+                          XStr attr_node_name = attr_node->getNodeName ();
+                          char*  attr_node_value_ch =
+                            XMLString::transcode (attr_node->getNodeValue ());
+                          ACE_TString attr_node_value = attr_node_value_ch;
+                          auto_ptr<char> cleanup_char (attr_node_value_ch);
+                          if (attr_node_name = XStr (ACE_TEXT ("href")))
+                            {
+                              XMLURL url (attr_node_value.c_str ());
+                              DOMNodeIterator * value_iter =
+                                Utils::parse_href_tag (url, 
+                                                       node->getOwnerDocument ());
+                              // Get to the root-node
+                              value_iter->nextNode ();
+
+                              // Process the property href tag
+                              property_iter = value_iter;
+                            }
+                        }
+                    }
+                  else
+                    property_iter = iter;
+
+                  // Deep copy the value
+                  CIAO::Config_Handler::Property_Handler::
+                    process_Property (property_iter, properties [index]);
+                }  
+            }
+          valid_property = 1;
+
+          // On exit go one step back to faciliate parsing next tag
+          iter->previousNode ();
+
+          // Copy sequence on to return struct
+          ret_struct.property = properties;
+        }
+      else if (name == XStr (ACE_TEXT ("name")))
+        {
+          valid_name = 1;
+          ret_struct.name = CIAO::Config_Handler::Utils::parse_string (iter);
+        }
+      else 
+        {
+          if (! valid_resourceType || 
+              ! valid_property     ||
+              ! valid_name)
+            {
+              ACE_DEBUG ((LM_DEBUG,
+                          "Config_Handlers::Requirement_Handler::process_\
+                          Requirement element mismatch expected <resourceType>\
+                          , <property> or <name>"));
+              ACE_THROW (CORBA::INTERNAL ());
+            }
+          // On exit go one step back as we have read one too many
+          iter->previousNode ();
+          break;
+        }
+    }
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.h
new file mode 100644
index 00000000000..b960e9b70d7
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Requirement_Handler.h
@@ -0,0 +1,57 @@
+//==================================================================
+/**
+ *  @file  Requirement_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef REQUIREMENT_HANDLER_H
+#define REQUIREMENT_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class Requirement_Handler
+     *
+     * @brief Handler class for <ImplementationDependency> type
+     *
+     * This class defines handler methods to parse Implementation
+     * Dependency types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+    class Config_Handler_Export Requirement_Handler
+    {
+    public:
+      static void
+        process_Requirement (DOMNodeIterator * iter,
+                             Deployment::Requirement &ret_struct);
+      // process elements of type Requirement in the descriptor files
+
+    };
+  }
+
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* REQUIREMENT_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.cpp
new file mode 100644
index 00000000000..e7731252994
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.cpp
@@ -0,0 +1,41 @@
+//$Id$
+
+#include "SPK_Handler.h"
+#include "tao/Exception.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Utils;
+
+void
+CIAO::Config_Handler::SPK_Handler::
+process_SatisfierPropertyKind (DOMNodeIterator * iter,
+                               Deployment::SatisfierPropertyKind &kind)
+{
+  // -- SatisfierPropertyKind enum
+  XStr quantity  ("Quantity");
+  XStr capacity  ("Capacity");
+  XStr minimum   ("Minimum");
+  XStr maximum   ("Maximum");
+  XStr attribute ("Attribute");
+  XStr selection ("Selection");
+
+  XStr kind_str = XStr (Utils::parse_string (iter));
+  if (kind_str == quantity)
+     kind = Deployment::Quantity;
+  else if (kind_str = capacity)
+     kind = Deployment::Capacity;
+  else if (kind_str == minimum)
+     kind = Deployment::Minimum;
+  else if (kind_str == maximum)
+     kind = Deployment::Maximum;
+  else if (kind_str == attribute)
+     kind = Deployment::Attribute;
+  else if (kind_str == selection)
+     kind = Deployment::Selection;
+
+  // Something wrong here.. Throw exception
+  ACE_DEBUG ((LM_DEBUG,
+              "Config_Handler::SPK_Handler::process_SPK \
+               illegal <SatisfierPropertyKind> value found \n"));
+  ACE_THROW (CORBA::INTERNAL ());
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.h
new file mode 100644
index 00000000000..51b6f1eb8b2
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/SPK_Handler.h
@@ -0,0 +1,57 @@
+//==================================================================
+/**
+ *  @file  SPK_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef SPK_HANDLER_H
+#define SPK_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class SPK_Handler
+     *
+     * @brief Handler class for <SatisfierPropertyKind> type
+     *
+     * This class defines handler methods to parse Implementation
+     * Dependency types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+    class Config_Handler_Export SPK_Handler
+    {
+    public:
+      static void process_SatisfierPropertyKind (DOMNodeIterator * iter,
+                                                 Deployment::SatisfierPropertyKind &kind);
+      // process elements of type SatisfierPropertyKind definitions in
+      // the descriptor files
+
+    };
+  }
+
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* SPK_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.cpp
new file mode 100644
index 00000000000..842912db9ca
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.cpp
@@ -0,0 +1,79 @@
+//$Id$
+
+#include "SP_Handler.h"
+#include "Any_Handler.h"
+#include "SPK_Handler.h"
+#include "tao/Exception.h"
+#include "ace/Auto_Ptr.h"
+#include "Utils.h"
+
+using CIAO::Config_Handler::Utils;
+using CIAO::Config_Handler::Any_Handler;
+
+void
+CIAO::Config_Handler::SP_Handler::
+process_SatisfierProperty (DOMNodeIterator * iter,
+                           Deployment::SatisfierProperty &property)
+{
+  for (DOMNode * node = iter->nextNode (); ; node = iter->nextNode ())
+    {
+      // Get name of the current element
+      XStr name (node->getNodeName ());
+
+      if (name == XStr (ACE_TEXT ("name")))
+        property.name = Utils::parse_string (iter);
+      else if (name == XStr (ACE_TEXT ("kind")))
+        SPK_Handler::process_SatisfierPropertyKind (iter, property.kind);
+      else if (name == XStr (ACE_TEXT ("value")))
+        {
+          // Check for <href> tags
+          if (node->hasAttributes ())
+            {
+              xercesc::DOMNamedNodeMap * named_node_map =
+                node->getAttributes ();
+              int length = named_node_map->getLength ();
+              if (length > 1)
+                {
+                  for (int j = 0; j < length; j++)
+                    {
+                      DOMNode * attr_node = named_node_map->item (j);
+                      XStr attr_node_name = attr_node->getNodeName ();
+                      char*  attr_node_value_ch =
+                        XMLString::transcode (attr_node->getNodeValue ());
+                      ACE_TString attr_node_value = attr_node_value_ch;
+                      XMLString::release (&attr_node_value_ch);
+                      if (attr_node_name = XStr (ACE_TEXT ("href")))
+                        {
+                          XMLURL url (attr_node_value.c_str ());
+                          DOMNodeIterator * value_iter =
+                            Utils::parse_href_tag (url, 
+                                                   node->getOwnerDocument ());
+
+                          // Get to the root-node
+                          value_iter->nextNode ();
+
+                          // Process the property href tag
+                          Any_Handler::process_Any (value_iter, 
+                                                    property.value);
+                        }
+                    }
+                }
+            }
+          else
+            // Populate value for the Property
+            Any_Handler::process_Any (iter, property.value);
+        }
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG, "Config_Handlers::SP_Handler::process_ \
+                      RequirementSatisfier element mismatch expected <name> \
+                      or <PropertyKind> <Deployment:Any>"));
+
+          // Get the previous iterator
+          iter->previousNode ();
+
+          // Exit from the for loop
+          break;
+        }
+    }
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.h
new file mode 100644
index 00000000000..a5402097793
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/SP_Handler.h
@@ -0,0 +1,56 @@
+//==================================================================
+/**
+ *  @file  SP_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef SP_HANDLER_H
+#define SP_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLString;
+using xercesc::DOMText;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+
+namespace CIAO
+{
+  namespace Config_Handler
+  {
+    /**
+     * @class SP_Handler
+     *
+     * @brief Handler class for <SatisfierProperty> type
+     *
+     * This class defines handler methods to parse Implementation
+     * Dependency types in the descriptor files. The corresponding
+     * CORBA IDL type for the schema element is returned.
+     *
+     */
+    class Config_Handler_Export SP_Handler
+    {
+    public:
+      static void process_SatisfierProperty (DOMNodeIterator * iter,
+                                             Deployment::SatisfierProperty &property);
+      // process elements of type SatisfierProperty definitions in
+      // the descriptor files
+
+    };
+  }
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* ID_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.cpp b/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.cpp
new file mode 100644
index 00000000000..d145106bae5
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.cpp
@@ -0,0 +1,88 @@
+// $Id$
+
+#include "tao/Exception.h"
+#include "ace/Log_Msg.h"
+#include "Property_Handler.h"
+#include "Requirement_Handler.h"
+#include "CPR_Handler.h"
+#include "CompPkgDesc_Handler.h"
+#include "TPD_Handler.h"
+#include "Process_Element.h"
+#include "Utils.h"
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/// handle the package configuration and populate it
+ACE_TString TPD_Handler::process_TopLevelPackageDescription()
+{
+  for (DOMNode* node = this->iter_->nextNode ();
+       node != 0;
+       node = this->iter_->nextNode ())
+    {
+      XStr node_name (node->getNodeName());
+      if (node_name == XStr
+              (ACE_TEXT ("Deployment:TopLevelPackageDescription")))
+        {
+        }
+      else if (node_name == XStr(ACE_TEXT ("package")))
+        {
+          if (node->hasAttributes ())
+            {
+              DOMNamedNodeMap* named_node_map = node->getAttributes ();
+
+              // the number of attributes
+              int length = named_node_map->getLength();
+              // iterate the attributes
+              for (int j = 0; j < length; ++j)
+                {
+                  DOMNode* attribute_node = named_node_map->item (j);
+                  XStr strattrnodename (attribute_node->getNodeName ());
+
+                  char * temp =
+                    XMLString::transcode (attribute_node->getNodeValue ());
+                  ACE_TString aceattrnodevalue = temp;
+                  XMLString::release (&temp);
+
+                  // if href is given find out the referenced position
+                  // and process the element
+                  if (strattrnodename == XStr (ACE_TEXT ("href")))
+                    {
+                      XMLURL xml_url (aceattrnodevalue.c_str ());
+                      XMLURL result (aceattrnodevalue.c_str ());
+                      ACE_TString url_string = aceattrnodevalue.c_str ();
+
+                      char * temp =
+                        XMLString::transcode ( doc_->getDocumentURI ());
+                      ACE_TString doc_path = temp;
+                      XMLString::release (&temp);
+
+                      XMLCh * relative_path =
+                        XMLString::transcode (doc_path.c_str ());
+                      result.makeRelativeTo (relative_path);
+                      XMLString::release (&relative_path);
+
+                      temp = XMLString::transcode (result.getURLText ());
+                      ACE_TString final_url = temp;
+                      XMLString::release (&temp);
+
+                      if (xml_url.isRelative ())
+                        {
+                          return final_url;
+                        }
+                      else
+                        {
+                          return url_string;
+                        }
+                    }
+                }
+            }
+        }
+      else
+        {
+          break;
+        }
+    }
+  ACE_THROW (CORBA::INTERNAL());
+}
+
+END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.h b/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.h
new file mode 100644
index 00000000000..30265026f8c
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/TPD_Handler.h
@@ -0,0 +1,87 @@
+//==================================================================
+/**
+ *  @file  TPD_Handler.h
+ *
+ *  $Id$
+ *
+ *  @author Emre Turkay <turkaye@dre.vanderbilt.edu>
+ */
+//=====================================================================
+
+#ifndef TPD_HANDLER_H
+#define TPD_HANDLER_H
+#include /**/ "ace/pre.h"
+
+#include "DeploymentC.h"
+#include "Config_Handler_export.h"
+#include "Basic_Handler.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/SString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include "XercesString.h"
+
+using Config_Handler::XStr;
+using xercesc::XMLUni;
+using xercesc::XMLString;
+using xercesc::XMLException;
+using xercesc::DOMException;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMImplementationLS;
+using xercesc::DOMImplementation;
+using xercesc::DOMText;
+using xercesc::DOMNamedNodeMap;
+using xercesc::DOMLocator;
+using xercesc::DOMError;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMNodeFilter;
+
+BEGIN_DEPLOYMENT_NAMESPACE
+
+/**
+ * @class TPD_Handler
+ *
+ * @brief Handler class for <TopLevelPackageConfiguration> type 
+ *
+ * This class is within the Component Data Model subpackage of the
+ * Deployment & Configuration package.
+ *
+ * This class defines handler methods to parse the aforementioned type
+ * in the description files. The corresponding CORBA IDL type for this
+ * element is returned.
+ */
+
+class Config_Handler_Export TPD_Handler: public Basic_Handler
+{
+public:
+
+  /// constructor
+  TPD_Handler (DOMDocument* doc, unsigned long filter_)
+    : Basic_Handler (doc, filter_) { }
+
+  /// constructor
+  TPD_Handler (DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (iter, release) { }
+
+  /// constructor
+  TPD_Handler (DOMDocument* doc, DOMNodeIterator* iter, bool release = false)
+    : Basic_Handler (doc, iter, release) { }
+
+  /// Process the package configuration
+  ACE_TString process_TopLevelPackageDescription ();
+
+};
+
+END_DEPLOYMENT_NAMESPACE
+
+#include /**/ "ace/post.h"
+
+#endif /* TPD_HANDLER_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Utils.cpp b/TAO/CIAO/DAnCE/Config_Handlers/Utils.cpp
new file mode 100644
index 00000000000..526d757dbd9
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Utils.cpp
@@ -0,0 +1,353 @@
+//$Id$
+
+#include "Utils.h"
+#include "ace/OS_NS_stdlib.h"
+#include "ace/Log_Msg.h"
+#include "ace/SString.h"
+#include "ace/Auto_Ptr.h"
+
+#include "XercesString.h"
+#include <xercesc/util/XMLURL.hpp>
+#include <xercesc/util/XMLUri.hpp>
+#include <xercesc/util/XMLUniDefs.hpp>
+
+using xercesc::XMLUri;
+using xercesc::XMLURL;
+using xercesc::DOMDocument;
+using xercesc::DOMDocumentTraversal;
+using xercesc::XMLUni;
+using xercesc::DOMImplementation;
+using xercesc::DOMImplementationRegistry;
+using xercesc::DOMNodeFilter;
+using xercesc::DOMBuilder;
+using xercesc::DOMImplementationLS;
+
+char *
+CIAO::Config_Handler::Utils::parse_string (DOMNodeIterator * iter)
+{
+  DOMNode * node = iter->nextNode();
+  DOMText* text = ACE_reinterpret_cast (DOMText*, node);
+  return XMLString::transcode (text->getNodeValue ());
+}
+
+CORBA::Short
+CIAO::Config_Handler::Utils::parse_short (DOMNodeIterator * iter)
+{
+  char *temp = Config_Handler::Utils::parse_string (iter);
+  CORBA::Short ret_val = ACE_OS::atoi (temp);
+  XMLString::release (&temp);
+  return ret_val;
+}
+
+CORBA::ULong
+CIAO::Config_Handler::Utils::parse_ulong (DOMNodeIterator * iter)
+{
+  char *temp = Config_Handler::Utils::parse_string (iter);
+  CORBA::ULong ret_val = ACE_OS::strtoul (temp, 0, 10);
+  XMLString::release (&temp);
+  return ret_val;
+}
+
+CORBA::Long
+CIAO::Config_Handler::Utils::parse_long (DOMNodeIterator * iter)
+{
+  char *temp = Config_Handler::Utils::parse_string (iter);
+  CORBA::ULong ret_val = ACE_OS::strtol (temp, 0, 10);
+  XMLString::release (&temp);
+  return ret_val;
+}
+
+CORBA::Double
+CIAO::Config_Handler::Utils::parse_double (DOMNodeIterator * iter)
+{
+  char *temp = Config_Handler::Utils::parse_string (iter);
+  CORBA::Double ret_val = ACE_OS::strtod (temp, 0);
+  XMLString::release (&temp);
+  return ret_val;
+}
+
+CORBA::Float
+CIAO::Config_Handler::Utils::parse_float (DOMNodeIterator * iter)
+{
+  return ACE_static_cast (CORBA::Float, Utils::parse_double (iter));
+}
+
+CORBA::Boolean
+CIAO::Config_Handler::Utils::parse_bool (DOMNodeIterator * iter)
+{
+  XStr true_val ("true");
+  XStr true_cap_val ("TRUE");
+
+  DOMText * text = ACE_reinterpret_cast (DOMText *, iter->nextNode ());
+  XStr value (text->getNodeValue ());
+
+  if (value == true_val || value == true_cap_val)
+    return 1;
+  else
+    return 0;
+}
+
+CORBA::Char
+CIAO::Config_Handler::Utils::parse_char (DOMNodeIterator * iter)
+{
+  DOMText * text = ACE_reinterpret_cast (DOMText *, iter->nextNode ());
+  char * temp_string = XMLString::transcode (text->getNodeValue ());
+
+  // Should be non-null
+  ACE_ASSERT (temp_string != 0);
+
+  // Return the first character in the node as char value
+  char ret_char = temp_string [0];
+  XMLString::release (&temp_string);
+  return ret_char;
+}
+
+CORBA::Octet
+CIAO::Config_Handler::Utils::parse_octet (DOMNodeIterator * iter)
+{
+  return Utils::parse_char (iter);
+}
+
+bool
+CIAO::Config_Handler::Utils::process_string (DOMNodeIterator* iter,
+                const XStr& node_name, const char* name,
+                TAO_String_Manager& var)
+{
+  bool result = (node_name == XStr(ACE_TEXT (name)));
+  if (result == true)
+    {
+      DOMNode* node = iter->nextNode();
+      const XMLCh* text = ACE_reinterpret_cast(DOMText*, node)->getNodeValue
+();
+      if (text)
+        var = XMLString::transcode (text);
+    }
+  return result;
+}
+
+bool
+CIAO::Config_Handler::Utils::process_string_seq (DOMNodeIterator* iter,
+                    const XStr& node_name, const char* name,
+                    CORBA::StringSeq& seq)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      DOMNode* node = iter->nextNode ();
+      const XMLCh* text = ACE_reinterpret_cast
+                            (DOMText*, node)->getNodeValue ();
+
+      if (text)
+        {
+          CORBA::ULong i (seq.length ());
+          seq.length (i + 1);
+          seq[i] = XMLString::transcode (text);
+        }
+    }
+
+  return result;
+}
+
+bool
+CIAO::Config_Handler::Utils::process_ulong (DOMNodeIterator* iter,
+               const XStr& node_name, const char* name,
+               CORBA::ULong& var)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      DOMNode* node = iter->nextNode ();
+      const XMLCh* text = ACE_reinterpret_cast
+                            (DOMText*, node)->getNodeValue ();
+
+      if (text)
+        {
+          CORBA::String_var temp = XMLString::transcode (text);
+          var = ACE_static_cast (CORBA::ULong, ACE_OS::strtol (temp.in (),
+                                 0, 10));
+        }
+    }
+
+  return result;
+}
+
+bool
+CIAO::Config_Handler::Utils::process_boolean (DOMNodeIterator* iter,
+                 const XStr& node_name, const char* name,
+                 CORBA::Boolean& var)
+{
+  bool result = (node_name == XStr (ACE_TEXT (name)));
+
+  if (result == true)
+    {
+      DOMNode* node = iter->nextNode ();
+      const XMLCh* text = ACE_reinterpret_cast
+                            (DOMText*, node)->getNodeValue ();
+
+      if (text)
+        {
+          CORBA::String_var temp = XMLString::transcode (text);
+          var = ACE_static_cast (CORBA::Boolean, ACE_OS::strtol (temp.in (),
+                                 0, 10));
+        }
+    }
+
+  return result;
+}
+
+DOMDocument*
+CIAO::Config_Handler::Utils::create_document (const char * url)
+{
+  xercesc::XMLPlatformUtils::Initialize();
+  static const XMLCh gLS[] = { xercesc::chLatin_L,
+                               xercesc::chLatin_S,
+                               xercesc::chNull };
+
+  DOMImplementation* impl
+    = DOMImplementationRegistry::getDOMImplementation(gLS);
+  //auto_ptr<DOMImplementation> cleanup_impl (impl);
+
+  DOMBuilder* parser =
+    ((DOMImplementationLS*)impl)->
+    createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
+  //auto_ptr<DOMBuilder> cleanup_parser (parser);
+
+  // Discard comment nodes in the document
+  parser->setFeature (XMLUni::fgDOMComments, false);
+
+  // Disable datatype normalization. The XML 1.0 attribute value
+  // normalization always occurs though.
+  parser->setFeature (XMLUni::fgDOMDatatypeNormalization, true);
+
+  // Do not create EntityReference nodes in the DOM tree. No
+  // EntityReference nodes will be created, only the nodes
+  // corresponding to their fully expanded sustitution text will be
+  // created.
+  parser->setFeature (XMLUni::fgDOMEntities, false);
+
+  // Perform Namespace processing.
+  parser->setFeature (XMLUni::fgDOMNamespaces, true);
+
+  // Perform Validation
+  parser->setFeature (XMLUni::fgDOMValidation, true);
+
+  // Do not include ignorable whitespace in the DOM tree.
+  parser->setFeature (XMLUni::fgDOMWhitespaceInElementContent, false);
+
+  // Enable the parser's schema support.
+  parser->setFeature (XMLUni::fgXercesSchema, true);
+
+  // Enable full schema constraint checking, including checking which
+  // may be time-consuming or memory intensive. Currently, particle
+  // unique attribution constraint checking and particle derivation
+  // restriction checking are controlled by this option.
+  parser->setFeature (XMLUni::fgXercesSchemaFullChecking, true);
+
+  // The parser will treat validation error as fatal and will exit.
+  parser->setFeature (XMLUni::fgXercesValidationErrorAsFatal, true);
+
+
+  DOMDocument* doc = parser->parseURI (url);
+  //auto_ptr<DOMDocument> cleanup_doc (doc);
+
+  return doc;
+}
+
+DOMBuilder*
+CIAO::Config_Handler::Utils::create_parser ()
+{
+  xercesc::XMLPlatformUtils::Initialize();
+  static const XMLCh gLS[] = { xercesc::chLatin_L,
+                               xercesc::chLatin_S,
+                               xercesc::chNull };
+
+  DOMImplementation* impl
+    = DOMImplementationRegistry::getDOMImplementation(gLS);
+  //auto_ptr<DOMImplementation> cleanup_impl (impl);
+
+  DOMBuilder* parser =
+    ((DOMImplementationLS*)impl)->
+    createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0);
+  //auto_ptr<DOMBuilder> cleanup_parser (parser);
+
+  // Discard comment nodes in the document
+  parser->setFeature (XMLUni::fgDOMComments, false);
+
+  // Disable datatype normalization. The XML 1.0 attribute value
+  // normalization always occurs though.
+  parser->setFeature (XMLUni::fgDOMDatatypeNormalization, true);
+
+  // Do not create EntityReference nodes in the DOM tree. No
+  // EntityReference nodes will be created, only the nodes
+  // corresponding to their fully expanded sustitution text will be
+  // created.
+  parser->setFeature (XMLUni::fgDOMEntities, false);
+
+  // Perform Namespace processing.
+  parser->setFeature (XMLUni::fgDOMNamespaces, true);
+
+  // Perform Validation
+  parser->setFeature (XMLUni::fgDOMValidation, true);
+
+  // Do not include ignorable whitespace in the DOM tree.
+  parser->setFeature (XMLUni::fgDOMWhitespaceInElementContent, false);
+
+  // Enable the parser's schema support.
+  parser->setFeature (XMLUni::fgXercesSchema, true);
+
+  // Enable full schema constraint checking, including checking which
+  // may be time-consuming or memory intensive. Currently, particle
+  // unique attribution constraint checking and particle derivation
+  // restriction checking are controlled by this option.
+  parser->setFeature (XMLUni::fgXercesSchemaFullChecking, true);
+
+  // The parser will treat validation error as fatal and will exit.
+  parser->setFeature (XMLUni::fgXercesValidationErrorAsFatal, true);
+
+
+  //DOMDocument* doc = parser->parseURI (url);
+  //auto_ptr<DOMDocument> cleanup_doc (doc);
+
+  return parser;
+}
+
+DOMNodeIterator *
+CIAO::Config_Handler::Utils::parse_href_tag (XMLURL url, DOMDocument * doc)
+{
+  char * document_path = 0;
+  if (url.isRelative ())
+  {
+    char * doc_path = XMLString::transcode (doc->getDocumentURI ());
+    XMLCh * temp = XMLString::transcode (doc_path);
+    url.makeRelativeTo (temp);
+    document_path = XMLString::transcode (url.getURLText ());
+
+    // Release allocated memory
+    XMLString::release (&doc_path);
+    XMLString::release (&temp);
+  }
+  else
+  {
+    document_path = XMLString::transcode (url.getURLText ());
+
+  }
+
+  DOMDocument* href_doc =
+    CIAO::Config_Handler::Utils::create_document (document_path);
+  //auto_ptr<DOMDocument> cleanup_doc (href_doc);
+
+  DOMDocumentTraversal* traverse = href_doc;
+  DOMNode* root = (href_doc->getDocumentElement ());
+  unsigned long filter = DOMNodeFilter::SHOW_ELEMENT |
+                         DOMNodeFilter::SHOW_TEXT;
+
+  // release allocated memory
+  XMLString::release (&document_path);
+
+  return traverse->createNodeIterator (root,
+                                       filter,
+                                       0,
+                                       true);
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/Utils.h b/TAO/CIAO/DAnCE/Config_Handlers/Utils.h
new file mode 100644
index 00000000000..dd051603d40
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/Utils.h
@@ -0,0 +1,118 @@
+//====================================================================
+/**
+ *  @file  Utils.h
+ *
+ *  $Id$
+ *
+ *  @author Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
+ *  @author Tao Lu <lu@dre.vanderbilt.edu>,
+ *  @author Boris <boris@dre.vanderbilt.edu>
+ *
+ */
+//=====================================================================
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#include /**/ "ace/pre.h"
+
+#include "Config_Handler_export.h"
+#include "DeploymentC.h"
+
+#include "tao/Basic_Types.h"
+#include "XercesString.h"
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/util/XMLURL.hpp>
+
+using xercesc::XMLURL;
+using xercesc::DOMNodeIterator;
+using xercesc::DOMNode;
+using xercesc::DOMText;
+using xercesc::DOMBuilder;
+using xercesc::XMLString;
+using xercesc::DOMDocument;
+using Config_Handler::XStr;
+
+namespace CIAO {
+
+  namespace Config_Handler
+  {
+
+    /**
+     * @class Utils
+     *
+     * @brief Utility class for parsing basic types such as string float
+     * double etc.
+     *
+     * Helper methods for each type are defined as parse_<type> where type
+     * equals string, float, double etc. The corresponding C++ types are
+     * returned. These follow the IDL to C++ mapping defined by the CORBA
+     * specification.
+     *
+     */
+
+    class Config_Handler_Export Utils
+    {
+    public:
+      static char * parse_string (DOMNodeIterator * iter);
+      // Parse string type
+
+      static CORBA::ULong parse_ulong (DOMNodeIterator * iter);
+      // Parse ulong type
+
+      static CORBA::Long parse_long (DOMNodeIterator * iter);
+      // Parse long type
+
+      static CORBA::Short parse_short (DOMNodeIterator * iter);
+      // Parse short type
+
+      static CORBA::Float parse_float (DOMNodeIterator * iter);
+      // Parse float type
+
+      static CORBA::Double parse_double (DOMNodeIterator * iter);
+      // Parse double type
+
+      static CORBA::Boolean parse_bool (DOMNodeIterator * iter);
+      // Parse bool type
+
+      static CORBA::Char parse_char (DOMNodeIterator * iter);
+      // Parse char type
+
+      static CORBA::Octet parse_octet (DOMNodeIterator * iter);
+      // Parse octect type
+
+      static DOMDocument* create_document (const char * url);
+      // Create a document from the URL
+
+      static DOMBuilder* create_parser ();
+      // Create a parser from the URL
+
+      static bool process_string (DOMNodeIterator* iter, const XStr& node_name, 
+                                  const char* name, TAO_String_Manager& var);
+      // process strings
+
+      static bool process_string_seq (DOMNodeIterator* iter, 
+                                      const XStr& node_name, 
+                                      const char* name, CORBA::StringSeq& seq);
+      // process string sequence
+
+      static bool process_boolean (DOMNodeIterator* iter, 
+                                   const XStr& node_name, 
+                                   const char* name, CORBA::Boolean& var);
+      // process strings
+
+      static bool process_ulong (DOMNodeIterator* iter, const XStr& node_name, 
+                                 const char* name, CORBA::ULong& var);
+      // process ulong
+
+
+      static DOMNodeIterator * parse_href_tag (XMLURL xml_url,
+                                               DOMDocument * doc);
+      // Process the <href = "URL"> and return an iterator to the
+      // new document
+    };
+  }
+
+}
+#endif /* UTILS_H */
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XercesString.cpp b/TAO/CIAO/DAnCE/Config_Handlers/XercesString.cpp
new file mode 100644
index 00000000000..7b719e4dc80
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XercesString.cpp
@@ -0,0 +1,145 @@
+// $Id$
+
+#include <ostream>
+
+#include "XercesString.h"
+using xercesc::XMLString;
+
+namespace Config_Handler
+{
+
+  XStr::XStr (const char* str)
+    : _wstr(0)
+  {
+    _wstr = XMLString::transcode(str);
+  }
+
+  XStr::XStr (XMLCh *wstr)
+    : _wstr(wstr)
+  {
+
+  }
+
+  XStr::XStr (const XMLCh* wstr)
+    : _wstr(0)
+  {
+    _wstr = XMLString::replicate(wstr);
+  }
+
+  XStr::XStr (const XStr &right)
+    : _wstr(0)
+  {
+    _wstr = XMLString::replicate(right._wstr);
+  }
+
+  XStr& XStr::operator= (const XStr& rhs)
+  {
+    if (&rhs == this)
+      return *this;
+    XStr temp (rhs);
+    ACE_Swap<XMLCh*>::swap (this->_wstr, temp._wstr);
+    return *this;
+  }
+
+  XStr::~XStr ()
+  {
+    if (_wstr)
+      XMLString::release(&_wstr);
+  }
+
+  const XMLCh* XStr::begin () const
+  {
+    return _wstr;
+  }
+
+  const XMLCh* XStr::end () const
+  {
+    return _wstr + size();
+  }
+
+  bool XStr::append(const XMLCh *tail)
+  {
+    int iTailLen = XMLString::stringLen(tail);
+    int iWorkLen = XMLString::stringLen(_wstr);
+    XMLCh *result = new XMLCh[ iWorkLen + iTailLen + 1 ];
+    bool bOK = result != 0;
+    if (bOK)
+      {
+        XMLCh *target = result;
+        XMLString::moveChars(target, _wstr, iWorkLen);
+        target += iWorkLen;
+        XMLString::moveChars(target, tail, iTailLen);
+        target += iTailLen;
+        *target++ = 0;
+        XMLString::release(&_wstr);
+        _wstr = result;
+      }
+    return bOK;
+  }
+
+  bool XStr::erase(const XMLCh *head, const XMLCh *tail)
+  {
+    bool bOK = head <= tail && head >= begin() && tail <= end();
+    if (bOK)
+      {
+        XMLCh *result = new XMLCh[ size() - (tail - head) + 1 ];
+        XMLCh *target = result;
+        bOK = target != NULL;
+        if (bOK)
+          {
+            const XMLCh *cursor = begin();
+
+            while (cursor != head) *target++ = *cursor++;
+            cursor = tail;
+            while ( cursor != end() ) *target++ = *cursor++;
+            *target ++ = 0;
+            XMLString::release(&_wstr);
+            _wstr = result;
+          }
+      }
+    return bOK;
+  }
+
+  int XStr::size () const
+  {
+    return XMLString::stringLen(_wstr);
+  }
+
+  XMLCh XStr::operator [] (const int i)
+  {
+    return _wstr[i];
+  }
+
+  const XMLCh XStr::operator [] (const int i) const
+  {
+    return _wstr[i];
+  }
+
+  bool XStr::operator== (const XMLCh* wstr) const
+  {
+    return XMLString::compareIString (wstr, this->_wstr) == 0;
+  }
+
+  bool operator== (const XStr& lhs, const XStr& rhs)
+  {
+    return XMLString::compareIString (lhs,rhs) == 0;
+  }
+
+  bool operator!= (const XStr& lhs, const XStr& rhs)
+  {
+    return !operator==(lhs, rhs);
+  }
+
+
+  std::ostream&
+  operator<< (std::ostream& o, XStr const& str)
+  {
+    char* s = XMLString::transcode (str);
+
+    o << s;
+
+    XMLString::release (&s); // idiots?
+    return o;
+  }
+
+}
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XercesString.h b/TAO/CIAO/DAnCE/Config_Handlers/XercesString.h
new file mode 100644
index 00000000000..87ef31c3c2c
--- /dev/null
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XercesString.h
@@ -0,0 +1,76 @@
+// $Id$
+
+#ifndef _XERCESSTRING_H
+#define _XERCESSTRING_H
+
+#include /**/ "ace/pre.h"
+
+#include "ace/Swap.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include <iosfwd>
+
+#include <xercesc/util/XMLString.hpp>
+
+// Utility class that provides a std::string like facade to XMLString.
+// Doesn't implement all of the methods of std::string.
+
+namespace Config_Handler
+{
+
+  class XStr
+  {
+  public:
+    XStr() : _wstr(0L) { };
+
+    XStr (const char* str);
+
+    XStr (XMLCh* wstr);
+
+    XStr (const XMLCh* wstr);
+
+    XStr (const XStr& copy);
+
+    XStr& operator= (const XStr& rhs);
+
+    ~XStr();
+
+    const XMLCh* begin() const;
+
+    const XMLCh* end() const;
+
+    bool append(const XMLCh* tail);
+
+    bool erase(const XMLCh* head, const XMLCh* tail);
+
+    int size() const;
+
+    XMLCh operator [] (const int i);
+
+    const XMLCh operator [] (const int i) const;
+
+    operator const XMLCh* () const { return _wstr; };
+
+    bool operator== (const XMLCh* wstr) const;
+
+
+  private:
+
+    XMLCh* _wstr; // Internal representation
+
+  };
+
+  bool operator== (const XStr& lhs, const XStr& rhs);
+  bool operator!= (const XStr& lhs, const XStr& rhs);
+
+  std::ostream&
+  operator<< (std::ostream& o, XStr const& str);
+  
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* _XERCESSTRING_H */