*** empty log message ***

1 files changed, 71 insertions, 50 deletions

diff --git a/TAO/orbsvcs/orbsvcs/Concurrency/CC_Lock.cpp b/TAO/orbsvcs/orbsvcs/Concurrency/CC_Lock.cpp
index 4438cc8e668..29f505adc00 100644
--- a/TAO/orbsvcs/orbsvcs/Concurrency/CC_Lock.cpp
+++ b/TAO/orbsvcs/orbsvcs/Concurrency/CC_Lock.cpp
@@ -11,7 +11,7 @@
 //
 // = DESCRIPTION
 //      This class implements a lock used by the lock set from the
-//      concurrency control service
+//      concurrency control service.
 //
 // = AUTHORS
 //    Torben Worm <tworm@cs.wustl.edu>
@@ -21,86 +21,110 @@
 #include "CC_Lock.h"
 #include "tao/corba.h"
 
-CC_Lock::CC_Lock(CosConcurrencyControl::lock_mode mode)
-  : mode_ (mode), lock_held_ (0)
+CC_Lock::CC_Lock (CosConcurrencyControl::lock_mode mode)
+  : mode_ (mode),
+    lock_held_ (0)
 {
 }
 
-CC_Lock::~CC_Lock()
+CC_Lock::~CC_Lock (void)
 {
 }
 
-void CC_Lock::lock(CORBA::Environment &_env)
+void 
+CC_Lock::lock (CORBA::Environment &env)
 {
-  ACE_DEBUG((LM_DEBUG, "CC_Lock::lock\n"));
+  ACE_DEBUG ((LM_DEBUG,
+              "CC_Lock::lock\n"));
   lock_held_++;
-  int success = semaphore_.acquire();
-  if(success==-1) {
-    TAO_THROW(CORBA::INTERNAL(CORBA::COMPLETED_NO));
-  }
+
+  if (semaphore_.acquire () == -1)
+    TAO_THROW (CORBA::INTERNAL (CORBA::COMPLETED_NO));
 }
 
-CORBA::Boolean CC_Lock::try_lock(CORBA::Environment &_env)
+CORBA::Boolean 
+CC_Lock::try_lock (CORBA::Environment &env)
 {
-  ACE_DEBUG((LM_DEBUG, "CC_Lock::try_lock. "));
+  ACE_DEBUG ((LM_DEBUG,
+              "CC_Lock::try_lock. "));
+
   lock_held_++;
-  ACE_DEBUG((LM_DEBUG, "lock_held_: %i, ", lock_held_));
-  int success = semaphore_.tryacquire();
-  ACE_DEBUG((LM_DEBUG, "success: %i\n", success));
-  if(success==-1) {
-    if(errno==EBUSY) {
-      lock_held_--;
-      return CORBA::B_FALSE;
+
+  ACE_DEBUG ((LM_DEBUG,
+              "lock_held_: %i, ",
+              lock_held_));
+
+  int success = semaphore_.tryacquire ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              "success: %i\n", success));
+
+  if (success == -1) 
+    {
+      if (errno == EBUSY) 
+        {
+          lock_held_--;
+          return CORBA::B_FALSE;
+        }
+      else
+        TAO_THROW_RETURN (CORBA::INTERNAL (CORBA::COMPLETED_NO),
+                          CORBA::B_FALSE);
     }
-    else
-      TAO_THROW_RETURN(CORBA::INTERNAL(CORBA::COMPLETED_NO), CORBA::B_FALSE);
-  }
-  //  else {
-  //    this->lock(_env);
-  //  }
 }
 
-void CC_Lock::unlock(CORBA::Environment &_env)
+void 
+CC_Lock::unlock (CORBA::Environment &env)
 {
-  ACE_DEBUG((LM_DEBUG, "CC_Lock::unlock\n"));
-  if(lock_held_==0)
-    TAO_THROW(CosConcurrencyControl::LockNotHeld);
-  int success = semaphore_.release();
-  if(success==-1) {
-    TAO_THROW(CORBA::INTERNAL(CORBA::COMPLETED_NO));
-  }
+  ACE_DEBUG ((LM_DEBUG,
+              "CC_Lock::unlock\n"));
+  if (lock_held_ == 0)
+    TAO_THROW (CosConcurrencyControl::LockNotHeld);
+
+  int success = semaphore_.release ();
+
+  if (success == -1) 
+    TAO_THROW (CORBA::INTERNAL (CORBA::COMPLETED_NO));
+
   lock_held_--;
 }
 
-void CC_Lock::change_mode(CosConcurrencyControl::lock_mode new_mode,
-                          CORBA::Environment &_env)
+void 
+CC_Lock::change_mode (CosConcurrencyControl::lock_mode new_mode,
+                      CORBA::Environment &env)
 {
-  ACE_DEBUG((LM_DEBUG, "CC_Lock::change_mode\n"));
-  // @@TAO Hmmm, we cannot really do anything at present since there is
-  // only one lock per lock set and that lock is essentially a write lock
-  if(lock_held_==0)
-    TAO_THROW(CosConcurrencyControl::LockNotHeld);
+  ACE_DEBUG ((LM_DEBUG,
+              "CC_Lock::change_mode\n"));
+
+  // @@TAO Hmmm, we cannot really do anything at present since there
+  // is only one lock per lock set and that lock is essentially a
+  // write lock
+
+  if (lock_held_ == 0)
+    TAO_THROW (CosConcurrencyControl::LockNotHeld);
+
   this->mode_ = new_mode;
 }
   
-CORBA::Boolean CC_Lock::Compatible(const CC_Lock &other)
+CORBA::Boolean CC_Lock::Compatible (const CC_Lock &other)
 {
-  return this->Compatible(other.mode_);
+  return this->Compatible (other.mode_);
 }
 
-CORBA::Boolean CC_Lock::Compatible(CosConcurrencyControl::lock_mode mode)
+CORBA::Boolean CC_Lock::Compatible (CosConcurrencyControl::lock_mode mode)
 {
   return compatible_[this->mode_][mode];
 }
 
-CosConcurrencyControl::lock_mode CC_Lock::GetMode(void)
+CosConcurrencyControl::lock_mode CC_Lock::GetMode (void)
 {
   return mode_;
 }
 
-// The check of compatibility is a hard coded table statically allocated
-// This table must be changed if the number of lock modes or their
-// compatibility are changed. 5 = number of lock modes
+// The check of compatibility is a hard coded table statically
+// allocated.  This table must be changed if the number of lock modes
+// or their compatibility are changed. 5 = number of lock modes
+// @@ Torben, also please make sure to use an enum here, as well!
+
 CORBA::Boolean CC_Lock::compatible_[5][5] ={
   {CORBA::B_TRUE, CORBA::B_TRUE, CORBA::B_TRUE, CORBA::B_TRUE, CORBA::B_FALSE},
   {CORBA::B_TRUE, CORBA::B_TRUE, CORBA::B_TRUE, CORBA::B_FALSE, CORBA::B_FALSE},
@@ -108,6 +132,3 @@ CORBA::Boolean CC_Lock::compatible_[5][5] ={
   {CORBA::B_TRUE, CORBA::B_FALSE, CORBA::B_FALSE, CORBA::B_FALSE, CORBA::B_TRUE},
   {CORBA::B_FALSE, CORBA::B_FALSE, CORBA::B_FALSE, CORBA::B_FALSE, CORBA::B_FALSE}};
 
-//#if defined (__ACE_INLINE__)
-//#include "CC_Lock.i"
-//#endif // defined INLINE