Show
Ignore:
Timestamp:
03/21/12 18:36:20 (3 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osg/OperationThread.cpp

    r12292 r13041  
    5656} 
    5757 
    58 bool OperationQueue::empty()  
    59 {  
     58bool OperationQueue::empty() 
     59{ 
    6060 
    6161  OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    62   return _operations.empty();  
     62  return _operations.empty(); 
    6363} 
    6464 
     
    6666{ 
    6767  OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    68   return static_cast<unsigned int>(_operations.size());  
     68  return static_cast<unsigned int>(_operations.size()); 
    6969} 
    7070 
     
    7777 
    7878    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    79      
     79 
    8080    if (_operations.empty()) return osg::ref_ptr<Operation>(); 
    81      
     81 
    8282    if (_currentOperationIterator == _operations.end()) 
    8383    { 
     
    8585        _currentOperationIterator = _operations.begin(); 
    8686    } 
    87      
     87 
    8888    ref_ptr<Operation> currentOperation = *_currentOperationIterator; 
    8989 
     
    140140        { 
    141141            bool needToResetCurrentIterator = (_currentOperationIterator == itr); 
    142              
     142 
    143143            itr = _operations.erase(itr); 
    144              
     144 
    145145            if (needToResetCurrentIterator) _currentOperationIterator = itr; 
    146              
     146 
    147147        } 
    148148        else ++itr; 
     
    153153{ 
    154154    OSG_INFO<<"Doing remove named operation"<<std::endl; 
    155      
     155 
    156156    // acquire the lock on the operations queue to prevent anyone else for modifying it at the same time 
    157157    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
     
    161161        itr!=_operations.end();) 
    162162    { 
    163         if ((*itr)->getName()==name)  
     163        if ((*itr)->getName()==name) 
    164164        { 
    165165            bool needToResetCurrentIterator = (_currentOperationIterator == itr); 
    166              
     166 
    167167            itr = _operations.erase(itr); 
    168              
     168 
    169169            if (needToResetCurrentIterator) _currentOperationIterator = itr; 
    170170        } 
     
    183183 
    184184    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    185      
     185 
    186186    _operations.clear(); 
    187      
     187 
    188188    // reset current operator. 
    189189    _currentOperationIterator = _operations.begin(); 
     
    201201    // reset current operation iterator to beginning if at end. 
    202202    if (_currentOperationIterator==_operations.end()) _currentOperationIterator = _operations.begin(); 
    203      
     203 
    204204    for(; 
    205205        _currentOperationIterator != _operations.end(); 
     
    216216            ++_currentOperationIterator; 
    217217        } 
    218                  
     218 
    219219        // OSG_INFO<<"Doing op "<<_currentOperation->getName()<<" "<<this<<std::endl; 
    220220 
     
    233233    _operationsBlock->release(); 
    234234} 
    235   
     235 
    236236 void OperationQueue::releaseAllOperations() 
    237237{ 
    238238    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    239      
     239 
    240240    for(Operations::iterator itr = _operations.begin(); 
    241241        itr!=_operations.end(); 
     
    301301    { 
    302302        OSG_INFO<<"set done "<<this<<std::endl; 
    303          
     303 
    304304        { 
    305305            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadMutex); 
     
    322322    if( isRunning() ) 
    323323    { 
    324      
     324 
    325325        _done = true; 
    326326 
     
    330330            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadMutex); 
    331331 
    332             if (_operationQueue.valid())  
     332            if (_operationQueue.valid()) 
    333333            { 
    334334                 _operationQueue->releaseOperationsBlock(); 
     
    338338            if (_currentOperation.valid()) _currentOperation->release(); 
    339339        } 
    340          
     340 
    341341        // then wait for the the thread to stop running. 
    342342        while(isRunning()) 
     
    347347                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadMutex); 
    348348 
    349                 if (_operationQueue.valid())  
     349                if (_operationQueue.valid()) 
    350350                { 
    351351                    _operationQueue->releaseOperationsBlock(); 
     
    404404        ref_ptr<Operation> operation; 
    405405        ref_ptr<OperationQueue> operationQueue; 
    406          
     406 
    407407        { 
    408408            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadMutex); 
     
    426426            (*operation)(_parent.get()); 
    427427 
    428             {             
     428            { 
    429429                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadMutex); 
    430430                _currentOperation = 0; 
     
    434434        if (firstTime) 
    435435        { 
    436             // do a yield to get round a peculiar thread hang when testCancel() is called  
     436            // do a yield to get round a peculiar thread hang when testCancel() is called 
    437437            // in certain circumstances - of which there is no particular pattern. 
    438438            YieldCurrentThread(); 
    439439            firstTime = false; 
    440440        } 
    441          
     441 
    442442        // OSG_NOTICE<<"operations.size()="<<_operations.size()<<" done="<<_done<<" testCancel()"<<testCancel()<<std::endl; 
    443443