ICE-5606 renamed ServantLocator::deactivate to destroy

1 files changed, 122 insertions, 122 deletions

diff --git a/cpp/src/Freeze/BackgroundSaveEvictorI.cpp b/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
index f37d44bad7e..e747f371b3a 100644
--- a/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
+++ b/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
@@ -51,7 +51,7 @@ public:
 };
 Init init;
 
-void 
+void
 handleFatalError(const Freeze::BackgroundSaveEvictorPtr& evictor, const Ice::CommunicatorPtr& communicator)
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(fatalErrorCallbackMutex);
@@ -73,7 +73,7 @@ handleFatalError(const Freeze::BackgroundSaveEvictorPtr& evictor, const Ice::Com
 class WatchDogTask : public IceUtil::TimerTask
 {
 public:
-    
+
     WatchDogTask(BackgroundSaveEvictorI& evictor) : _evictor(evictor)
     {
     }
@@ -85,7 +85,7 @@ public:
         out.flush();
         handleFatalError(&_evictor, _evictor.communicator());
     }
-    
+
 private:
 
     BackgroundSaveEvictorI& _evictor;
@@ -95,11 +95,11 @@ private:
 
 //
 // createEvictor functions
-// 
+//
 
 Freeze::BackgroundSaveEvictorPtr
-Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter, 
-                                    const string& envName, 
+Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter,
+                                    const string& envName,
                                     const string& filename,
                                     const ServantInitializerPtr& initializer,
                                     const vector<IndexPtr>& indices,
@@ -109,9 +109,9 @@ Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter,
 }
 
 BackgroundSaveEvictorPtr
-Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter, 
-                                    const string& envName, 
-                                    DbEnv& dbEnv, 
+Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter,
+                                    const string& envName,
+                                    DbEnv& dbEnv,
                                     const string& filename,
                                     const ServantInitializerPtr& initializer,
                                     const vector<IndexPtr>& indices,
@@ -120,7 +120,7 @@ Freeze::createBackgroundSaveEvictor(const ObjectAdapterPtr& adapter,
     return new BackgroundSaveEvictorI(adapter, envName, &dbEnv, filename, initializer, indices, createDb);
 }
 
-FatalErrorCallback 
+FatalErrorCallback
 Freeze::registerFatalErrorCallback(FatalErrorCallback cb)
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(fatalErrorCallbackMutex);
@@ -133,10 +133,10 @@ Freeze::registerFatalErrorCallback(FatalErrorCallback cb)
 // BackgroundSaveEvictorI
 //
 
