Make the constructors taking a pthread_rwlock_t * private.

This is to avoid re-introducing code using the unwrapped pthread_rwlock_t's.
While there, reorganize the classes to make the order more natural.

diff --git a/pdns/lock.hh b/pdns/lock.hh
index e3a1e1b57a373b4150f99199dd19b110f4097178..5cbc4404d7dc05ede533b1d529b00839cf28fb2d 100644 (file)
--- a/pdns/lock.hh
+++ b/pdns/lock.hh
@@ -52,24 +52,46 @@ private:
   pthread_rwlock_t d_lock;
 };
 
-class WriteLock
+class ReadLock
 {
-  pthread_rwlock_t *d_lock;
 public:
+  ReadLock(ReadWriteLock& lock): ReadLock(lock.getLock())
+  {
+  }
 
-  WriteLock(pthread_rwlock_t *lock) : d_lock(lock)
+  ReadLock(ReadWriteLock* lock): ReadLock(lock->getLock())
   {
-    int err;
-    if((err = pthread_rwlock_wrlock(d_lock))) {
-      throw PDNSException("error acquiring rwlock wrlock: "+stringerror(err));
-    }
   }
-  ~WriteLock()
+
+  ~ReadLock()
   {
-    if(d_lock) // might have been moved
+    if(d_lock) // may have been moved
       pthread_rwlock_unlock(d_lock);
   }
 
+  ReadLock(ReadLock&& rhs)
+  {
+    d_lock = rhs.d_lock;
+    rhs.d_lock = nullptr;
+  }
+  ReadLock(const ReadLock& rhs) = delete;
+  ReadLock& operator=(const ReadLock& rhs) = delete;
+
+private:
+  ReadLock(pthread_rwlock_t *lock) : d_lock(lock)
+  {
+    int err;
+    if((err = pthread_rwlock_rdlock(d_lock))) {
+      throw PDNSException("error acquiring rwlock readlock: "+stringerror(err));
+    }
+  }
+
+ pthread_rwlock_t *d_lock;
+};
+
+class WriteLock
+{
+public:
   WriteLock(ReadWriteLock& lock): WriteLock(lock.getLock())
   {
   }
@@ -83,30 +105,40 @@ public:
     d_lock = rhs.d_lock;
     rhs.d_lock=0;
   }
+
+  ~WriteLock()
+  {
+    if(d_lock) // might have been moved
+      pthread_rwlock_unlock(d_lock);
+  }
+
   WriteLock(const WriteLock& rhs) = delete;
   WriteLock& operator=(const WriteLock& rhs) = delete;
 
+private:
+  WriteLock(pthread_rwlock_t *lock) : d_lock(lock)
+  {
+    int err;
+    if((err = pthread_rwlock_wrlock(d_lock))) {
+      throw PDNSException("error acquiring rwlock wrlock: "+stringerror(err));
+    }
+  }
+
+  pthread_rwlock_t *d_lock;
 };
 
