ChangeLogTag:Fri

24 files changed, 385 insertions, 286 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index 763e4e1bfaf..382276cbae5 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,45 @@
+Fri Sep 14 00:36:43 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/UUID.cpp: Changed the case of the clock_sequence from u_char
+          to ACE_UINT16 to avoid duplicate UUIDs.  Thanks to wim dot van
+          dot den dot boogaard at varianinc dot com for reporting this.
+
+Thu Sep 13 17:57:31 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/Mutex.h: Updated the document for ACE_Mutex to indicate that
+          ACE_Process_Mutex or ACE_Thread_Mutex is preferred.  Thanks to
+          Nathan Glasser <nglasser at cantata dot com>
+
+Tue Sep 11 15:24:43 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * docs/ACE-bug-process.html: Clarified bug fixing policies.  Thanks to
+          Torsten Saliwada <sally at gmx dot net> for motivating this.
+
+Mon Sep  3 18:54:54 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * NEWS: Updated the NEWS file to reflect the recent changes to the UUID class.
+
+Mon Sep  3 14:54:55 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * protocols/ace/HTBP/HTBP_ID_Requestor.cpp (get_HTID): 
+        * tests/UUID_Test.cpp (test): Updated to use the new "ACE-ified"
+          UUDI interface.
+
+Mon Sep  3 12:53:49 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * ace/UUID.{h,inl,cpp}: Converted this code to use ACE programming
+          conventions for naming. 
+
+Mon Sep  3 12:37:44 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * Implemented an accessor to obtain the timestamp and
+          clockSequence in an atomic manner. The clockSequence could
+          change between the moment the timestamp is obtained and the
+          moment the clockSequence is used in a multithreaded environment
+          and that results in duplicate UUIDs.  Thanks to Wim van den
+          Boogaard <wim dot van dot den dot boogaard at varianinc dot com>
+          for contributing this.
+
 Thu Sep 20 18:49:27 UTC 2007  Abdullah Sowayan  <abdullah.sowayan@lmco.com>
 
         * include/makeinclude/platform_g++_common.GNU:
@@ -163,6 +205,7 @@ Thu Sep 20 06:59:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
         * docs/bczar/bczar.html:
           Updated based on the steps of x.6.1
 
+>>>>>>> .r79674
 Wed Sep 19 04:10:15 CDT 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * ACE version 5.6.1 released.
diff --git a/ACE/NEWS b/ACE/NEWS
index a80d3fde461..ce6c8a15556 100644
--- a/ACE/NEWS
+++ b/ACE/NEWS
@@ -5,9 +5,13 @@ PLANNED MAJOR CHANGES "SOMETIME IN THE FUTURE" (i.e., exact beta not known)
 
 . (OO) Various other fixes that have been piling up.
 
-USER VISIBLE CHANGES BETWEEN ACE-5.6 and ACE-5.6.1
+USER VISIBLE CHANGES BETWEEN ACE-5.6.1 and ACE-5.6.2
 ====================================================
 
+. ACE-ified the UUID class, which will change user applications slightly.
+
+USER VISIBLE CHANGES BETWEEN ACE-5.6 and ACE-5.6.1
+
 . Added support for CodeGear RAD Studio 2007
 
 . Added support for CodeGear C++ Builder 2007 Update 3
@@ -17,7 +21,6 @@ USER VISIBLE CHANGES BETWEEN ACE-5.6 and ACE-5.6.1
   page: http://tinyurl.com/2jqcmd
   This fixes bugzilla #2753
 
-
 USER VISIBLE CHANGES BETWEEN ACE-5.5.10 and ACE-5.6
 ====================================================
 
diff --git a/ACE/THANKS b/ACE/THANKS
index edb6e26cbc9..ff29a0b23f9 100644
--- a/ACE/THANKS
+++ b/ACE/THANKS
@@ -1902,7 +1902,7 @@ J. Abelardo Gutierrez <jabelardo at cantv dot net>
 Roger Sala <Roger dot Sala at gd-ais dot com>
 Razi Ben-Yehuda <raziebe at gmail dot com>
 Geo Sebastian <geosebastian at onmobile dot com>
-Simon Massey <simon dot massey at prismtechnologies dot com>
+Simon Massey <sma at prismtech dot com>
 Rich Shapiro <rshapiro at bbn dot com>
 Ramiro Morales <rm0 at gmx dot net>
 Andrew Athan <aathan-ace-bugs-1524 at cloakmail dot com>
@@ -2007,7 +2007,7 @@ Steven T. Hatton <hattons at globalsymmetry dot com>
 Yevgen Galchenko <yevgeng at softcomputer dot com>
 Timothy Wayne Gomez <gomezt at saic dot com>
 Ventimiglia Chere <Ventimiglia_Chere at emc dot com>
-Friedhelm Wolf <friedhelm dot wolf at homag dot de>
+Friedhelm Wolf <fwolf at dre dot vanderbilt dot edu>
 Frederick Heckel <fwph at cse dot wustl dot edu>
 Ian Zagorskih <ianzag at megasignal dot com>
 Olivier Guérin <guerin35 at hotmail dot com>
@@ -2220,6 +2220,9 @@ Norbert Thoden <thoden at rheinmetall-de dot com>
 Premkumar P <kumaran dot prem at gmail dot com>
 David Beck <davidbeck at acm dot org>
 Hayim Shaul <hayim at iportent dot com>
+Erman Balcik <erman dot balcik at siemens dot com>
+Torsten Saliwada <sally at gmx dot net>
+Nathan Glasser <nglasser at cantata dot com>
 
 I would particularly like to thank Paul Stephenson, who worked with me
 at Ericsson in the early 1990's.  Paul devised the recursive Makefile