-Freeze::BackgroundSaveEvictorI::BackgroundSaveEvictorI(const ObjectAdapterPtr& adapter, 
-                                                       const string& envName, 
-                                                       DbEnv* dbEnv, 
-                                                       const string& filename, 
+Freeze::BackgroundSaveEvictorI::BackgroundSaveEvictorI(const ObjectAdapterPtr& adapter,
+                                                       const string& envName,
+                                                       DbEnv* dbEnv,
+                                                       const string& filename,
                                                        const ServantInitializerPtr& initializer,
                                                        const vector<IndexPtr>& indices,
                                                        bool createDb) :
@@ -145,8 +145,8 @@ Freeze::BackgroundSaveEvictorI::BackgroundSaveEvictorI(const ObjectAdapterPtr& a
     _currentEvictorSize(0),
     _savingThreadDone(false)
 {
-    string propertyPrefix = string("Freeze.Evictor.") + envName + '.' + _filename; 
-    
+    string propertyPrefix = string("Freeze.Evictor.") + envName + '.' + _filename;
+
     //
     // By default, we save every minute or when the size of the modified queue
     // reaches 10.
@@ -159,24 +159,24 @@ Freeze::BackgroundSaveEvictorI::BackgroundSaveEvictorI(const ObjectAdapterPtr& a
         getPropertyAsIntWithDefault(propertyPrefix + ".SavePeriod", 60 * 1000);
 
     _savePeriod = IceUtil::Time::milliSeconds(savePeriod);
-   
+
     //
     // By default, we save at most 10 * SaveSizeTrigger objects per transaction
     //
     _maxTxSize = _communicator->getProperties()->
         getPropertyAsIntWithDefault(propertyPrefix + ".MaxTxSize", 10 * _saveSizeTrigger);
-    
+
     if(_maxTxSize <= 0)
     {
         _maxTxSize = 100;
-    }   
+    }
 
     //
     // By default, no stream timeout
     //
     _streamTimeout = _communicator->getProperties()->
         getPropertyAsIntWithDefault(propertyPrefix+ ".StreamTimeout", 0) * 1000;
-    
+
     if(_streamTimeout > 0)
     {
         _timer = IceInternal::getInstanceTimer(_communicator);
@@ -197,9 +197,9 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
     checkIdentity(ident);
     checkServant(servant);
     DeactivateController::Guard deactivateGuard(_deactivateController);
-   
+
     ObjectStore<BackgroundSaveEvictorElement>* store = findStore(facet, _createDb);
-    
+
     if(store == 0)
     {
         throw NotFoundException(__FILE__, __LINE__, "addFacet: could not open database for facet '"
@@ -213,11 +213,11 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
         //
         // Create a new entry
         //
-        
+
         BackgroundSaveEvictorElementPtr element = new BackgroundSaveEvictorElement(*store);
         element->status = dead;
         BackgroundSaveEvictorElementPtr oldElt = store->putIfAbsent(ident, element);
-      
+
         if(oldElt != 0)
         {
             element = oldElt;
@@ -230,13 +230,13 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
             {
                 //
                 // Try again
-                // 
+                //
                 continue;
             }
             fixEvictPosition(element);
 
             IceUtil::Mutex::Lock lock(element->mutex);
-        
+
             switch(element->status)
             {
                 case clean:
@@ -245,12 +245,12 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
                 {
                     alreadyThere = true;
                     break;
-                }  
+                }
                 case destroyed:
                 {
                     element->status = modified;
                     element->rec.servant = servant;
-                    
+
                     //
                     // No need to push it on the modified queue, as a destroyed object
                     // is either already on the queue or about to be saved. When saved,
@@ -282,7 +282,7 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
         }
         break; // for(;;)
     }
-    
+
     if(alreadyThere)
     {
         AlreadyRegisteredException ex(__FILE__, __LINE__);
@@ -319,7 +319,7 @@ Freeze::BackgroundSaveEvictorI::removeFacet(const Identity& ident, const string&
 {
     checkIdentity(ident);
     DeactivateController::Guard deactivateGuard(_deactivateController);
-   
+
     ObjectStore<BackgroundSaveEvictorElement>* store = findStore(facet, false);
     ObjectPtr servant = 0;
 
@@ -330,7 +330,7 @@ Freeze::BackgroundSaveEvictorI::removeFacet(const Identity& ident, const string&
             //
             // Retrieve object
             //
-            
+
             BackgroundSaveEvictorElementPtr element = store->pin(ident);
             if(element != 0)
             {
@@ -339,14 +339,14 @@ Freeze::BackgroundSaveEvictorI::removeFacet(const Identity& ident, const string&
                 {
                     //
                     // Try again
-                    // 
+                    //
                     continue;
                 }
-            
+
                 fixEvictPosition(element);
                 {
                     IceUtil::Mutex::Lock lock(element->mutex);
-                    
+
                     switch(element->status)
                     {
                         case clean:
@@ -375,7 +375,7 @@ Freeze::BackgroundSaveEvictorI::removeFacet(const Identity& ident, const string&
                             // (at which point it becomes clean)
                             //
                             break;
-                        }  
+                        }
                         case destroyed:
                         case dead:
                         {
@@ -403,10 +403,10 @@ Freeze::BackgroundSaveEvictorI::removeFacet(const Identity& ident, const string&
                     element->evictPosition = _evictorList.begin();
                 }
             }
-            break; // for(;;)  
+            break; // for(;;)
         }
     }
-    
+
     if(servant == 0)
     {
         NotRegisteredException ex(__FILE__, __LINE__);
@@ -461,9 +461,9 @@ Freeze::BackgroundSaveEvictorI::keepFacet(const Identity& ident, const string& f
                 notThere = true;
                 break;
             }
-            
+
             Lock sync(*this);
-            
+
             if(element->stale)
             {
                 //
@@ -471,8 +471,8 @@ Freeze::BackgroundSaveEvictorI::keepFacet(const Identity& ident, const string& f
                 //
                 continue;
             }
-            
-            
+
+
             {
                 IceUtil::Mutex::Lock lockElement(element->mutex);
                 if(element->status == destroyed || element->status == dead)
@@ -481,7 +481,7 @@ Freeze::BackgroundSaveEvictorI::keepFacet(const Identity& ident, const string& f
                     break;
                 }
             }
-            
+
             //
             // Found!
             //
@@ -540,12 +540,12 @@ Freeze::BackgroundSaveEvictorI::releaseFacet(const Identity& ident, const string
     if(store != 0)
     {
         Lock sync(*this);
-        
+
         BackgroundSaveEvictorElementPtr element = store->getIfPinned(ident);
         if(element != 0)
         {
             assert(!element->stale);
-            if(element->keepCount > 0) 
+            if(element->keepCount > 0)
             {
                 if(--element->keepCount == 0)
                 {
@@ -566,7 +566,7 @@ Freeze::BackgroundSaveEvictorI::releaseFacet(const Identity& ident, const string
             }
         }
     }
-    
+
     NotRegisteredException ex(__FILE__, __LINE__);
     ex.kindOfObject = "servant";
     ex.id = _communicator->identityToString(ident);
@@ -591,12 +591,12 @@ Freeze::BackgroundSaveEvictorI::hasFacet(const Identity& ident, const string& fa
     }
 
     {
-        Lock sync(*this);  
+        Lock sync(*this);
         BackgroundSaveEvictorElementPtr element = store->getIfPinned(ident);
         if(element != 0)
         {
-            assert(!element->stale);    
-            
+            assert(!element->stale);
+
             IceUtil::Mutex::Lock lock(element->mutex);
             return element->status != dead && element->status != destroyed;
         }
@@ -610,34 +610,34 @@ Freeze::BackgroundSaveEvictorI::hasAnotherFacet(const Identity& ident, const str
     DeactivateController::Guard deactivateGuard(_deactivateController);
 
     //
-    // If the object exists in another store, throw FacetNotExistException 
+    // If the object exists in another store, throw FacetNotExistException
     // instead of returning 0 (== ObjectNotExistException)
-    // 
+    //
     StoreMap storeMapCopy;
     {
         Lock sync(*this);
         storeMapCopy = _storeMap;
-    }       
-        
+    }
+
     for(StoreMap::iterator p = storeMapCopy.begin(); p != storeMapCopy.end(); ++p)
     {
         //
         // Do not check again the given facet
         //
         if((*p).first != facet)
-        { 
+        {
             ObjectStore<BackgroundSaveEvictorElement>* store = (*p).second;
-            
+
             bool inCache = false;
             {
                 Lock sync(*this);
-                
+
                 BackgroundSaveEvictorElementPtr element = store->getIfPinned(ident);
                 if(element != 0)
                 {
                     inCache = true;
-                    assert(!element->stale);    
-                    
+                    assert(!element->stale);
+
                     IceUtil::Mutex::Lock lock(element->mutex);
                     if(element->status != dead && element->status != destroyed)
                     {
@@ -675,7 +675,7 @@ Freeze::BackgroundSaveEvictorI::locateImpl(const Current& current, LocalObjectPt
         }
         return 0;
     }
-    
+
     for(;;)
     {
         BackgroundSaveEvictorElementPtr element = store->pin(current.id);
@@ -689,7 +689,7 @@ Freeze::BackgroundSaveEvictorI::locateImpl(const Current& current, LocalObjectPt
             }
             return 0;
         }
-        
+
         Lock sync(*this);
 
         if(element->stale)
@@ -707,7 +707,7 @@ Freeze::BackgroundSaveEvictorI::locateImpl(const Current& current, LocalObjectPt
             if(_trace >= 2)
             {
                 Trace out(_communicator->getLogger(), "Freeze.Evictor");
-                out << "locate found \"" << _communicator->identityToString(current.id) 
+                out << "locate found \"" << _communicator->identityToString(current.id)
                     << "\" in the cache for database \"" << current.facet << "\" but it was dead or destroyed";
             }
             return 0;
@@ -719,7 +719,7 @@ Freeze::BackgroundSaveEvictorI::locateImpl(const Current& current, LocalObjectPt
         if(_trace >= 2)
         {
             Trace out(_communicator->getLogger(), "Freeze.Evictor");
-            out << "locate found \"" << _communicator->identityToString(current.id) << "\" in Db \"" 
+            out << "locate found \"" << _communicator->identityToString(current.id) << "\" in Db \""
                 << _filename << "\"";
         }
 
@@ -741,37 +741,37 @@ Freeze::BackgroundSaveEvictorI::finished(const Current& current, const ObjectPtr
     {
         BackgroundSaveEvictorElementPtr element = BackgroundSaveEvictorElementPtr::dynamicCast(cookie);
         assert(element);
-    
+
         bool enqueue = false;
-        
+
         if((servant->ice_operationAttributes(current.operation) & 0x1) != 0)
         {
             IceUtil::Mutex::Lock lock(element->mutex);
-            
+
             if(element->status == clean)
             {
                 //
                 // Assume this operation updated the object
-                // 
+                //
                 element->status = modified;
                 enqueue = true;
             }
         }
-        
+
         Lock sync(*this);
 
         //
-        // Only elements with a usageCount == 0 can become stale and we own 
+        // Only elements with a usageCount == 0 can become stale and we own
         // one count!
-        // 
+        //
         assert(!element->stale);
         assert(element->usageCount >= 1);
-        
+
         //
         // Decrease the usage count of the evictor queue element.
         //
         element->usageCount--;
-        
+
         if(enqueue)
         {
             addToModifiedQueue(element);
@@ -787,7 +787,7 @@ Freeze::BackgroundSaveEvictorI::finished(const Current& current, const ObjectPtr
 }
 
 void
-Freeze::BackgroundSaveEvictorI::deactivate(const string&)
+Freeze::BackgroundSaveEvictorI::destroy(const string&)
 {
     if(_deactivateController.deactivate())
     {
@@ -796,19 +796,19 @@ Freeze::BackgroundSaveEvictorI::deactivate(const string&)
             saveNow();
 
             Lock sync(*this);
-     
+
             //
             // Set the evictor size to zero, meaning that we will evict
             // everything possible.
             //
             _evictorSize = 0;
             evict();
-            
+
             _savingThreadDone = true;
             notifyAll();
             sync.release();
             getThreadControl().join();
-            
+
             closeDbEnv();
         }
         catch(...)
@@ -841,7 +841,7 @@ Freeze::BackgroundSaveEvictorI::run()
             deque<BackgroundSaveEvictorElementPtr> deadObjects;
 
             size_t saveNowThreadsSize = 0;
-            
+
             {
                 Lock sync(*this);
 
@@ -859,18 +859,18 @@ Freeze::BackgroundSaveEvictorI::run()
                         // Timeout, so let's save
                         //
                         break; // while
-                    }                           
+                    }
                 }
-                
+
                 saveNowThreadsSize = _saveNowThreads.size();
-                
+
                 if(_savingThreadDone)
                 {
                     assert(_modifiedQueue.size() == 0);
                     assert(saveNowThreadsSize == 0);
                     break; // for(;;)
                 }
-                
+
                 //
                 // Check first if there is something to do!
                 //
@@ -883,38 +883,38 @@ Freeze::BackgroundSaveEvictorI::run()
                     }
                     continue; // for(;;)
                 }
-                
+
                 _modifiedQueue.swap(allObjects);
             }
-            
+
             const size_t size = allObjects.size();
-            
+
             deque<StreamedObject> streamedObjectQueue;
-            
+
             Long streamStart = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
-            
+
             //
             // Stream each element
             //
             for(size_t i = 0; i < size; i++)
             {
                 BackgroundSaveEvictorElementPtr& element = allObjects[i];
-                
+
                 bool tryAgain;
                 do
                 {
                     tryAgain = false;
                     ObjectPtr servant = 0;
-                    
+
                     //
-                    // These elements can't be stale as only elements with 
+                    // These elements can't be stale as only elements with
                     // usageCount == 0 can become stale, and the modifiedQueue
                     // (us now) owns one count.
                     //
 
                     IceUtil::Mutex::Lock lockElement(element->mutex);
                     Byte status = element->status;
-                    
+
                     switch(status)
                     {
                         case created:
@@ -922,7 +922,7 @@ Freeze::BackgroundSaveEvictorI::run()
                         {
                             servant = element->rec.servant;
                             break;
-                        }   
+                        }
                         case destroyed:
                         {
                             size_t index = streamedObjectQueue.size();
@@ -934,7 +934,7 @@ Freeze::BackgroundSaveEvictorI::run()
                             deadObjects.push_back(element);
 
                             break;
-                        }   
+                        }
                         case dead:
                         {
                             deadObjects.push_back(element);
@@ -961,7 +961,7 @@ Freeze::BackgroundSaveEvictorI::run()
                             // Lock servant and then element so that user can safely lock
                             // servant and call various Evictor operations
                             //
-                            
+
                             IceUtil::AbstractMutex::TryLock lockServant(*mutex);
                             if(!lockServant.acquired())
                             {
@@ -983,7 +983,7 @@ Freeze::BackgroundSaveEvictorI::run()
                                 lockElement.acquire();
                                 status = element->status;
                             }
-  
+
                             switch(status)
                             {
                                 case created:
@@ -1007,7 +1007,7 @@ Freeze::BackgroundSaveEvictorI::run()
                                 case destroyed:
                                 {
                                     lockServant.release();
-                                    
+
                                     size_t index = streamedObjectQueue.size();
                                     streamedObjectQueue.resize(index + 1);
                                     StreamedObject& obj = streamedObjectQueue[index];
@@ -1016,7 +1016,7 @@ Freeze::BackgroundSaveEvictorI::run()
                                     element->status = dead;
                                     deadObjects.push_back(element);
                                     break;
-                                }   
+                                }
                                 case dead:
                                 {
                                     deadObjects.push_back(element);
@@ -1034,26 +1034,26 @@ Freeze::BackgroundSaveEvictorI::run()
                         else
                         {
                             DatabaseException ex(__FILE__, __LINE__);
-                            ex.message = string(typeid(*element->rec.servant).name()) 
+                            ex.message = string(typeid(*element->rec.servant).name())
                                 + " does not implement IceUtil::AbstractMutex";
                             throw ex;
                         }
                     }
                 } while(tryAgain);
             }
-            
+
             if(_trace >= 1)
             {
                 Long now = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                 Trace out(_communicator->getLogger(), "Freeze.Evictor");
-                out << "streamed " << streamedObjectQueue.size() << " objects in " 
+                out << "streamed " << streamedObjectQueue.size() << " objects in "
                     << static_cast<Int>(now - streamStart) << " ms";
             }
-            
+
             //
             // Now let's save all these streamed objects to disk using a transaction
             //
-            
+
             //
             // Each time we get a deadlock, we reduce the number of objects to save
             // per transaction
@@ -1064,20 +1064,20 @@ Freeze::BackgroundSaveEvictorI::run()
                 txSize = static_cast<size_t>(_maxTxSize);
             }
             bool tryAgain;
-            
+
             do
             {
                 tryAgain = false;
-                
+
                 while(streamedObjectQueue.size() > 0)
                 {
                     if(txSize > streamedObjectQueue.size())
                     {
                         txSize = streamedObjectQueue.size();
                     }
-                    
+
                     Long saveStart = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
-                   
+
                     try
                     {
                         DbTxn* tx = 0;
@@ -1092,7 +1092,7 @@ Freeze::BackgroundSaveEvictorI::run()
                         }
 
                         try
-                        {       
+                        {
                             for(size_t i = 0; i < txSize; i++)
                             {
                                 StreamedObject& obj = streamedObjectQueue[i];
@@ -1118,14 +1118,14 @@ Freeze::BackgroundSaveEvictorI::run()
                         }
 
                         streamedObjectQueue.erase
-                            (streamedObjectQueue.begin(), 
+                            (streamedObjectQueue.begin(),
                              streamedObjectQueue.begin() + txSize);
-                        
+
                         if(_trace >= 1)
                         {
                             Long now = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                             Trace out(_communicator->getLogger(), "Freeze.Evictor");
-                            out << "saved " << txSize << " objects in " 
+                            out << "saved " << txSize << " objects in "
                                 << static_cast<Int>(now - saveStart) << " ms";
                         }
                     }
@@ -1137,7 +1137,7 @@ Freeze::BackgroundSaveEvictorI::run()
                             out << "Deadlock in Freeze::BackgroundSaveEvictorI::run while writing into Db \"" + _filename
                                 + "\"; retrying ...";
                         }
-                        
+
                         tryAgain = true;
                         txSize = (txSize + 1)/2;
                     }
@@ -1147,13 +1147,13 @@ Freeze::BackgroundSaveEvictorI::run()
                         ex.message = dx.what();
                         throw ex;
                     }
-                } 
+                }
             }
             while(tryAgain);
-            
+
             {
                 Lock sync(*this);
-               
+
                 //
                 // Release usage count
                 //
@@ -1191,7 +1191,7 @@ Freeze::BackgroundSaveEvictorI::run()
                 }
                 deadObjects.clear();
                 evict();
-                
+
                 if(saveNowThreadsSize > 0)
                 {
                     _saveNowThreads.erase(_saveNowThreads.begin(), _saveNowThreads.begin() + saveNowThreadsSize);
@@ -1227,7 +1227,7 @@ void
 Freeze::BackgroundSaveEvictorI::saveNow()
 {
     Lock sync(*this);
-    
+
     IceUtil::ThreadControl myself;
 
     _saveNowThreads.push_back(myself);
@@ -1249,7 +1249,7 @@ Freeze::BackgroundSaveEvictorI::evict()
     assert(_currentEvictorSize == _evictorList.size());
 
     list<BackgroundSaveEvictorElementPtr>::reverse_iterator p = _evictorList.rbegin();
-    
+
     while(_currentEvictorSize > _evictorSize)
     {
         //
@@ -1285,10 +1285,10 @@ Freeze::BackgroundSaveEvictorI::evict()
             {
                 out << "-f \"" << facet << "\" ";
             }
-            out << "from the queue\n" 
+            out << "from the queue\n"
                 << "number of elements in the queue: " << _currentEvictorSize;
         }
-        
+
         //
         // Remove last unused element from the evictor queue.
         //
@@ -1299,11 +1299,11 @@ Freeze::BackgroundSaveEvictorI::evict()
     }
 }
 
-void 
+void
 Freeze::BackgroundSaveEvictorI::fixEvictPosition(const BackgroundSaveEvictorElementPtr& element)
 {
     assert(!element->stale);
-    
+
     if(element->keepCount == 0)
     {
         if(element->usageCount < 0)
@@ -1323,7 +1323,7 @@ Freeze::BackgroundSaveEvictorI::fixEvictPosition(const BackgroundSaveEvictorElem
     }
 }
 
-void 
+void
 Freeze::BackgroundSaveEvictorI::evict(const BackgroundSaveEvictorElementPtr& element)
 {
     assert(!element->stale);
@@ -1341,7 +1341,7 @@ Freeze::BackgroundSaveEvictorI::addToModifiedQueue(const BackgroundSaveEvictorEl
 {
     element->usageCount++;
     _modifiedQueue.push_back(element);
-    
+
     if(_saveSizeTrigger >= 0 && static_cast<Int>(_modifiedQueue.size()) >= _saveSizeTrigger)
     {
         notifyAll();
@@ -1353,7 +1353,7 @@ void
 Freeze::BackgroundSaveEvictorI::stream(const BackgroundSaveEvictorElementPtr& element, Long streamStart, StreamedObject& obj)
 {
     assert(element->status != dead);
-    
+
     obj.status = element->status;
     obj.store = &element->store;
 
@@ -1397,7 +1397,7 @@ Freeze::BackgroundSaveEvictorElement::~BackgroundSaveEvictorElement()
 {
 }
 
-void 
+void
 Freeze::BackgroundSaveEvictorElement::init(ObjectStore<BackgroundSaveEvictorElement>::Position p)
 {
     stale = false;