nel/src/misc/cdb_branch_observing_handler.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21 #include "nel/misc/cdb_branch_observing_handler.h"
  22
  23 #ifdef DEBUG_NEW
  24 #define new DEBUG_NEW
  25 #endif
  26
  27 namespace NLMISC{
  28         CCDBBranchObservingHandler::CCDBBranchObservingHandler()
  29         {
  30                 reset();
  31         }
  32
  33         CCDBBranchObservingHandler::~CCDBBranchObservingHandler()
  34         {
  35                 reset();
  36         }
  37
  38         void CCDBBranchObservingHandler::flushObserverCalls()
  39         {
  40                 bool flushed = false;
  41
  42                 do
  43                 {
  44                         flushed = false;
  45                         uint oldList = currentList;
  46                         currentList = 1 - currentList;
  47
  48                         std::list< CCDBNodeBranch::ICDBDBBranchObserverHandle* >::iterator itr
  49                                 = flushableObservers[ oldList ].begin();
  50
  51                         while( itr != flushableObservers[ oldList ].end() )
  52                         {
  53                                 currentHandle = *itr;
  54                                 ++itr;
  55
  56                                 if( currentHandle->observer() != NULL )
  57                                         currentHandle->observer()->update( currentHandle->owner() );
  58
  59                                 // Update might have removed it
  60                                 if( currentHandle != NULL )
  61                                         currentHandle->removeFromFlushableList( oldList );
  62
  63                                 currentHandle = NULL;
  64                                 flushed = true;
  65                         }
  66                         triggerFlushObservers();
  67
  68                 }while( flushed );
  69
  70                 triggerFlushObservers();
  71         }
  72
  73         void CCDBBranchObservingHandler::reset()
  74         {
  75                 currentList = 0;
  76                 currentHandle = NULL;
  77
  78                 for( uint i = 0; i < MAX_OBS_LST; i++ )
  79                         flushableObservers[ i ].clear();
  80         }
  81
  82         void CCDBBranchObservingHandler::addBranchObserver( CCDBNodeBranch *branch, ICDBNode::IPropertyObserver *observer, const std::vector< std::string >& positiveLeafNameFilter )
  83         {
  84                 if( branch == NULL )
  85                         return;
  86
  87                 CCDBDBBranchObserverHandle *handle = new CCDBDBBranchObserverHandle( observer, branch, this );
  88                 branch->addBranchObserver( handle, positiveLeafNameFilter );
  89         }
  90
  91         void CCDBBranchObservingHandler::addBranchObserver( CCDBNodeBranch *branch, const char *dbPathFromThisNode, ICDBNode::IPropertyObserver &observer, const char **positiveLeafNameFilter, uint positiveLeafNameFilterSize )
  92         {
  93                 if( branch == NULL )
  94                         return;
  95
  96                 CCDBDBBranchObserverHandle *handle = new CCDBDBBranchObserverHandle( &observer, branch, this );
  97                 branch->addBranchObserver( handle, dbPathFromThisNode, positiveLeafNameFilter, positiveLeafNameFilterSize );
  98         }
  99
 100         void CCDBBranchObservingHandler::removeBranchObserver( CCDBNodeBranch *branch, ICDBNode::IPropertyObserver* observer )
 101         {
 102                 branch->removeBranchObserver( observer );
 103         }
 104
 105         void CCDBBranchObservingHandler::removeBranchObserver( CCDBNodeBranch *branch, const char *dbPathFromThisNode, ICDBNode::IPropertyObserver &observer )
 106         {
 107                 branch->removeBranchObserver( dbPathFromThisNode, observer );
 108         }
 109
 110         void CCDBBranchObservingHandler::triggerFlushObservers()
 111         {
 112                 for( std::vector< IBranchObserverCallFlushObserver* >::iterator itr = flushObservers.begin();
 113                          itr != flushObservers.end(); itr++ )
 114                          (*itr)->onObserverCallFlush();
 115         }
 116
 117         void CCDBBranchObservingHandler::addFlushObserver( IBranchObserverCallFlushObserver *observer )
 118         {
 119                 std::vector< IBranchObserverCallFlushObserver* >::iterator itr
 120                         = std::find( flushObservers.begin(), flushObservers.end(), observer );
 121
 122                 if( itr != flushObservers.end() )
 123                         return;
 124
 125                 flushObservers.push_back( observer );
 126         }
 127
 128         void CCDBBranchObservingHandler::removeFlushObserver( IBranchObserverCallFlushObserver *observer )
 129         {
 130                 std::vector< IBranchObserverCallFlushObserver* >::iterator itr
 131                         = std::find( flushObservers.begin(), flushObservers.end(), observer );
 132
 133                 if( itr == flushObservers.end() )
 134                         return;
 135
 136                 flushObservers.erase( itr );
 137         }
 138
 139         CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::CCDBDBBranchObserverHandle( NLMISC::ICDBNode::IPropertyObserver *observer, NLMISC::CCDBNodeBranch *owner, CCDBBranchObservingHandler *handler )
 140         {
 141                 std::fill( _inList, _inList + MAX_OBS_LST, false );
 142                 _observer = observer;
 143                 _owner = owner;
 144                 _handler = handler;
 145         }
 146
 147         CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::~CCDBDBBranchObserverHandle()
 148         {
 149                 _observer = NULL;
 150         }
 151
 152         bool CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::observesLeaf( const std::string &leafName )
 153         {
 154                 if( !_observedLeaves.empty() ){
 155                         std::vector< std::string >::iterator itr
 156                                 = std::find( _observedLeaves.begin(), _observedLeaves.end(), leafName );
 157
 158                         if( itr == _observedLeaves.end() )
 159                                 return false;
 160                         else
 161                                 return true;
 162                 }
 163
 164                 return true;
 165         }
 166
 167         bool CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::inList( uint list )
 168         {
 169                 return _inList[ list ];
 170         }
 171
 172         void CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::addToFlushableList()
 173         {
 174                 uint list = _handler->currentList;
 175
 176                 if( _inList[ list ] )
 177                         return;
 178
 179                 _handler->flushableObservers[ list ].push_back( this );
 180                 _inList[ list ] = true;
 181         }
 182
 183         void CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::removeFromFlushableList( uint list )
 184         {
 185                 if( !_inList[ list ] )
 186                         return;
 187
 188                 std::list< CCDBNodeBranch::ICDBDBBranchObserverHandle* >::iterator itr
 189                         = std::find( _handler->flushableObservers[ list ].begin(),
 190                                      _handler->flushableObservers[ list ].end(), this );
 191
 192                 if( itr == _handler->flushableObservers[ list ].end() )
 193                         return;
 194
 195                 if( _handler->currentHandle == this )
 196                         _handler->currentHandle = NULL;
 197
 198                 _handler->flushableObservers[ list ].erase( itr );
 199                 _inList[ list ] = false;
 200
 201         }
 202
 203         void CCDBBranchObservingHandler::CCDBDBBranchObserverHandle::removeFromFlushableList()
 204         {
 205                 for( uint i = 0; i < MAX_OBS_LST; i++ )
 206                         removeFromFlushableList( i );
 207         }
 208 }
 209