diff --git a/ACE/ace/Mutex.h b/ACE/ace/Mutex.h
index 2d145f7fe6d..e876a09d3f8 100644
--- a/ACE/ace/Mutex.h
+++ b/ACE/ace/Mutex.h
@@ -43,7 +43,9 @@ class ACE_Time_Value;
  * @class ACE_Mutex
  *
  * @brief @c ACE_Mutex wrapper (valid in same process or across
- *        processes (depending on @a TYPE flag)).
+ *        processes (depending on @a TYPE flag)).  In general,
+ *        however, we recommend using @a ACE_Process_Mutex or @a
+ *        ACE_Thread_Mutex rather than @a ACE_Mutex.
  */
 class ACE_Export ACE_Mutex
 {
diff --git a/ACE/ace/UUID.cpp b/ACE/ace/UUID.cpp
index b285ea62215..495d95be516 100644
--- a/ACE/ace/UUID.cpp
+++ b/ACE/ace/UUID.cpp
@@ -24,75 +24,70 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
 namespace ACE_Utils
 {
-
-  UUID_node::UUID_node (void)
+  UUID_Node::UUID_Node (void)
   {
-    for (int i = 0; i < UUID_node::NODE_ID_SIZE; ++i)
-      {
-        nodeID_[i] = 0;
-      }
+    for (int i = 0; i < UUID_Node::NODE_ID_SIZE; ++i)
+      node_ID_[i] = 0;
   }
 
-  UUID_node::NodeID&
-  UUID_node::nodeID (void)
+  UUID_Node::Node_ID&
+  UUID_Node::node_ID (void)
   {
-    return nodeID_;
+    return node_ID_;
   }
 
   void
-  UUID_node::nodeID (NodeID& nodeID)
+  UUID_Node::node_ID (Node_ID& node_ID)
   {
-    for (int i = 0; i < UUID_node::NODE_ID_SIZE; ++i)
-      {
-        nodeID_[i] = nodeID[i];
-      }
+    for (int i = 0; i < UUID_Node::NODE_ID_SIZE; ++i)
+      node_ID_[i] = node_ID[i];
   }
 
   UUID UUID::NIL_UUID;
 
   /// Construct a nil UUID. Such a UUID has every one of it's data
   /// elements set to zero.
-  UUID::UUID(void)
-    : timeLow_ (0),
-      timeMid_ (0),
-      timeHiAndVersion_ (0),
-      clockSeqHiAndReserved_ (0),
-      clockSeqLow_ (0),
+  UUID::UUID (void)
+    : time_low_ (0),
+      time_mid_ (0),
+      time_hi_and_version_ (0),
+      clock_seq_hi_and_reserved_ (0),
+      clock_seq_low_ (0),
       node_ (0),
       node_release_ (true),
       as_string_ (0)
   {
     ACE_NEW (node_,
-             UUID_node);
+             UUID_Node);
   }
 
   /// Construct a UUID from a string representation of an UUID.
   UUID::UUID (const ACE_CString& uuid_string)
-    : timeLow_ (0),
-      timeMid_ (0),
-      timeHiAndVersion_ (0),
-      clockSeqHiAndReserved_ (0),
-      clockSeqLow_ (0),
+    : time_low_ (0),
+      time_mid_ (0),
+      time_hi_and_version_ (0),
+      clock_seq_hi_and_reserved_ (0),
+      clock_seq_low_ (0),
       node_ (0),
       node_release_ (true),
       as_string_ (0)
   {
     ACE_NEW (node_,
-             UUID_node);
+             UUID_Node);
 
     this->from_string_i (uuid_string);
   }
 
-  UUID::UUID(const UUID &right)
-    : timeLow_ (right.timeLow_),
-      timeMid_ (right.timeMid_),
-      timeHiAndVersion_ (right.timeHiAndVersion_),
-      clockSeqHiAndReserved_ (right.clockSeqHiAndReserved_),
-      clockSeqLow_ (right.clockSeqLow_),
+  UUID::UUID (const UUID &right)
+    : time_low_ (right.time_low_),
+      time_mid_ (right.time_mid_),
+      time_hi_and_version_ (right.time_hi_and_version_),
+      clock_seq_hi_and_reserved_ (right.clock_seq_hi_and_reserved_),
+      clock_seq_low_ (right.clock_seq_low_),
       as_string_ (0)
   {
     ACE_NEW (node_,
-             UUID_node (*right.node_));
+             UUID_Node (*right.node_));
   }
 
   UUID::~UUID (void)
@@ -122,22 +117,22 @@ namespace ACE_Utils
                             char[UUID_STRING_LENGTH + 1],
                             0);
 
-            ACE_OS::sprintf(buf,
-                            "%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x-%s-%s",
-                            this->timeLow_,
-                            this->timeMid_,
-                            this->timeHiAndVersion_,
-                            this->clockSeqHiAndReserved_,
-                            this->clockSeqLow_,
-                            (this->node_->nodeID ()) [0],
-                            (this->node_->nodeID ()) [1],
-                            (this->node_->nodeID ()) [2],
-                            (this->node_->nodeID ()) [3],
-                            (this->node_->nodeID ()) [4],
-                            (this->node_->nodeID ()) [5],
-                            thr_id_.c_str (),
-                            pid_.c_str ()
-                            );
+            ACE_OS::sprintf (buf,
+                             "%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x-%s-%s",
+                             this->time_low_,
+                             this->time_mid_,
+                             this->time_hi_and_version_,
+                             this->clock_seq_hi_and_reserved_,
+                             this->clock_seq_low_,
+                             (this->node_->node_ID ()) [0],
+                             (this->node_->node_ID ()) [1],
+                             (this->node_->node_ID ()) [2],
+                             (this->node_->node_ID ()) [3],
+                             (this->node_->node_ID ()) [4],
+                             (this->node_->node_ID ()) [5],
+                             thr_id_.c_str (),
+                             pid_.c_str ()
+                             );
           }
         else
           {
@@ -147,17 +142,17 @@ namespace ACE_Utils
 
             ACE_OS::sprintf (buf,
                              "%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
-                             this->timeLow_,
-                             this->timeMid_,
-                             this->timeHiAndVersion_,
-                             this->clockSeqHiAndReserved_,
-                             this->clockSeqLow_,
-                             (this->node_->nodeID ()) [0],
-                             (this->node_->nodeID ()) [1],
-                             (this->node_->nodeID ()) [2],
-                             (this->node_->nodeID ()) [3],
-                             (this->node_->nodeID ()) [4],
-                             (this->node_->nodeID ()) [5]
+                             this->time_low_,
+                             this->time_mid_,
+                             this->time_hi_and_version_,
+                             this->clock_seq_hi_and_reserved_,
+                             this->clock_seq_low_,
+                             (this->node_->node_ID ()) [0],
+                             (this->node_->node_ID ()) [1],
+                             (this->node_->node_ID ()) [2],
+                             (this->node_->node_ID ()) [3],
+                             (this->node_->node_ID ()) [4],
+                             (this->node_->node_ID ()) [5]
                              );
           }
 
@@ -171,10 +166,8 @@ namespace ACE_Utils
 
         // then we test that ACE_NEW succeded for 'as_string_'
         // if not, we return 0 (NULL) to indicate failure.
-        if( this->as_string_ == 0 )
-        {
-           return 0;
-        }
+        if (this->as_string_ == 0 )
+          return 0;
       }
 
     return as_string_;
@@ -183,11 +176,11 @@ namespace ACE_Utils
   void
   UUID::from_string_i (const ACE_CString& uuid_string)
   {
-    if (uuid_string.length() < NIL_UUID.to_string ()->length ())
+    if (uuid_string.length () < NIL_UUID.to_string ()->length ())
       {
         ACE_ERROR ((LM_ERROR,
                     "%N ACE_UUID::from_string_i - "
-                    "IllegalArgument(incorrect string length)\n"));
+                    "IllegalArgument (incorrect string length)\n"));
         return;
       }
 
@@ -201,15 +194,15 @@ namespace ACE_Utils
         return;
       }
 
-    unsigned int timeLow;
-    unsigned int timeMid;
-    unsigned int timeHiAndVersion;
-    unsigned int clockSeqHiAndReserved;
-    unsigned int clockSeqLow;
-    unsigned int node [UUID_node::NODE_ID_SIZE];
+    unsigned int time_low;
+    unsigned int time_mid;
+    unsigned int time_hi_and_version;
+    unsigned int clock_seq_hi_and_reserved;
+    unsigned int clock_seq_low;
+    unsigned int node [UUID_Node::NODE_ID_SIZE];
     char thr_pid_buf [BUFSIZ];
 
