1 files changed, 32 insertions, 32 deletions

diff --git a/dep/include/zthread/Semaphore.h b/dep/include/zthread/Semaphore.h
index 2a9e4d02d03..b01c77804ba 100644
--- a/dep/include/zthread/Semaphore.h
+++ b/dep/include/zthread/Semaphore.h
@@ -27,16 +27,16 @@
 #include "zthread/NonCopyable.h"
 
 namespace ZThread {
-  
+
   class FifoSemaphoreImpl;
- 
+
   /**
    * @class Semaphore
    * @author Eric Crahen <http://www.code-foo.com>
    * @date <2003-07-16T15:28:01-0400>
    * @version 2.2.1
    *
-   * A Semaphore is an owner-less Lockable object. Its probably best described as 
+   * A Semaphore is an owner-less Lockable object. Its probably best described as
    * a set of 'permits'. A Semaphore is initialized with an initial count and
    * a maximum count, these would correspond to the number of 'permits' currently
    * available and the number of' permits' in total.
@@ -44,28 +44,28 @@ namespace ZThread {
    * - Acquiring the Semaphore means taking a permit, but if there are none
    *   (the count is 0) the Semaphore will block the calling thread.
    *
-   * - Releasing the Semaphore means returning a permit, unblocking a thread 
+   * - Releasing the Semaphore means returning a permit, unblocking a thread
    *   waiting for one.
    *
-   * A Semaphore with an initial value of 1 and maximum value of 1 will act as 
+   * A Semaphore with an initial value of 1 and maximum value of 1 will act as
    * a Mutex.
    *
    * Threads blocked on a Semaphore are resumed in FIFO order.
    *
    */
   class ZTHREAD_API Semaphore : public Lockable, private NonCopyable {
-  
+
     FifoSemaphoreImpl* _impl;
-  
+
   public:
-  
+
     /**
-     * Create a new Semaphore. 
+     * Create a new Semaphore.
      *
      * @param count initial count
      * @param maxCount maximum count
      */
-    Semaphore(int count = 1, unsigned int maxCount = 1); 
+    Semaphore(int count = 1, unsigned int maxCount = 1);
 
     //! Destroy the Semaphore
     virtual ~Semaphore();
@@ -74,8 +74,8 @@ namespace ZThread {
      * <i>Provided to reflect the traditional Semaphore semantics</i>
      *
      * @see acquire()
-     */ 
-    void wait(); 
+     */
+    void wait();
 
 
     /**
@@ -83,52 +83,52 @@ namespace ZThread {
      *
      * @see tryAcquire(unsigned long timeout)
      */
-    bool tryWait(unsigned long timeout); 
+    bool tryWait(unsigned long timeout);
 
     /**
      * <i>Provided to reflect the traditional Semaphore semantics</i>
      *
      * @see release()
      */
-    void post(); 
+    void post();
+
 
-  
     /**
-     * Get the current count of the semaphore. 
+     * Get the current count of the semaphore.
      *
      * This value may change immediately after this function returns to the calling thread.
      *
      * @return <em>int</em> count
      */
-    virtual int count(); 
+    virtual int count();
 
     /**
-     * Decrement the count, blocking that calling thread if the count becomes 0 or 
-     * less than 0. The calling thread will remain blocked until the count is 
+     * Decrement the count, blocking that calling thread if the count becomes 0 or
+     * less than 0. The calling thread will remain blocked until the count is
      * raised above 0, an exception is thrown or the given amount of time expires.
-     * 
+     *
      * @param timeout maximum amount of time (milliseconds) this method could block
-     * 
-     * @return 
+     *
+     * @return
      *   - <em>true</em> if the Semaphore was acquired before <i>timeout</i> milliseconds elapse.
      *   - <em>false</em> otherwise.
      *
      * @exception Interrupted_Exception thrown when the calling thread is interrupted.
      *            A thread may be interrupted at any time, prematurely ending any wait.
-     * 
+     *
      * @see Lockable::tryAcquire(unsigned long timeout)
      */
-    virtual bool tryAcquire(unsigned long timeout); 
- 
+    virtual bool tryAcquire(unsigned long timeout);
+
 
     /**
-     * Decrement the count, blocking that calling thread if the count becomes 0 or 
-     * less than 0. The calling thread will remain blocked until the count is 
+     * Decrement the count, blocking that calling thread if the count becomes 0 or
+     * less than 0. The calling thread will remain blocked until the count is
      * raised above 0 or if an exception is thrown.
-     * 
+     *
      * @exception Interrupted_Exception thrown when the calling thread is interrupted.
      *            A thread may be interrupted at any time, prematurely ending any wait.
-     * 
+     *
      * @see Lockable::acquire()
      */
     virtual void acquire();
@@ -137,12 +137,12 @@ namespace ZThread {
      * Increment the count, unblocking one thread if count is positive.
      *
      * @exception InvalidOp_Exception thrown if the maximum count would be exceeded.
-     * 
+     *
      * @see Lockable::release()
      */
     virtual void release();
-  
-  }; 
+
+  };
 
 
 } // namespace ZThread