Thu Jul 1 11:06:42 2004 Jaiganesh B <jai@dre.vanderbilt.edu>

5 files changed, 244 insertions, 220 deletions

diff --git a/TAO/CIAO/ChangeLog b/TAO/CIAO/ChangeLog
index a2213c7eedc..44ee2d19666 100644
--- a/TAO/CIAO/ChangeLog
+++ b/TAO/CIAO/ChangeLog
@@ -1,3 +1,19 @@
+Thu Jul  1 11:06:42 2004  Jaiganesh B  <jai@dre.vanderbilt.edu>
+
+        * DnC/Config_Handlers/Process_Element_T.cpp:
+        * DnC/Config_Handlers/Process_Element_T.h:
+
+          Added the files to follow ACE coding standards.
+
+        * DnC/Config_Handlers/Process_Element.tpp:
+        * DnC/Config_Handlers/Process_Element.i:
+
+          Removed these files, as they were not following the
+          ACE standards.
+
+          The code in the above files have been moved to
+          Process_Element_T.cpp and Process_Element_T.h.
+
 Thu Jul  1 10:56:28 2004  Tao Lu  <lu@dre.vanderbilt.edu>
 
 	* docs/releasenotes/index.html:
diff --git a/TAO/CIAO/DnC/Config_Handlers/Process_Element.h b/TAO/CIAO/DnC/Config_Handlers/Process_Element.h
index a68631ef99c..c60c1e14b75 100644
--- a/TAO/CIAO/DnC/Config_Handlers/Process_Element.h
+++ b/TAO/CIAO/DnC/Config_Handlers/Process_Element.h
@@ -5,6 +5,7 @@
  *  $Id$
  *
  *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ *          Jaiganesh Balasubramanian  <jai@dre.vanderbilt.edu>
  */
 //=====================================================================
 
@@ -65,7 +66,8 @@ 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 {
+class Process_Function 
+{
 public:
   virtual void call(DOMDocument*, DOMNodeIterator*, DATA&)=0;
 
@@ -80,7 +82,8 @@ public:
  */
 
 template <typename OBJ, typename DATA>
-class Process_Member_Function: public Process_Function<DATA> {
+class Process_Member_Function: public Process_Function<DATA> 
+{
 public:
   typedef void (OBJ::*func_type) (DOMNodeIterator*, DATA&);
   typedef DATA data_type;
@@ -108,11 +111,13 @@ private:
 };
 
 /*
- *  Wrapper class for the process member functions which does not have DOMNodeIterator parameter
+ *  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> {
+class Process_Member_Function_Remote: public Process_Function<DATA> 
+{
 public:
   typedef void (OBJ::*func_type) (DATA&);
   typedef DATA data_type;
@@ -144,7 +149,8 @@ private:
  */
 
 template <typename DATA>
-class Process_Static_Function: public Process_Function<DATA> {
+class Process_Static_Function: public Process_Function<DATA> 
+{
 public:
   typedef void (*func_type) (DOMNodeIterator*, DATA&);
   typedef DATA data_type;
@@ -163,29 +169,6 @@ private:
   func_type f_;
 };
 
-// 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);
-
 // Processes reference sequences
 bool
 process_reference_seq (DOMNode* node,
@@ -202,43 +185,8 @@ process_reference (DOMNode* node,
                    int& index,
                    IDREF_MAP& idref_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);
-
 END_DEPLOYMENT_NAMESPACE
 
-#if defined (__ACE_INLINE__)
-#include "Process_Element.i"
-#endif /* __ACE_INLINE__ */
-
-#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
-#include "Process_Element.tpp"
-#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
-
-#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
-#pragma implementation ("Process_Element.tpp")
-#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+#include "Process_Element_T.h"
 
 #endif // PROCESS_ELEMENT_H
diff --git a/TAO/CIAO/DnC/Config_Handlers/Process_Element.i b/TAO/CIAO/DnC/Config_Handlers/Process_Element.i
deleted file mode 100644
index 38271138e2f..00000000000
--- a/TAO/CIAO/DnC/Config_Handlers/Process_Element.i
+++ /dev/null
@@ -1,151 +0,0 @@
-// -*-C++-*-
-//=====================================================================
-/**
- *  @file Process_Element.i
- *
- *  $Id$
- *
- *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
- */
-//=====================================================================
-
-#include "Process_Element.h"
-
-BEGIN_DEPLOYMENT_NAMESPACE
-
-/*
- *  Process function for member functions - id_map: obj->id_map()
- */
-
-template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
-ACE_INLINE 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;
-}
-
-/*
- *  Process function for member functions -
- */
-
-template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
-ACE_INLINE 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;
-}
-
-/*
- *  Process function for static functions
- */
-
-template<typename DATA, typename SEQUENCE, typename FUNCTION>
-ACE_INLINE 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;
-}
-
-/*
- *  Process function for non-sequential elements
- */
-
-template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
-ACE_INLINE 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;
-}
-
-// Process function for non-sequential non-local elements
-template<typename DATA, typename OBJECT, typename ELEMENT, typename FUNCTION>
-ACE_INLINE 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;
-}
-
-END_DEPLOYMENT_NAMESPACE
diff --git a/TAO/CIAO/DnC/Config_Handlers/Process_Element.tpp b/TAO/CIAO/DnC/Config_Handlers/Process_Element_T.cpp
index 4d349e7850b..486574da240 100644
--- a/TAO/CIAO/DnC/Config_Handlers/Process_Element.tpp
+++ b/TAO/CIAO/DnC/Config_Handlers/Process_Element_T.cpp
@@ -1,26 +1,147 @@
 //=====================================================================
 /**
- *  @file Process_Element.tpp
+ *  @file Process_Element_T.cpp
  *
  *  $Id$
  *
  *  @author Emre Turkay  <turkaye@dre.vanderbilt.edu>
+ *          Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu>
  */
 //=====================================================================
 
-#include "Process_Element.h"
+#include "Process_Element_T.h"
 #include "Config_Handlers/Config_Error_Handler.h"
 #include "ace/Auto_Ptr.h"
 #include "Utils.h"
 #include <iostream>
 #include <memory>
-#if !defined (__ACE_INLINE__)
-#include "Process_Element.i"
-#endif /* __ACE_INLINE__ */
+
 BEGIN_DEPLOYMENT_NAMESPACE
 
 class parser_error { };
 
+template<typename DATA, typename OBJECT, typename SEQUENCE, typename FUNCTION>
+ACE_INLINE 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>
+ACE_INLINE 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>
+ACE_INLINE 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>
+ACE_INLINE 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>
+ACE_INLINE 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,
diff --git a/TAO/CIAO/DnC/Config_Handlers/Process_Element_T.h b/TAO/CIAO/DnC/Config_Handlers/Process_Element_T.h
new file mode 100644
index 00000000000..693f0338a47
--- /dev/null
+++ b/TAO/CIAO/DnC/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