-class TryWriteLock
+class TryReadLock
 {
-  pthread_rwlock_t *d_lock;
-  bool d_havelock;
 public:
-  TryWriteLock(const TryWriteLock& rhs) = delete;
-  TryWriteLock& operator=(const TryWriteLock& rhs) = delete;
+  TryReadLock(ReadWriteLock& lock): TryReadLock(lock.getLock())
+  {
+  }
 
-  TryWriteLock(pthread_rwlock_t *lock) : d_lock(lock)
+  TryReadLock(ReadWriteLock* lock): TryReadLock(lock->getLock())
   {
-    d_havelock=false;
-    int err;
-    if((err = pthread_rwlock_trywrlock(d_lock)) && err!=EBUSY) {
-      throw PDNSException("error acquiring rwlock tryrwlock: "+stringerror(err));
-    }
-    d_havelock=(err==0);
   }
 
-  TryWriteLock(TryWriteLock&& rhs)
+  TryReadLock(TryReadLock&& rhs)
   {
     d_lock = rhs.d_lock;
     rhs.d_lock = nullptr;
@@ -114,33 +146,21 @@ public:
     rhs.d_havelock = false;
   }
 
-  TryWriteLock(ReadWriteLock& lock): TryWriteLock(lock.getLock())
+  ~TryReadLock()
   {
+    if(d_havelock && d_lock)
+      pthread_rwlock_unlock(d_lock);
   }
 
-  TryWriteLock(ReadWriteLock* lock): TryWriteLock(lock->getLock())
-  {
-  }
+  TryReadLock(const TryReadLock& rhs) = delete;
+  TryReadLock& operator=(const TryReadLock& rhs) = delete;
 
-  ~TryWriteLock()
-  {
-    if(d_havelock && d_lock) // we might be moved
-      pthread_rwlock_unlock(d_lock);
-  }
   bool gotIt()
   {
     return d_havelock;
   }
-};
-
-class TryReadLock
-{
-  pthread_rwlock_t *d_lock;
-  bool d_havelock;
-public:
-  TryReadLock(const TryReadLock& rhs) = delete;
-  TryReadLock& operator=(const TryReadLock& rhs) = delete;
 
+private:
   TryReadLock(pthread_rwlock_t *lock) : d_lock(lock)
   {
     int err;
@@ -150,15 +170,22 @@ public:
     d_havelock=(err==0);
   }
 
-  TryReadLock(ReadWriteLock& lock): TryReadLock(lock.getLock())
+  pthread_rwlock_t *d_lock;
+  bool d_havelock;
+};
+
+class TryWriteLock
+{
+public:
+  TryWriteLock(ReadWriteLock& lock): TryWriteLock(lock.getLock())
   {
   }
 
-  TryReadLock(ReadWriteLock* lock): TryReadLock(lock->getLock())
+  TryWriteLock(ReadWriteLock* lock): TryWriteLock(lock->getLock())
   {
   }
 
-  TryReadLock(TryReadLock&& rhs)
+  TryWriteLock(TryWriteLock&& rhs)
   {
     d_lock = rhs.d_lock;
     rhs.d_lock = nullptr;
@@ -166,50 +193,32 @@ public:
     rhs.d_havelock = false;
   }
 
-  ~TryReadLock()
+  ~TryWriteLock()
   {
-    if(d_havelock && d_lock)
+    if(d_havelock && d_lock) // we might be moved
       pthread_rwlock_unlock(d_lock);
   }
+
+  TryWriteLock(const TryWriteLock& rhs) = delete;
+  TryWriteLock& operator=(const TryWriteLock& rhs) = delete;
+
   bool gotIt()
   {
     return d_havelock;
   }
-};
-
-
-class ReadLock
-{
-  pthread_rwlock_t *d_lock;
-public:
 
-  ReadLock(pthread_rwlock_t *lock) : d_lock(lock)
+private:
+  TryWriteLock(pthread_rwlock_t *lock) : d_lock(lock)
   {
+    d_havelock=false;
     int err;
-    if((err = pthread_rwlock_rdlock(d_lock))) {
-      throw PDNSException("error acquiring rwlock readlock: "+stringerror(err));
+    if((err = pthread_rwlock_trywrlock(d_lock)) && err!=EBUSY) {
+      throw PDNSException("error acquiring rwlock tryrwlock: "+stringerror(err));
     }
+    d_havelock=(err==0);
   }
 
-  ReadLock(ReadWriteLock& lock): ReadLock(lock.getLock())
-  {
-  }
-
-  ReadLock(ReadWriteLock* lock): ReadLock(lock->getLock())
-  {
-  }
-
-  ~ReadLock()
-  {
-    if(d_lock) // may have been moved
-      pthread_rwlock_unlock(d_lock);
-  }
-
-  ReadLock(ReadLock&& rhs)
-  {
-    d_lock = rhs.d_lock;
-    rhs.d_lock = nullptr;
-  }
-  ReadLock(const ReadLock& rhs) = delete;
-  ReadLock& operator=(const ReadLock& rhs) = delete;
+  pthread_rwlock_t *d_lock;
+  bool d_havelock;
 };
+