-    if (uuid_string.length() == NIL_UUID.to_string()->length())
+    if (uuid_string.length () == NIL_UUID.to_string ()->length ())
       {
         // This might seem quite strange this being in ACE, but it
         // seems to be a bit difficult to write a facade for ::sscanf
@@ -220,15 +213,15 @@ namespace ACE_Utils
 #if defined (ACE_HAS_TR24731_2005_CRT)
           sscanf_s (
 #else
-          ::sscanf(
-#endif
-                   uuid_string.c_str(),
+          ::sscanf (
+#endif /* ACE_HAS_TR24731_2005_CRT */
+                   uuid_string.c_str (),
                    "%8x-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x",
-                   &timeLow,
-                   &timeMid,
-                   &timeHiAndVersion,
-                   &clockSeqHiAndReserved,
-                   &clockSeqLow,
+                   &time_low,
+                   &time_mid,
+                   &time_hi_and_version,
+                   &clock_seq_hi_and_reserved,
+                   &clock_seq_low,
                    &node[0],
                    &node[1],
                    &node[2],
@@ -241,7 +234,7 @@ namespace ACE_Utils
           {
             ACE_DEBUG ((LM_DEBUG,
                         "UUID::from_string_i - "
-                        "IllegalArgument(invalid string representation)\n"));
+                        "IllegalArgument (invalid string representation)\n"));
             return;
           }
       }
@@ -249,13 +242,13 @@ namespace ACE_Utils
       {
         const int nScanned =
 #if defined (ACE_HAS_TR24731_2005_CRT)
-          sscanf_s (uuid_string.c_str(),
+          sscanf_s (uuid_string.c_str (),
                     "%8x-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x-%s",
-                    &timeLow,
-                    &timeMid,
-                    &timeHiAndVersion,
-                    &clockSeqHiAndReserved,
-                    &clockSeqLow,
+                    &time_low,
+                    &time_mid,
+                    &time_hi_and_version,
+                    &clock_seq_hi_and_reserved,
+                    &clock_seq_low,
                     &node[0],
                     &node[1],
                     &node[2],
@@ -266,13 +259,13 @@ namespace ACE_Utils
                     BUFSIZ
                     );
 #else
-          ::sscanf (uuid_string.c_str(),
+          ::sscanf (uuid_string.c_str (),
                     "%8x-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x-%s",
-                    &timeLow,
-                    &timeMid,
-                    &timeHiAndVersion,
-                    &clockSeqHiAndReserved,
-                    &clockSeqLow,
+                    &time_low,
+                    &time_mid,
+                    &time_hi_and_version,
+                    &clock_seq_hi_and_reserved,
+                    &clock_seq_low,
                     &node[0],
                     &node[1],
                     &node[2],
@@ -287,47 +280,48 @@ namespace ACE_Utils
           {
             ACE_DEBUG ((LM_DEBUG,
                         "ACE_UUID::from_string_i - "
-                        "IllegalArgument(invalid string representation)\n"));
+                        "IllegalArgument (invalid string representation)\n"));
             return;
           }
       }
 
-    this->timeLow_ = static_cast<ACE_UINT32> (timeLow);
-    this->timeMid_ = static_cast<ACE_UINT16> (timeMid);
-    this->timeHiAndVersion_ = static_cast<ACE_UINT16> (timeHiAndVersion);
-    this->clockSeqHiAndReserved_ = static_cast<u_char> (clockSeqHiAndReserved);
-    this->clockSeqLow_ = static_cast<u_char> (clockSeqLow);
+    this->time_low_ = static_cast<ACE_UINT32> (time_low);
+    this->time_mid_ = static_cast<ACE_UINT16> (time_mid);
+    this->time_hi_and_version_ = static_cast<ACE_UINT16> (time_hi_and_version);
+    this->clock_seq_hi_and_reserved_ = static_cast<u_char> (clock_seq_hi_and_reserved);
+    this->clock_seq_low_ = static_cast<u_char> (clock_seq_low);
 
-    UUID_node::NodeID nodeID;
-    for (int i = 0; i < UUID_node::NODE_ID_SIZE; ++i)
-      nodeID [i] = static_cast<u_char> (node[i]);
+    UUID_Node::Node_ID node_id;
+    for (int i = 0; i < UUID_Node::NODE_ID_SIZE; ++i)
+      node_id [i] = static_cast<u_char> (node[i]);
 
-    this->node_->nodeID (nodeID);
+    this->node_->node_ID (node_id);
 
     // Support varient 10- only
-    if ((this->clockSeqHiAndReserved_ & 0xc0) != 0x80 && (this->clockSeqHiAndReserved_ & 0xc0) != 0xc0)
+    if ((this->clock_seq_hi_and_reserved_ & 0xc0) != 0x80 && (this->clock_seq_hi_and_reserved_ & 0xc0) != 0xc0)
       {
         ACE_DEBUG ((LM_DEBUG,
                     "ACE_UUID::from_string_i - "
-                    "IllegalArgument(unsupported variant)\n"));
+                    "IllegalArgument (unsupported variant)\n"));
         return;
       }
 
     /// Support versions 1, 3, and 4 only
-    ACE_UINT16 V1 = this->timeHiAndVersion_;
+    ACE_UINT16 V1 = this->time_hi_and_version_;
 
     if ((V1 & 0xF000) != 0x1000 &&
         (V1 & 0xF000) != 0x3000 &&
-      (V1 & 0xF000) != 0x4000)
+        (V1 & 0xF000) != 0x4000)
       {
         ACE_DEBUG ((LM_DEBUG,
                     "ACE_UUID::from_string_i - "
-                    "IllegalArgument(unsupported version)\n"));
+                    "IllegalArgument (unsupported version)\n"));
         return;
       }
