Expanded tabs into spaces

1 files changed, 137 insertions, 137 deletions

diff --git a/cpp/src/Freeze/EvictorIteratorI.cpp b/cpp/src/Freeze/EvictorIteratorI.cpp
index d2a1ecef2f5..68feab953aa 100644
--- a/cpp/src/Freeze/EvictorIteratorI.cpp
+++ b/cpp/src/Freeze/EvictorIteratorI.cpp
@@ -33,12 +33,12 @@ Freeze::EvictorIteratorI::hasNext()
 {
     if(_batchIterator != _batch.end()) 
     {
-	return true;
+        return true;
     }
     else
     {
-	_batchIterator = nextBatch();
-	return (_batchIterator != _batch.end());
+        _batchIterator = nextBatch();
+        return (_batchIterator != _batch.end());
     }
 }
 
@@ -47,11 +47,11 @@ Freeze::EvictorIteratorI::next()
 {
     if(hasNext())
     {
-	return *_batchIterator++;
+        return *_batchIterator++;
     }
     else
     {
-	throw Freeze::NoSuchElementException(__FILE__, __LINE__);
+        throw Freeze::NoSuchElementException(__FILE__, __LINE__);
     }
 }
 
@@ -60,13 +60,13 @@ vector<Identity>::const_iterator
 Freeze::EvictorIteratorI::nextBatch()
 {
     DeactivateController::Guard 
-	deactivateGuard(_store->evictor()->deactivateController());
+        deactivateGuard(_store->evictor()->deactivateController());
 
     _batch.clear();
 
     if(!_more)
     {
-	return _batch.end();
+        return _batch.end();
     }
 
     vector<EvictorElementPtr> evictorElements;
@@ -78,145 +78,145 @@ Freeze::EvictorIteratorI::nextBatch()
    
     try
     {
-	for(;;)
-	{
-	    _batch.clear();
-	    evictorElements.clear();
-	    
-	    Dbt dbKey;
-	    initializeOutDbt(_key, dbKey);
-
-	    Dbt dbValue;
-	    dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
-	   
-	    Dbc* dbc = 0;
-	    try
-	    {
-		//
-		// Move to the first record
-		// 
-		u_int32_t flags = DB_NEXT;
-
-		if(_initialized)
-		{
-		    //
-		    // _key represents the next element not yet returned
-		    // if it has been deleted, we want the one after
-		    //
-		    flags = DB_SET_RANGE;
-
-		    //
-		    // Will be used as input as well
-		    //
-		    dbKey.set_size(static_cast<u_int32_t>(firstKey.size()));
-		}
-		
-		_store->db()->cursor(0, &dbc, 0);
-
-		bool done = false;
-		do
-		{
-		    for(;;)
-		    {
-			try
-			{
-			    //
-			    // It is critical to set key size to key capacity before the
-			    // get, as a resize that increases the size inserts 0
-			    //
-			    _key.resize(_key.capacity());
-
-			    _more = (dbc->get(&dbKey, &dbValue, flags) == 0);
-			    if(_more)
-			    {
-				_key.resize(dbKey.get_size());
-				_initialized = true;
-
-				flags = DB_NEXT;
-		    
-				Ice::Identity ident;
-				ObjectStore::unmarshal(ident, _key, communicator);
-				if(_batch.size() < _batchSize)
-				{
-				    _batch.push_back(ident);
-				}
-				else
-				{
-				    //
-				    // Keep the last element in _key
-				    //
-				    done = true;
-				}
-			    }
-			    break;
-			}
-			catch(const DbDeadlockException&)
-			{
-			    throw;
-			}
-			catch(const DbException& dx)
-			{
-			    handleDbException(dx, _key, dbKey, __FILE__, __LINE__);
-			}
-		    }
-		}
-		while(!done && _more);
-
-		Dbc* toClose = dbc;
-		dbc = 0;
-		toClose->close();
-		break; // for (;;)
-	    }
-	    catch(const DbDeadlockException&)
-	    {
-		if(dbc != 0)
-		{
-		    try
-		    {
-			dbc->close();
-		    }
-		    catch(const DbDeadlockException&)
-		    {
-			//
-			// Ignored
-			//
-		    }
-		}
-		_key = firstKey;
-		//
-		// Retry
-		//
-	    }
-	    catch(...)
-	    {
-		if(dbc != 0)
-		{
-		    try
-		    {
-			dbc->close();
-		    }
-		    catch(const DbDeadlockException&)
-		    {
-			//
-			// Ignored
-			//
-		    }
-		}
-		throw;
-	    }
-	}
+        for(;;)
+        {
+            _batch.clear();
+            evictorElements.clear();
+            
+            Dbt dbKey;
+            initializeOutDbt(_key, dbKey);
+
+            Dbt dbValue;
+            dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL);
+           
+            Dbc* dbc = 0;
+            try
+            {
+                //
+                // Move to the first record
+                // 
+                u_int32_t flags = DB_NEXT;
+
+                if(_initialized)
+                {
+                    //
+                    // _key represents the next element not yet returned
+                    // if it has been deleted, we want the one after
+                    //
+                    flags = DB_SET_RANGE;
+
+                    //
+                    // Will be used as input as well
+                    //
+                    dbKey.set_size(static_cast<u_int32_t>(firstKey.size()));
+                }
+                
+                _store->db()->cursor(0, &dbc, 0);
+
+                bool done = false;
+                do
+                {
+                    for(;;)
+                    {
+                        try
+                        {
+                            //
+                            // It is critical to set key size to key capacity before the
+                            // get, as a resize that increases the size inserts 0
+                            //
+                            _key.resize(_key.capacity());
+
+                            _more = (dbc->get(&dbKey, &dbValue, flags) == 0);
+                            if(_more)
+                            {
+                                _key.resize(dbKey.get_size());
+                                _initialized = true;
+
+                                flags = DB_NEXT;
+                    
+                                Ice::Identity ident;
+                                ObjectStore::unmarshal(ident, _key, communicator);
+                                if(_batch.size() < _batchSize)
+                                {
+                                    _batch.push_back(ident);
+                                }
+                                else
+                                {
+                                    //
+                                    // Keep the last element in _key
+                                    //
+                                    done = true;
+                                }
+                            }
+                            break;
+                        }
+                        catch(const DbDeadlockException&)
+                        {
+                            throw;
+                        }
+                        catch(const DbException& dx)
+                        {
+                            handleDbException(dx, _key, dbKey, __FILE__, __LINE__);
+                        }
+                    }
+                }
+                while(!done && _more);
+
+                Dbc* toClose = dbc;
+                dbc = 0;
+                toClose->close();
+                break; // for (;;)
+            }
+            catch(const DbDeadlockException&)
+            {
+                if(dbc != 0)
+                {
+                    try
+                    {
+                        dbc->close();
+                    }
+                    catch(const DbDeadlockException&)
+                    {
+                        //
+                        // Ignored
+                        //
+                    }
+                }
+                _key = firstKey;
+                //
+                // Retry
+                //
+            }
+            catch(...)
+            {
+                if(dbc != 0)
+                {
+                    try
+                    {
+                        dbc->close();
+                    }
+                    catch(const DbDeadlockException&)
+                    {
+                        //
+                        // Ignored
+                        //
+                    }
+                }
+                throw;
+            }
+        }
     }
     catch(const DbException& dx)
     {
-	handleDbException(dx, __FILE__, __LINE__);
+        handleDbException(dx, __FILE__, __LINE__);
     }
     
     if(_batch.size() == 0)
     {
-	return _batch.end();
+        return _batch.end();
     }
     else
     {
-	return _batch.begin();
+        return _batch.begin();
     }
 }