Removed redundant spaces

[libcds.git] / cds / intrusive / tsigas_cycle_queue.h

diff --git a/cds/intrusive/tsigas_cycle_queue.h b/cds/intrusive/tsigas_cycle_queue.h
index b667f39cab32d5dff070eeddea2f3cc65878d596..550762762c2256579a470b800ef81a46e33e8500 100644 (file)
--- a/cds/intrusive/tsigas_cycle_queue.h
+++ b/cds/intrusive/tsigas_cycle_queue.h
@@ -5,7 +5,7 @@
 
     Source code repo: http://github.com/khizmax/libcds/
     Download: http://sourceforge.net/projects/libcds/files/
-    
+
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
 
@@ -25,7 +25,7 @@
     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #ifndef CDSLIB_INTRUSIVE_TSIGAS_CYCLE_QUEUE_H
@@ -269,24 +269,24 @@ namespace cds { namespace intrusive {
                 index_type temp = ( ate + 1 ) & nModulo ;    // next item after tail
 
                 // Looking for actual tail
-                while ( !is_free( tt ) ) {
-                    if ( te != m_nTail.load(memory_model::memory_order_relaxed) )    // check the tail consistency
+                while ( !is_free( tt )) {
+                    if ( te != m_nTail.load(memory_model::memory_order_relaxed))    // check the tail consistency
                         goto TryAgain;
-                    if ( temp == m_nHead.load(memory_model::memory_order_acquire) )    // queue full?
+                    if ( temp == m_nHead.load(memory_model::memory_order_acquire))    // queue full?
                         break;
                     tt = m_buffer[ temp ].load(memory_model::memory_order_relaxed);
                     ate = temp;
                     temp = (temp + 1) & nModulo;
                 }
 
-                if ( te != m_nTail.load(memory_model::memory_order_acquire) )
+                if ( te != m_nTail.load(memory_model::memory_order_acquire))
                     continue;
 
                 // Check whether queue is full
-                if ( temp == m_nHead.load(memory_model::memory_order_acquire) ) {
+                if ( temp == m_nHead.load(memory_model::memory_order_acquire)) {
                     ate = ( temp + 1 ) & nModulo;
                     tt = m_buffer[ ate ].load(memory_model::memory_order_relaxed);
-                    if ( !is_free( tt ) ) {
+                    if ( !is_free( tt )) {
                         return false;   // Queue is full
                     }
 
@@ -295,13 +295,13 @@ namespace cds { namespace intrusive {
                     continue;
                 }
 
-                if ( tt == reinterpret_cast<value_type *>(free1) )
+                if ( tt == reinterpret_cast<value_type *>(free1))
                     pNewNode = reinterpret_cast<value_type *>(reinterpret_cast<intptr_t>( pNewNode ) | 1);
-                if ( te != m_nTail.load(memory_model::memory_order_acquire) )
+                if ( te != m_nTail.load(memory_model::memory_order_acquire))
                     continue;
 
                 // get actual tail and try to enqueue new node
-                if ( m_buffer[ate].compare_exchange_strong( tt, pNewNode, memory_model::memory_order_release, atomics::memory_order_relaxed ) ) {
+                if ( m_buffer[ate].compare_exchange_strong( tt, pNewNode, memory_model::memory_order_release, atomics::memory_order_relaxed )) {
                     if ( temp % 2 == 0 )
                         m_nTail.compare_exchange_strong( te, temp, memory_model::memory_order_release, atomics::memory_order_relaxed );
                     ++m_ItemCounter;
@@ -332,23 +332,23 @@ namespace cds { namespace intrusive {
                 value_type * pNull;
 
                 // find the actual head after this loop
-                while ( is_free( tt ) ) {
-                    if ( th != m_nHead.load(memory_model::memory_order_relaxed) )
+                while ( is_free( tt )) {
+                    if ( th != m_nHead.load(memory_model::memory_order_relaxed))
                         goto TryAgain;
 
                     // two consecutive nullptr means the queue is empty
-                    if ( temp == m_nTail.load(memory_model::memory_order_acquire) )
+                    if ( temp == m_nTail.load(memory_model::memory_order_acquire))
                         return nullptr;
 
                     temp = ( temp + 1 ) & nModulo;
                     tt = m_buffer[ temp ].load(memory_model::memory_order_relaxed);
                 }
 
-                if ( th != m_nHead.load(memory_model::memory_order_relaxed) )
+                if ( th != m_nHead.load(memory_model::memory_order_relaxed))
                     continue;
 
                 // check whether the queue is empty
-                if ( temp == m_nTail.load(memory_model::memory_order_acquire) ) {
+                if ( temp == m_nTail.load(memory_model::memory_order_acquire)) {
                     // help the enqueue to update end
                     m_nTail.compare_exchange_weak( temp, (temp + 1) & nModulo, memory_model::memory_order_release, atomics::memory_order_relaxed );
                     continue;
@@ -356,7 +356,7 @@ namespace cds { namespace intrusive {
 
                 pNull = reinterpret_cast<value_type *>((reinterpret_cast<uintptr_t>(tt) & 1) ? free0 : free1);
 
-                if ( th != m_nHead.load(memory_model::memory_order_relaxed) )
+                if ( th != m_nHead.load(memory_model::memory_order_relaxed))
                     continue;
 
                 // Get the actual head, null means empty
@@ -397,11 +397,11 @@ namespace cds { namespace intrusive {
             const value_type * tt = m_buffer[ temp ].load(memory_model::memory_order_relaxed);
 
             // find the actual head after this loop
-            while ( is_free( tt ) ) {
-                if ( th != m_nHead.load(memory_model::memory_order_relaxed) )
+            while ( is_free( tt )) {
+                if ( th != m_nHead.load(memory_model::memory_order_relaxed))
                     goto TryAgain;
                 // two consecutive nullptr means queue empty
-                if ( temp == m_nTail.load(memory_model::memory_order_relaxed) )
+                if ( temp == m_nTail.load(memory_model::memory_order_relaxed))
                     return true;
                 temp = ( temp + 1 ) & nModulo;
                 tt = m_buffer[ temp ].load(memory_model::memory_order_relaxed);
@@ -432,7 +432,7 @@ namespace cds { namespace intrusive {
         */
         void clear()
         {
-            clear( disposer() );
+            clear( disposer());
         }
 
         /// Returns queue's item count