-    if ((this->clockSeqHiAndReserved_ & 0xc0) == 0xc0)
+
+    if ((this->clock_seq_hi_and_reserved_ & 0xc0) == 0xc0)
       {
-        if (uuid_string.length() == NIL_UUID.to_string()->length())
+        if (uuid_string.length () == NIL_UUID.to_string ()->length ())
           {
             ACE_DEBUG ((LM_DEBUG,
                       "ACE_UUID::from_string_i - "
@@ -347,14 +341,14 @@ namespace ACE_Utils
   }
 
   UUID_Generator::UUID_Generator ()
-    : timeLast_ (0),
+    : time_last_ (0),
       destroy_lock_ (true)
   {
     ACE_NEW (lock_,
              ACE_SYNCH_MUTEX);
   }
 
-  UUID_Generator::~UUID_Generator()
+  UUID_Generator::~UUID_Generator ()
   {
     if (destroy_lock_)
       delete lock_;
@@ -366,7 +360,7 @@ namespace ACE_Utils
     ACE_OS::macaddr_node_t macaddress;
     int result = ACE_OS::getmacaddress (&macaddress);
 
-    UUID_node::NodeID nodeID;
+    UUID_Node::Node_ID node_id;
     if (result != -1)
       {
 //         ACE_DEBUG ((LM_DEBUG,
@@ -378,104 +372,125 @@ namespace ACE_Utils
 //                     macaddress.node [4],
 //                     macaddress.node [5]));
 
-        ACE_OS::memcpy (&nodeID,
+        ACE_OS::memcpy (&node_id,
                         macaddress.node,
-                        sizeof (nodeID));
+                        sizeof (node_id));
       }
     else
       {
-        nodeID [0] = static_cast<u_char> (ACE_OS::rand());
-        nodeID [1] = static_cast<u_char> (ACE_OS::rand());
-        nodeID [2] = static_cast<u_char> (ACE_OS::rand());
-        nodeID [3] = static_cast<u_char> (ACE_OS::rand());
-        nodeID [4] = static_cast<u_char> (ACE_OS::rand());
-        nodeID [5] = static_cast<u_char> (ACE_OS::rand());
+        node_id [0] = static_cast<u_char> (ACE_OS::rand ());
+        node_id [1] = static_cast<u_char> (ACE_OS::rand ());
+        node_id [2] = static_cast<u_char> (ACE_OS::rand ());
+        node_id [3] = static_cast<u_char> (ACE_OS::rand ());
+        node_id [4] = static_cast<u_char> (ACE_OS::rand ());
+        node_id [5] = static_cast<u_char> (ACE_OS::rand ());
       }
 
-    this->get_timestamp (timeLast_);
+    this->get_timestamp (time_last_);
 
     {
       ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, *lock_);
-      uuid_state_.timestamp = timeLast_;
-      uuid_state_.node.nodeID (nodeID);
+      uuid_state_.timestamp = time_last_;
+      uuid_state_.node.node_ID (node_id);
     }
   }
 
-
   void
-  UUID_Generator::generateUUID (UUID& uuid,ACE_UINT16 version, u_char variant)
+  UUID_Generator::generate_UUID (UUID& uuid,ACE_UINT16 version,
+                                u_char variant)
   {
-    UUID_time timestamp;
-    this->get_timestamp (timestamp);
+    UUID_Time timestamp;
+    ACE_UINT16 clock_sequence;
 
+    this->get_timestamp_and_clocksequence (timestamp,
+                                           clock_sequence);
 
     // Construct a Version 1 UUID with the information in the arguements.
-    uuid.timeLow (static_cast<ACE_UINT32> (timestamp & 0xFFFFFFFF));
-    uuid.timeMid (static_cast<ACE_UINT16> ((timestamp >> 32) & 0xFFFF));
-
+    uuid.time_low (static_cast<ACE_UINT32> (timestamp & 0xFFFFFFFF));
+    uuid.time_mid (static_cast<ACE_UINT16> ((timestamp >> 32) & 0xFFFF));
 
     ACE_UINT16 tHAV = static_cast<ACE_UINT16> ((timestamp >> 48) & 0xFFFF);
     tHAV |= (version << 12);
-    uuid.timeHiAndVersion (tHAV);
+    uuid.time_hi_and_version (tHAV);
 
     u_char cseqHAV;
-    {
-      ACE_GUARD (ACE_SYNCH_MUTEX, mon, *lock_);
-      uuid.clockSeqLow (static_cast<u_char> (uuid_state_.clockSequence & 0xFF));
-      cseqHAV = static_cast<u_char> ((uuid_state_.clockSequence & 0x3f00) >> 8);
-      uuid_state_.timestamp = timestamp;
-    }
+    uuid.clock_seq_low (static_cast<u_char> (clock_sequence & 0xFF));
+    cseqHAV = static_cast<u_char> ((clock_sequence & 0x3f00) >> 8);
+    uuid_state_.timestamp = timestamp;
 
     cseqHAV |= variant;
-    uuid.clockSeqHiAndReserved (cseqHAV);
-    uuid.node (&(uuid_state_.node));
+    uuid.clock_seq_hi_and_reserved (cseqHAV);
+    uuid.node (& (uuid_state_.node));
 
     if (variant == 0xc0)
-    {
-      ACE_Thread_ID thread_id;
-      char buf [BUFSIZ];
-      thread_id.to_string (buf);
-      uuid.thr_id (buf);
-
-      ACE_OS::sprintf (buf,
-                       "%d",
-                       static_cast<int> (ACE_OS::getpid ()));
-      uuid.pid (buf);
-    }
+      {
+        ACE_Thread_ID thread_id;
+        char buf [BUFSIZ];
+        thread_id.to_string (buf);
+        uuid.thr_id (buf);
+
+        ACE_OS::sprintf (buf,
+                         "%d",
+                         static_cast<int> (ACE_OS::getpid ()));
+        uuid.pid (buf);
+      }
   }
 
   UUID*
-  UUID_Generator::generateUUID (ACE_UINT16 version, u_char variant)
+  UUID_Generator::generate_UUID (ACE_UINT16 version, u_char variant)
   {
     UUID* uuid;
     ACE_NEW_RETURN (uuid,
                     UUID,
                     0);
 
-    this->generateUUID (*uuid, version, variant);
+    this->generate_UUID (*uuid, version, variant);
     return uuid;
   }
 
   /// Obtain a new timestamp. If UUID's are being generated too quickly
   /// the clock sequence will be incremented
   void
-  UUID_Generator::get_timestamp (UUID_time& timestamp)
+  UUID_Generator::get_timestamp (UUID_Time& timestamp)
+  {
+    ACE_GUARD (ACE_SYNCH_MUTEX, mon, *lock_);
+
+    this->get_systemtime (timestamp);
+
+    // Account for the clock being set back. Increment the clock /
+    // sequence.
+    if (timestamp <= time_last_)
+      uuid_state_.clockSequence = static_cast<ACE_UINT16> 
+        ((uuid_state_.clockSequence + 1) & ACE_UUID_CLOCK_SEQ_MASK);
+
+    // If the system time ticked since the last UUID was
+    // generated. Set / the clock sequence back.
+    else if (timestamp > time_last_)
+      uuid_state_.clock_sequence = 0;
+
+    time_last_ = timestamp;
+  }
+
+  void
+  UUID_Generator::get_timestamp_and_clocksequence (UUID_Time& timestamp,
+                                                   ACE_UINT16& clock_sequence)
   {
     ACE_GUARD (ACE_SYNCH_MUTEX, mon, *lock_);
 
-    this->get_systemtime(timestamp);
+    this->get_systemtime (timestamp);
 
     // Account for the clock being set back. Increment the clock /
     // sequence.
-    if (timestamp <= timeLast_)
-      uuid_state_.clockSequence = static_cast<u_char> ((uuid_state_.clockSequence + 1) & ACE_UUID_CLOCK_SEQ_MASK);
+    if (timestamp <= time_last_)
+      uuid_state_.clock_sequence = static_cast<u_char> ((uuid_state_.clock_sequence + 1) & ACE_UUID_CLOCK_SEQ_MASK);
 
     // If the system time ticked since the last UUID was
     // generated. Set / the clock sequence back.
-    else if (timestamp > timeLast_)
-      uuid_state_.clockSequence = 0;
+    else if (timestamp > time_last_)
+      uuid_state_.clock_sequence = 0;
 
-    timeLast_ = timestamp;
+    time_last_ = timestamp;
+    clock_sequence = uuid_state_.clock_sequence;
   }
 
   /**
@@ -486,13 +501,13 @@ namespace ACE_Utils
    *   1 Jan 1600 - 1 Jan 1900: 3 centuries + 73 leap days ( 25 in 17th cent.
    *       and 24 each in 18th and 19th centuries)
    *   1 Jan 1900 - 1 Jan 1970: 70 years + 17 leap days.
-   * This adds up, in days: (17+30+31+365*17+4)+(365*300+73)+(365*70+17) or
+   * This adds up, in days: (17+30+31+365*17+4)+ (365*300+73)+ (365*70+17) or
    * 122192928000000000U (0x1B21DD213814000) 100 ns ticks.
    */
   void
-  UUID_Generator::get_systemtime (UUID_time & timestamp)
+  UUID_Generator::get_systemtime (UUID_Time & timestamp)
   {
-    const UUID_time timeOffset =
+    const UUID_Time timeOffset =
 #if defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
       ACE_U_LongLong (ACE_INT64_LITERAL (0x1B21DD213814000));
 #elif defined (ACE_LACKS_LONGLONG_T)
@@ -502,7 +517,7 @@ namespace ACE_Utils
 #endif  /* ACE_LACKS_UNSIGNEDLONGLONG_T */
 
     /// Get the time of day, convert to 100ns ticks then add the offset.
-    ACE_Time_Value now = ACE_OS::gettimeofday();
+    ACE_Time_Value now = ACE_OS::gettimeofday ();
     ACE_UINT64 time;
     now.to_usec (time);
     time = time * 10;
diff --git a/ACE/ace/UUID.h b/ACE/ace/UUID.h
index f94ffeafc71..5be6a4c065a 100644
--- a/ACE/ace/UUID.h
+++ b/ACE/ace/UUID.h
@@ -30,32 +30,30 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 namespace ACE_Utils
 {
   /// Class to hold a MAC address
-  class ACE_Export UUID_node
+  class ACE_Export UUID_Node
   {
   public:
 
     /// Constructor
-    UUID_node (void);
+    UUID_Node (void);
 
     enum {NODE_ID_SIZE = 6};
-    typedef u_char NodeID[NODE_ID_SIZE];
+    typedef u_char Node_ID[NODE_ID_SIZE];
 
-    NodeID& nodeID (void);
-    void nodeID (NodeID&);
+    Node_ID &node_ID (void);
+    void node_ID (Node_ID&);
 
     ///// Equality Operations
-    bool operator == (const UUID_node& right) const;
-    bool operator != (const UUID_node& right) const;
+    bool operator == (const UUID_Node& right) const;
+    bool operator != (const UUID_Node& right) const;
 
     ///// Relational Operations
-    //bool operator <  (const UUID_node& right) const;
+    //bool operator <  (const UUID_Node& right) const;
 
   private:
-    NodeID nodeID_;
+    Node_ID node_ID_;
   };
 
-
-
   /**
    *  @class ACE_UUID
    *
@@ -89,23 +87,23 @@ namespace ACE_Utils
     // Destructor
     ~UUID (void);
 
-    ACE_UINT32 timeLow (void) const;
-    void timeLow (ACE_UINT32);
+    ACE_UINT32 time_low (void) const;
+    void time_low (ACE_UINT32);
 
-    ACE_UINT16 timeMid (void) const;
-    void timeMid (ACE_UINT16);
+    ACE_UINT16 time_mid (void) const;
+    void time_mid (ACE_UINT16);
 
-    ACE_UINT16 timeHiAndVersion (void) const;
-    void timeHiAndVersion (ACE_UINT16);
+    ACE_UINT16 time_hi_and_version (void) const;
+    void time_hi_and_version (ACE_UINT16);
 
-    u_char clockSeqHiAndReserved (void) const;
-    void clockSeqHiAndReserved (u_char);
+    u_char clock_seq_hi_and_reserved (void) const;
+    void clock_seq_hi_and_reserved (u_char);
 
-    u_char clockSeqLow (void) const;
-    void clockSeqLow (u_char);
+    u_char clock_seq_low (void) const;
+    void clock_seq_low (u_char);
 
-    UUID_node* node (void) const;
-    void node (UUID_node*);
+    UUID_Node* node (void) const;
+    void node (UUID_Node*);
 
     ACE_CString* thr_id (void);
     void thr_id (char*);
@@ -132,17 +130,17 @@ namespace ACE_Utils
     //bool operator>= (const UUID &right) const;
 
   private:
-    void from_string_i (const ACE_CString& uuidString);
+    void from_string_i (const ACE_CString& uuid_string);
 
     UUID& operator= (const UUID&);
 
     /// Data Members for Class Attributes
-    ACE_UINT32 timeLow_;
-    ACE_UINT16 timeMid_;
-    ACE_UINT16 timeHiAndVersion_;
-    u_char clockSeqHiAndReserved_;
-    u_char clockSeqLow_;
-    UUID_node* node_;
+    ACE_UINT32 time_low_;
+    ACE_UINT16 time_mid_;
+    ACE_UINT16 time_hi_and_version_;
+    u_char clock_seq_hi_and_reserved_;
+    u_char clock_seq_low_;
+    UUID_Node* node_;
     bool node_release_;
     ACE_CString thr_id_;
     ACE_CString pid_;
@@ -152,7 +150,6 @@ namespace ACE_Utils
     ACE_CString *as_string_;
   };
 
-
   /**
    * @class ACE_UUID_Generator
    *
@@ -173,15 +170,15 @@ namespace ACE_Utils
     /// Format timestamp, clockseq, and nodeID into an UUID of the
     /// specified version and variant. For generating UUID's with
     /// thread and process ids use variant=0xc0
-    void generateUUID (UUID&, ACE_UINT16 version=0x0001, u_char variant=0x80);
+    void generate_UUID (UUID&, ACE_UINT16 version=0x0001, u_char variant=0x80);
 
     /// Format timestamp, clockseq, and nodeID into a VI UUID. For
     /// generating UUID's with thread and process ids use variant=0xc0
-    UUID* generateUUID (ACE_UINT16 version=0x0001, u_char variant=0x80);
+    UUID* generate_UUID (ACE_UINT16 version=0x0001, u_char variant=0x80);
 
     /// Type to represent UTC as a count of 100 nanosecond intervals
     /// since 00:00:00.00, 15 October 1582.
-    typedef ACE_UINT64 UUID_time;
+    typedef ACE_UINT64 UUID_Time;
 
     /// The locking strategy prevents multiple generators from accessing
     /// the UUID_state at the same time. Get the locking strategy.
@@ -194,25 +191,31 @@ namespace ACE_Utils
   private:
 
     /// The system time when that last uuid was generated.
-    UUID_time timeLast_;
+    UUID_Time time_last_;
 
     /// Type to contain the UUID generator persistent state. This will
     /// be kept in memory mapped shared memory
     struct UUID_State
     {
-      UUID_time timestamp;
-      UUID_node node;
-      ACE_UINT16 clockSequence;
+      UUID_Time timestamp;
+      UUID_Node node;
+      ACE_UINT16 clock_sequence;
     };
 
     /// Obtain a UUID timestamp. Compensate for the fact that the time
     /// obtained from getSystem time has a resolution less than 100ns.
-  void get_timestamp (UUID_time& timestamp);
+    void get_timestamp (UUID_Time& timestamp);
+
+    /// Obtain a UUID timestamp and clock sequence. Compensate for the
+    /// fact that the time obtained from getSystem time has a
+    /// resolution less than 100ns.
+    void get_timestamp_and_clocksequence (UUID_Time& timestamp, 
+                                          ACE_UINT16& clockSequence);
 
     /// Obtain the system time in UTC as a count of 100 nanosecond intervals
     /// since 00:00:00.00, 15 October 1582 (the date of Gregorian reform to
   /// the Christian calendar).
-    void get_systemtime( UUID_time& timeNow);
+    void get_systemtime( UUID_Time& timeNow);
 
     /// The UUID generator persistent state.
     UUID_State uuid_state_;
@@ -233,3 +236,4 @@ ACE_END_VERSIONED_NAMESPACE_DECL
 
 #include /**/ "ace/post.h"
 #endif // ACE_UUID_H
+
diff --git a/ACE/ace/UUID.inl b/ACE/ace/UUID.inl
index 39c68364b75..89526473b0a 100644
--- a/ACE/ace/UUID.inl
+++ b/ACE/ace/UUID.inl
@@ -9,73 +9,73 @@ namespace ACE_Utils
 
   /// Data Members for Class Attributes
   ACE_INLINE ACE_UINT32
-  UUID::timeLow (void) const
+  UUID::time_low (void) const
   {
-    return this->timeLow_;
+    return this->time_low_;
   }
 
   ACE_INLINE void
-  UUID::timeLow (ACE_UINT32 timelow)
+  UUID::time_low (ACE_UINT32 timelow)
   {
-    this->timeLow_ = timelow;
+    this->time_low_ = timelow;
   }
 
   ACE_INLINE ACE_UINT16
-  UUID::timeMid (void) const
+  UUID::time_mid (void) const
   {
-    return this->timeMid_;
+    return this->time_mid_;
   }
 
   ACE_INLINE void
-  UUID::timeMid (ACE_UINT16 time_mid)
+  UUID::time_mid (ACE_UINT16 time_mid)
   {
-    this->timeMid_ = time_mid;
+    this->time_mid_ = time_mid;
   }
 
   ACE_INLINE ACE_UINT16
-  UUID::timeHiAndVersion (void) const
+  UUID::time_hi_and_version (void) const
   {
-    return this->timeHiAndVersion_;
+    return this->time_hi_and_version_;
   }
 
   ACE_INLINE void
-  UUID::timeHiAndVersion (ACE_UINT16 timeHiAndVersion)
+  UUID::time_hi_and_version (ACE_UINT16 time_hi_and_version)
   {
-    this->timeHiAndVersion_ = timeHiAndVersion;
+    this->time_hi_and_version_ = time_hi_and_version;
   }
 
   ACE_INLINE u_char
-  UUID::clockSeqHiAndReserved (void) const
+  UUID::clock_seq_hi_and_reserved (void) const
   {
-    return this->clockSeqHiAndReserved_;
+    return this->clock_seq_hi_and_reserved_;
   }
 
   ACE_INLINE void
-  UUID::clockSeqHiAndReserved (u_char clockSeqHiAndReserved)
+  UUID::clock_seq_hi_and_reserved (u_char clock_seq_hi_and_reserved)
   {
-    this->clockSeqHiAndReserved_ = clockSeqHiAndReserved;
+    this->clock_seq_hi_and_reserved_ = clock_seq_hi_and_reserved;
   }
 
   ACE_INLINE u_char
-  UUID::clockSeqLow (void) const
+  UUID::clock_seq_low (void) const
   {
-    return this->clockSeqLow_;
+    return this->clock_seq_low_;
   }
 
   ACE_INLINE void
-  UUID::clockSeqLow (u_char clockSeqLow)
+  UUID::clock_seq_low (u_char clock_seq_low)
   {
-    this->clockSeqLow_ = clockSeqLow;
+    this->clock_seq_low_ = clock_seq_low;
   }
 
-  ACE_INLINE UUID_node*
+  ACE_INLINE UUID_Node*
   UUID::node (void) const
   {
     return this->node_;
   }
 
   ACE_INLINE void
-  UUID::node (UUID_node* node)
+  UUID::node (UUID_Node* node)
   {
     if (node_release_)
       delete node_;
@@ -117,15 +117,13 @@ namespace ACE_Utils
   ACE_INLINE bool
   UUID::operator == (const UUID &right) const
   {
-    if ((this->timeLow_ != right.timeLow ()) ||
-        (this->timeMid_ != right.timeMid ()) ||
-        (this->timeHiAndVersion_ != right.timeHiAndVersion ()) ||
-        (this->clockSeqHiAndReserved_ != right.clockSeqHiAndReserved ()) ||
-        (this->clockSeqLow_ != right.clockSeqLow ()) ||
+    if ((this->time_low_ != right.time_low ()) ||
+        (this->time_mid_ != right.time_mid ()) ||
+        (this->time_hi_and_version_ != right.time_hi_and_version ()) ||
+        (this->clock_seq_hi_and_reserved_ != right.clock_seq_hi_and_reserved ()) ||
+        (this->clock_seq_low_ != right.clock_seq_low ()) ||
         (*this->node_ != *right.node ()))
-      {
-        return false;
-      }
+      return false;
 
       return true;
   }
@@ -172,20 +170,17 @@ namespace ACE_Utils
 //  }
 //
   ACE_INLINE bool
-  UUID_node::operator == (const UUID_node& rt) const
+  UUID_Node::operator == (const UUID_Node& rt) const
   {
     for (size_t i = 0; i < NODE_ID_SIZE; ++i)
-    {
-      if (nodeID_ [i] != rt.nodeID_ [i])
-        {
-          return false;
-        }
-    }
+      if (node_ID_ [i] != rt.node_ID_ [i])
+        return false;
+
     return true;
   }
 
   ACE_INLINE bool
-  UUID_node::operator != (const UUID_node& right) const
+  UUID_Node::operator != (const UUID_Node& right) const
   {
     return !(*this == right);
   }
diff --git a/ACE/docs/ACE-bug-process.html b/ACE/docs/ACE-bug-process.html
index 60a78541bdb..41ca26b6417 100644
--- a/ACE/docs/ACE-bug-process.html
+++ b/ACE/docs/ACE-bug-process.html
@@ -30,6 +30,9 @@ HREF="http://www.cs.wustl.edu/~schmidt/commercial-support.html">commercial
 support companies</A> who have deep knowledge of how ACE, TAO, and
 CIAO work and can help provide bug fixes and new features. <P>
 
+<HR>
+<H3>Process for Reporting a Bug</H3>
+
 To ensure the continued growth and maturation of ACE, TAO, and CIAO,
 and to allow the user and vendor communities to evolve, please make it
 a point to abide by the following policies:
@@ -137,10 +140,13 @@ support</A>.<P>
 
 </UL>
 
-Naturally, we encourage other ACE, TAO, and CIAO users to continue to
-help provide fixes and advice in response to postings on the mailing
-lists and newsgroup.  If you have a patch that fixes a problem you've
-found with our software here's the process for submitting it:
+<HR>
+<H3>Process for Submitting a Bug Fix</H3>
+
+We encourage other ACE, TAO, and CIAO users to continue to help
+provide fixes and advice in response to postings on the mailing lists
+and newsgroup.  If you have a patch that fixes a problem you've found
+with our software here's the process for submitting it:
 
 <OL>
 <LI> Use the latest contents of subversion CVS repository, i.e.,
diff --git a/ACE/protocols/ace/HTBP/HTBP_ID_Requestor.cpp b/ACE/protocols/ace/HTBP/HTBP_ID_Requestor.cpp
index 0f400522143..a048a295459 100644
--- a/ACE/protocols/ace/HTBP/HTBP_ID_Requestor.cpp
+++ b/ACE/protocols/ace/HTBP/HTBP_ID_Requestor.cpp
@@ -114,7 +114,7 @@ ACE::HTBP::ID_Requestor::get_HTID ()
       this->send_request (&cli_stream) == -1)
     {
       ACE_Utils::UUID_Generator gen;
-      ACE_Utils::UUID *uuid = gen.generateUUID ();
+      ACE_Utils::UUID *uuid = gen.generate_UUID ();
       const ACE_CString *uuidstr = uuid->to_string();
       ACE::HTBP::ID_Requestor::htid_ = ACE_TEXT_CHAR_TO_TCHAR (uuidstr->c_str());
       delete uuid;
diff --git a/ACE/tests/UUIDTest.cpp b/ACE/tests/UUID_Test.cpp
index e1800c6bc5d..734825f1739 100644
--- a/ACE/tests/UUIDTest.cpp
+++ b/ACE/tests/UUID_Test.cpp
@@ -1,10 +1,24 @@
 // $Id$
 
-// Test the ACE UUID class which generates unique id's
-
+// ============================================================================
+//
+// = LIBRARY
+//    tests
+//
+// = FILENAME
+//    UUID_Test.cpp
+//
+// = DESCRIPTION
+//    Test the ACE UUID class which generates unique id's
+//
+// = AUTHOR
+ *   Andrew T. Finnel <andrew@activesol.net> and
+ *   Yamuna Krishnmaurthy <yamuna@oomworks.com>
+// ============================================================================
 
 #include "test_config.h"
 #include "ace/UUID.h"
+#include "ace/Auto_Ptr.h"
 
 class Tester
 {
@@ -28,12 +42,11 @@ Tester::test (void)
   int retval = 0;
 
   // Generate UUID
-  ACE_Utils::UUID* uuid = ACE_Utils::UUID_GENERATOR::instance ()->generateUUID ();
+  auto_ptr <ACE_Utils::UUID> uuid (ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID ());
   ACE_CString uuid_str (uuid->to_string ()->c_str ());
   ACE_DEBUG ((LM_DEBUG,
               "Generated UUID\n %s\n",
               uuid_str.c_str ()));
-  delete uuid;
 
   // Construct UUID from string
   ACE_Utils::UUID new_uuid (uuid_str);
@@ -67,8 +80,8 @@ Tester::test (void)
     }
 
   // Generate UUID with process and thread ids.
-  ACE_Utils::UUID* uuid_with_tp_id =
-    ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (0x0001, 0xc0);
+  auto_ptr <ACE_Utils::UUID> uuid_with_tp_id (ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (0x0001,
+                                                                                                     0xc0));
   ACE_DEBUG ((LM_DEBUG,
               "UUID with Thread and Process ID\n %s\n",
               uuid_with_tp_id->to_string ()->c_str ()));
@@ -84,8 +97,6 @@ Tester::test (void)
   ACE_DEBUG ((LM_DEBUG,
               "UUID with Thread and Process ID reconstructed from above UUID \n %s\n",
               new_uuid_with_tp_id.to_string ()->c_str ()));
-  delete uuid_with_tp_id;
-
 
   return retval;
 }
@@ -98,26 +109,21 @@ int run_main(int, ACE_TCHAR* [])
 
   if (tester.init () == -1)
     {
-
       ACE_DEBUG((LM_DEBUG,
                  "UUIDTest: Tester::init failed\n"));
       return -1;
     }
 
-  int testRetValue = tester.test();
+  int result = tester.test();
 
-  if (testRetValue == 0)
-    {
-      ACE_DEBUG((LM_DEBUG,
-                 "UUIDTest succeeded\n"));
-    }
+  if (result == 0)
+    ACE_DEBUG((LM_DEBUG,
+               "UUIDTest succeeded\n"));
   else
-    {
-      ACE_DEBUG((LM_DEBUG,
-                 "UUIDTest failed\n"));
-    }
+    ACE_DEBUG((LM_DEBUG,
+               "UUIDTest failed\n"));
 
   ACE_END_TEST;
 
-  return testRetValue;
+  return result;
 }
diff --git a/CIAO/ChangeLog b/CIAO/ChangeLog
index 5e23d1a9054..a98179b36d3 100644
--- a/CIAO/ChangeLog
+++ b/CIAO/ChangeLog
@@ -1,3 +1,12 @@
+Mon Sep  3 14:49:07 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * tools/Config_Handlers/IDD_Handler.cpp (CIAO): 
+        * tools/Config_Handlers/IDD_Handler.cpp (CIAO): 
+        * tools/Config_Handlers/ADD_Handler.cpp (CIAO): 
+        * tools/Config_Handlers/MDD_Handler.cpp (CIAO): Changed
+          generateUUID() to generate_UUID() to match new ACE-ification of
+          the UUDI class.
+  
 Wed Sep 19 04:10:15 CDT 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
 
 	* CIAO version 0.6.1 released.
diff --git a/CIAO/tools/Config_Handlers/ADD_Handler.cpp b/CIAO/tools/Config_Handlers/ADD_Handler.cpp
index 095fcb21dee..103c764f819 100644
--- a/CIAO/tools/Config_Handlers/ADD_Handler.cpp
+++ b/CIAO/tools/Config_Handlers/ADD_Handler.cpp
@@ -161,7 +161,7 @@ namespace CIAO
 
         // Generate a UUID to use for the IDREF.
         ACE_Utils::UUID uuid;
-        ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+        ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
         ACE_CString add_id ("_");
         add_id += *uuid.to_string ();
 
diff --git a/CIAO/tools/Config_Handlers/IDD_Handler.cpp b/CIAO/tools/Config_Handlers/IDD_Handler.cpp
index 9fe9ebc974f..4940a93ebac 100644
--- a/CIAO/tools/Config_Handlers/IDD_Handler.cpp
+++ b/CIAO/tools/Config_Handlers/IDD_Handler.cpp
@@ -137,7 +137,7 @@ namespace CIAO
 
       // Generate a UUID to use for the IDREF.
       ACE_Utils::UUID uuid;
-      ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+      ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
       ACE_CString idd_id ("_");
       idd_id += *uuid.to_string ();
 
diff --git a/CIAO/tools/Config_Handlers/MDD_Handler.cpp b/CIAO/tools/Config_Handlers/MDD_Handler.cpp
index b0c5f7cfe94..4c710dec3ad 100644
--- a/CIAO/tools/Config_Handlers/MDD_Handler.cpp
+++ b/CIAO/tools/Config_Handlers/MDD_Handler.cpp
@@ -158,7 +158,7 @@ namespace CIAO
 
       // Generate a UUID to use for the IDREF.
       ACE_Utils::UUID uuid;
-      ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+      ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
       ACE_CString mdd_id ("_");
       mdd_id += *uuid.to_string ();
 
diff --git a/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp b/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp
index c89325ed467..2c1443d7be7 100644
--- a/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp
+++ b/CIAO/tools/Config_Handlers/Package_Handlers/SID_Handler.cpp
@@ -123,7 +123,7 @@ namespace CIAO
 
         // @@MAJO This is not a good way of binding reverse IDREFS.
         std::auto_ptr <ACE_Utils::UUID> safe_uuid (
-          ACE_Utils::UUID_GENERATOR::instance ()->generateUUID ());
+          ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID ());
         ACE_CString uuid ( safe_uuid->to_string ()->c_str ());
 
         //        ACE_ERROR ((LM_ERROR, "*** Binding to %s\n",
diff --git a/TAO/ChangeLog b/TAO/ChangeLog
index e5d5500b0fb..58bb659d204 100644
--- a/TAO/ChangeLog
+++ b/TAO/ChangeLog
@@ -1,3 +1,16 @@
+Mon Sep  3 14:34:39 UTC 2007  Douglas C. Schmidt  <schmidt@dre.vanderbilt.edu>
+
+        * orbsvcs/examples/FaultTolerance/RolyPoly/ReplicaController.cpp (ReplicaController): 
+        * orbsvcs/examples/LoadBalancing/RPS_Monitor.cpp (RPS_Monitor): 
+        * orbsvcs/examples/Notify/Federation/Gate/Gate.cpp (init): 
+        * orbsvcs/performance-tests/LoadBalancing/LBPerf/RPS/RPS_Monitor.cpp (RPS_Monitor): 
+        * orbsvcs/orbsvcs/FaultTolerance/FT_ClientRequest_Interceptor.cpp (TAO): 
+        * docs/tutorials/Quoter/RTCORBA/Distributor_i.cpp (subscribe_notifier): 
+        * docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp: Chan
+        * tao/Strategies/COIOP_Acceptor.cpp (TAO_COIOP_Acceptor): Changed
+          generateUUID() to generate_UUID() to match new ACE-ification of
+          the UUDI class.
+
 Thu Sep 20 09:35:15 UTC 2007  Johnny Willemsen  <jwillemsen@remedy.nl>
 
         * tao/Objref_VarOut_T.inl:
diff --git a/TAO/docs/tutorials/Quoter/RTCORBA/Distributor_i.cpp b/TAO/docs/tutorials/Quoter/RTCORBA/Distributor_i.cpp
index 997ab026d84..96ea1189624 100644
--- a/TAO/docs/tutorials/Quoter/RTCORBA/Distributor_i.cpp
+++ b/TAO/docs/tutorials/Quoter/RTCORBA/Distributor_i.cpp
@@ -43,7 +43,7 @@ StockDistributor_i::subscribe_notifier (::Stock::StockNameConsumer_ptr c,
 
   // Generate a unique id for the cookie.
   ACE_Utils::UUID uuid;
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 
   // Create a new cookie object; initialize its value.
   Stock::Cookie_var cookie = new OBV_Stock::Cookie ();
diff --git a/TAO/docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp b/TAO/docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp
index 6ceeae1da4f..7b019efa254 100644
--- a/TAO/docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp
+++ b/TAO/docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp
@@ -100,7 +100,7 @@ typename Stock_Database<CALLBACK>::Cookie
 Stock_Database<CALLBACK>::register_callback (CALLBACK &obj)
 {
   ACE_Utils::UUID uuid;
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
   
   this->callbacks_[uuid.to_string ()->c_str ()] = &obj;
   
diff --git a/TAO/orbsvcs/examples/FaultTolerance/RolyPoly/ReplicaController.cpp b/TAO/orbsvcs/examples/FaultTolerance/RolyPoly/ReplicaController.cpp
index 45db3e629d0..7193caa6fbf 100644
--- a/TAO/orbsvcs/examples/FaultTolerance/RolyPoly/ReplicaController.cpp
+++ b/TAO/orbsvcs/examples/FaultTolerance/RolyPoly/ReplicaController.cpp
@@ -104,7 +104,7 @@ ReplicaController (CORBA::ORB_ptr orb)
   // Generate member id
   ACE_Utils::UUID uuid;
   ACE_Utils::UUID_GENERATOR::instance ()->init ();
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 
   ACE_INET_Addr address (10000, "239.255.0.1");
 
diff --git a/TAO/orbsvcs/examples/LoadBalancing/RPS_Monitor.cpp b/TAO/orbsvcs/examples/LoadBalancing/RPS_Monitor.cpp
index cd24d5f5852..834a34cb8bd 100644
--- a/TAO/orbsvcs/examples/LoadBalancing/RPS_Monitor.cpp
+++ b/TAO/orbsvcs/examples/LoadBalancing/RPS_Monitor.cpp
@@ -20,7 +20,7 @@ RPS_Monitor::RPS_Monitor (ServerRequestInterceptor * interceptor)
   ACE_Utils::UUID_GENERATOR::instance ()->init ();
 
   ACE_Utils::UUID uuid;
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 
   this->location_[0].id = CORBA::string_dup (uuid.to_string ()->c_str ());
   this->location_[0].kind = CORBA::string_dup ("UUID");
diff --git a/TAO/orbsvcs/examples/Notify/Federation/Gate/Gate.cpp b/TAO/orbsvcs/examples/Notify/Federation/Gate/Gate.cpp
index cdaa34334b8..26fda764b86 100644
--- a/TAO/orbsvcs/examples/Notify/Federation/Gate/Gate.cpp
+++ b/TAO/orbsvcs/examples/Notify/Federation/Gate/Gate.cpp
@@ -58,7 +58,7 @@ init (ConsumerAdmin_ptr consumer_admin,
   //
   ACE_Utils::UUID uuid;
   ACE_Utils::UUID_GENERATOR::instance ()->init ();
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 
   id_ = string_alloc (ACE_Utils::truncate_cast<CORBA::ULong> (
                         uuid.to_string ()->length () + 2));
diff --git a/TAO/orbsvcs/orbsvcs/FaultTolerance/FT_ClientRequest_Interceptor.cpp b/TAO/orbsvcs/orbsvcs/FaultTolerance/FT_ClientRequest_Interceptor.cpp
index 3b3a119794c..6d8c87e0ec5 100644
--- a/TAO/orbsvcs/orbsvcs/FaultTolerance/FT_ClientRequest_Interceptor.cpp
+++ b/TAO/orbsvcs/orbsvcs/FaultTolerance/FT_ClientRequest_Interceptor.cpp
@@ -33,7 +33,7 @@ namespace TAO
     ACE_Utils::UUID_GENERATOR::instance ()->init ();
 
     this->uuid_ =
-      ACE_Utils::UUID_GENERATOR::instance ()->generateUUID ();
+      ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID ();
 
     // Would be nice to have runtime option.
     ACE_NEW (this->lock_,
diff --git a/TAO/orbsvcs/performance-tests/LoadBalancing/LBPerf/RPS/RPS_Monitor.cpp b/TAO/orbsvcs/performance-tests/LoadBalancing/LBPerf/RPS/RPS_Monitor.cpp
index ac374cc840a..c09321b0d7b 100644
--- a/TAO/orbsvcs/performance-tests/LoadBalancing/LBPerf/RPS/RPS_Monitor.cpp
+++ b/TAO/orbsvcs/performance-tests/LoadBalancing/LBPerf/RPS/RPS_Monitor.cpp
@@ -19,7 +19,7 @@ RPS_Monitor::RPS_Monitor (ServerRequestInterceptor * interceptor)
   ACE_Utils::UUID_GENERATOR::instance ()->init ();
 
   ACE_Utils::UUID uuid;
-  ACE_Utils::UUID_GENERATOR::instance ()->generateUUID (uuid);
+  ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 
   this->location_[0].id = CORBA::string_dup (uuid.to_string ()->c_str ());
   this->location_[0].kind = CORBA::string_dup ("UUID");
diff --git a/TAO/tao/Strategies/COIOP_Acceptor.cpp b/TAO/tao/Strategies/COIOP_Acceptor.cpp
index 2d01aa8b8ca..bea8f4e2a54 100644
--- a/TAO/tao/Strategies/COIOP_Acceptor.cpp
+++ b/TAO/tao/Strategies/COIOP_Acceptor.cpp
@@ -24,7 +24,7 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 TAO_COIOP_Acceptor::TAO_COIOP_Acceptor (void)
   : TAO_Acceptor (TAO_TAG_COIOP_PROFILE),
-    uuid_ (*ACE_Utils::UUID_GENERATOR::instance ()->generateUUID ()),
+    uuid_ (*ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID ()),
     version_ (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR),
     orb_core_ (0)
 {