Debugging yet, but the new server works.

It at least seems to!

1 files changed, 0 insertions, 10 deletions

diff --git a/src/stable/clientbuf.cpp b/src/stable/clientbuf.cpp
index c6b310f..8c4afc4 100644
--- a/src/stable/clientbuf.cpp
+++ b/src/stable/clientbuf.cpp
@@ -175,19 +175,16 @@ void Bu::ClientBuf::ClientAccess::close()
 
 Bu::size Bu::ClientBuf::ClientAccess::read( void *pBufRaw, size iBytes )
 {
-    Bu::println("ClientAccess::read( ptr, %1 )").arg( iBytes );
     char *pBuf = (char *)pBufRaw;
     Bu::MutexLocker l( mAccess );
     // Read from QueueBuf first
     Bu::size ps = qbPeek.read( pBuf, iBytes );
-    Bu::println("ClientAccess::read: attempted qbPeek, got %1\n>%2<").arg( ps ).arg( Bu::String(pBuf, ps) );
     iBytes -= ps;
     pBuf += ps;
     // Request space left? Try the client
     if( iBytes > 0 )
     {
         ps += rBuf.accClientFiltered.read( pBuf, iBytes );
-        Bu::println("ClientAccess::read: attempted completion from socket buffer, got %1\n>%2<").arg( ps ).arg( Bu::String(pBuf, ps) );
     }
     return ps;
 }
@@ -195,26 +192,22 @@ Bu::size Bu::ClientBuf::ClientAccess::read( void *pBufRaw, size iBytes )
 Bu::size Bu::ClientBuf::ClientAccess::peek( void *pData, int iBytes,
         int iOffset )
 {
-    Bu::println("ClientAccess::peek( ptr, %1, %2 )").arg( iBytes ).arg( iOffset );
     Bu::MutexLocker l( mAccess );
     // Do we have enough data in the peek buffer to handle this?
     if( qbPeek.getSize() < iBytes+iOffset )
     {
-        Bu::println("ClientAccess::peek: Insufficient buffered (have %1b, need %2b)").arg( qbPeek.getSize() ).arg( iBytes+iOffset );
         // Nope, make an attempt to fill it in.
         int nDiff = (iBytes+iOffset)-qbPeek.getSize();
         // We have to make our own buffer, since iBytes+nOffeset could be bigger
         // than pData.
         char *pTmp = new char[nDiff];
         Bu::size ps = rBuf.accClientFiltered.read( pTmp, nDiff );
-        Bu::println("ClientAccess::peek: Tried to fill buffer, read %1 of needed %2\n>%3<").arg( ps ).arg( nDiff ).arg( Bu::String(pTmp, ps) );
         if( ps > 0 )
         {
             // Add the data read to the peek buffer.
             qbPeek.write( pTmp, ps );
         }
         delete[] pTmp;
-        Bu::println("ClientAccess::peek: buffer left with %1").arg( qbPeek.getSize() );
     }
 
     return qbPeek.peek( pData, iBytes, iOffset );
@@ -234,7 +227,6 @@ Bu::size Bu::ClientBuf::ClientAccess::tell()
 
 void Bu::ClientBuf::ClientAccess::seek( Bu::size offset )
 {
-    Bu::println("ClientAccess::seek( %1 )").arg( offset );
     Bu::MutexLocker l( mAccess );
     // For this type of stream seek is basically a destructive skip. It's like
     // reading the data but with no output buffer. Let's remove data from the
@@ -242,7 +234,6 @@ void Bu::ClientBuf::ClientAccess::seek( Bu::size offset )
     if( qbPeek.getSize() > 0 )
     {
         Bu::size amount = Bu::buMin( qbPeek.getSize(), offset );
-        Bu::println("ClientAccess::seek: buffered: %1, amount: %2").arg( qbPeek.getSize() ).arg( amount );
         qbPeek.seek( amount );
         offset -= amount;
     }
@@ -250,7 +241,6 @@ void Bu::ClientBuf::ClientAccess::seek( Bu::size offset )
     // If there's offset left, then apply it to the underlying stream
     if( offset > 0 )
     {
-        Bu::println("ClientAccess::seek: seeking remaining %1 in socket buffer").arg( offset );
         rBuf.accClientFiltered.seek( offset );
     }
 }