Converted tabs to spaces with tabconv.

1 files changed, 126 insertions, 126 deletions

diff --git a/src/stable/server.cpp b/src/stable/server.cpp
index 39ff7bb..e6c256e 100644
--- a/src/stable/server.cpp
+++ b/src/stable/server.cpp
@@ -14,138 +14,138 @@
 #include "bu/config.h"
 
 Bu::Server::Server() :
-        nTimeoutSec( 0 ),
-        nTimeoutUSec( 0 ),
-        bAutoTick( false )
+    nTimeoutSec( 0 ),
+    nTimeoutUSec( 0 ),
+    bAutoTick( false )
 {
-        FD_ZERO( &fdActive );
+    FD_ZERO( &fdActive );
 }
 
 Bu::Server::~Server()
 {
-        shutdown();
+    shutdown();
 }
 
 void Bu::Server::addPort( int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
 {
-        this->nTimeoutSec = nTimeoutSec;
-        this->nTimeoutUSec = nTimeoutUSec;
+    this->nTimeoutSec = nTimeoutSec;
+    this->nTimeoutUSec = nTimeoutUSec;
 }
 
 void Bu::Server::scan()
 {
-        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
-        
-        fd_set fdRead = fdActive;
-        fd_set fdWrite /* = fdActive*/;
-        fd_set fdException = fdActive;
-
-        FD_ZERO( &fdWrite );
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->hasOutput() )
-                        FD_SET( i.getKey(), &fdWrite );
-        }
-
-        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
-                        &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
-        {
-                throw ExceptionBase("Error attempting to scan open connections.");
-        }
-
-        for( int j = 0; j < FD_SETSIZE; j++ )
-        {
-                if( FD_ISSET( j, &fdRead ) )
-                {
-                        if( hServers.has( j ) )
-                        {
-                                TcpServerSocket *pSrv = hServers.get( j );
-                                addClient( pSrv->accept(), pSrv->getPort() );
-                        }
-                        else
-                        {
-                                Client *pClient = hClients.get( j );
-                                pClient->processInput();
-                                if( !pClient->isOpen() )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                }
-                if( FD_ISSET( j, &fdWrite ) )
-                {
-                        try
-                        {
-                                Client *pClient = hClients.get( j );
-                                try
-                                {
-                                        pClient->processOutput();
-                                }
-                                catch( Bu::TcpSocketException &e )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                        catch( Bu::HashException &e )
-                        {
-                                // Do nothing, I guess, the client is already dead...
-                                // TODO:  Someday, we may want to handle this more graceully.
-                        }
-                }
-        }
-
-        Bu::List<int> lDelete;
-        // Now we just try to write all the pending data on all the sockets.
-        // this could be done better eventually, if we care about the socket
-        // wanting to accept writes (using a select).
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
-                {
-                        lDelete.append( i.getKey() );
-                }
-        }
-
-        for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
-        {
-                closeClient( *i );
-        }
-
-        if( bAutoTick )
-                tick();
+    struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+    
+    fd_set fdRead = fdActive;
+    fd_set fdWrite /* = fdActive*/;
+    fd_set fdException = fdActive;
+
+    FD_ZERO( &fdWrite );
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->hasOutput() )
+            FD_SET( i.getKey(), &fdWrite );
+    }
+
+    if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
+            &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
+    {
+        throw ExceptionBase("Error attempting to scan open connections.");
+    }
+
+    for( int j = 0; j < FD_SETSIZE; j++ )
+    {
+        if( FD_ISSET( j, &fdRead ) )
+        {
+            if( hServers.has( j ) )
+            {
+                TcpServerSocket *pSrv = hServers.get( j );
+                addClient( pSrv->accept(), pSrv->getPort() );
+            }
+            else
+            {
+                Client *pClient = hClients.get( j );
+                pClient->processInput();
+                if( !pClient->isOpen() )
+                {
+                    closeClient( j );
+                }
+            }
+        }
+        if( FD_ISSET( j, &fdWrite ) )
+        {
+            try
+            {
+                Client *pClient = hClients.get( j );
+                try
+                {
+                    pClient->processOutput();
+                }
+                catch( Bu::TcpSocketException &e )
+                {
+                    closeClient( j );
+                }
+            }
+            catch( Bu::HashException &e )
+            {
+                // Do nothing, I guess, the client is already dead...
+                // TODO:  Someday, we may want to handle this more graceully.
+            }
+        }
+    }
+
+    Bu::List<int> lDelete;
+    // Now we just try to write all the pending data on all the sockets.
+    // this could be done better eventually, if we care about the socket
+    // wanting to accept writes (using a select).
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
+        {
+            lDelete.append( i.getKey() );
+        }
+    }
+
+    for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
+    {
+        closeClient( *i );
+    }
+
+    if( bAutoTick )
+        tick();
 }
 
 void Bu::Server::addClient( socket_t nSocket, int nPort )
 {
-        FD_SET( nSocket, &fdActive );
+    FD_SET( nSocket, &fdActive );
 
-        Client *c = new Client(
-                new Bu::TcpSocket( nSocket ),
-                new SrvClientLinkFactory()
-                );
-        hClients.insert( nSocket, c );
+    Client *c = new Client(
+        new Bu::TcpSocket( nSocket ),
+        new SrvClientLinkFactory()
+        );
+    hClients.insert( nSocket, c );
 
-        onNewConnection( c, nPort );
+    onNewConnection( c, nPort );
 }
 
 Bu::Server::SrvClientLink::SrvClientLink( Bu::Client *pClient ) :
-        pClient( pClient )
+    pClient( pClient )
 {
 }
 
@@ -155,7 +155,7 @@ Bu::Server::SrvClientLink::~SrvClientLink()
 
 void Bu::Server::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
-        pClient->onMessage( sMsg );
+    pClient->onMessage( sMsg );
 }
 
 Bu::Server::SrvClientLinkFactory::SrvClientLinkFactory()
@@ -167,48 +167,48 @@ Bu::Server::SrvClientLinkFactory::~SrvClientLinkFactory()
 }
 
 Bu::ClientLink *Bu::Server::SrvClientLinkFactory::createLink(
-                Bu::Client *pClient )
+        Bu::Client *pClient )
 {
-        return new SrvClientLink( pClient );
+    return new SrvClientLink( pClient );
 }
 
 void Bu::Server::setAutoTick( bool bEnable )
 {
-        bAutoTick = bEnable;
+    bAutoTick = bEnable;
 }
 
 void Bu::Server::tick()
 {
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                (*i)->tick();
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        (*i)->tick();
+    }
 }
 
 void Bu::Server::shutdown()
 {
-        for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
-        {
-                delete *i;
-        }
+    for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
+    {
+        delete *i;
+    }
 
-        hServers.clear();
+    hServers.clear();
 
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                closeClient( i.getKey() );
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        closeClient( i.getKey() );
+    }
 
-        hClients.clear();
+    hClients.clear();
 }
 
 void Bu::Server::closeClient( socket_t iSocket )
 {
-        Bu::Client *pClient = hClients.get( iSocket );
-        onClosedConnection( pClient );
-        pClient->close();
-        hClients.erase( iSocket );
-        FD_CLR( iSocket, &fdActive );
-        delete pClient;
+    Bu::Client *pClient = hClients.get( iSocket );
+    onClosedConnection( pClient );
+    pClient->close();
+    hClients.erase( iSocket );
+    FD_CLR( iSocket, &fdActive );
+    delete pClient;
 }