diff options
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. @@ -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) { |