LoadBalancingTree Class Reference

#include <LoadBalancingTree.h>

List of all members.

Public Member Functions

 ~LoadBalancingTree ()
 LoadBalancingTree ()
 LoadBalancingTree (int subSpaceId, unsigned int maxPlayerLeafs, unsigned int treeWidth)
std::list< TreeMessageaddPlayer (int playerId, IPAddress playerIp)
std::list< TreeMessageremovePlayer (int playerId)
std::list< TreeMessageremovePlayer (IPAddress playerIp)
std::list< IPAddress > getList ()
std::list< PlayerNodegetAllPlayers ()
std::list< IPAddress > getAllNodes ()
std::list< IPAddress > getAllIntNodes ()
std::list< TreeMessageaddIntermediateNode (IPAddress destip)
std::list< IPAddress > exchangeNode (IPAddress oldNodeIp, IPAddress newNodeIp)
std::list< TreeMessagereplace (IPAddress newNodeIp)
std::list< TreeNodeserialize ()
void rebuildTree (std::list< TreeNode > source)
void printTree ()

Public Attributes

unsigned int size
std::list< IPAddress > readyIntermediateNodes
std::list< IPAddress > usedIntermediateNodes
int replacedIntermediateNodes

Protected Member Functions

NodePos searchPlayer (int playerId)
NodePos searchPlayer (IPAddress playerIp)
std::list< TreeNode * > searchNodes (IPAddress playerIp)
TreeNodesearchLeftmostNode ()
TreeNodesearchLastNode ()

Protected Attributes

TreeNoderoot
TreeNodelastTreeNode
std::list< TreeNodewaitingNodes
std::list< TreeNode >::iterator iW
std::list< TreeNode * > freed
std::list< TreeNode * >::iterator f
std::list< TreeNode * > inReplace
std::list< TreeNode * >::iterator iR
std::list< IPAddress >::iterator rI
unsigned int maxPlayerLeafs
unsigned int treeWidth
int lock
int subSpaceId
int actions

Friends

std::ostream & operator<< (std::ostream &Stream, LoadBalancingTree t)


Constructor & Destructor Documentation

LoadBalancingTree::~LoadBalancingTree (  ) 

00017                                       {
00018         this->root->leafs.clear();
00019         this->root->childs.clear();
00020 }

LoadBalancingTree::LoadBalancingTree (  ) 

00021                                      {
00022         this->root = new TreeNode();
00023         this->root->parent = NULL;
00024         this->lastTreeNode = this->root;
00025         this->size=0;
00026         this->lock = 0;
00027         actions=0;
00028         replacedIntermediateNodes = 0;
00029 }

LoadBalancingTree::LoadBalancingTree ( int  subSpaceId,
unsigned int  maxPlayerLeafs,
unsigned int  treeWidth 
)

00031                                                                                                         {
00032         this->maxPlayerLeafs = maxPlayerLeafs;
00033         this->treeWidth = treeWidth;
00034         this->root = new TreeNode();
00035         this->root->parent = NULL;
00036         this->lastTreeNode = root;
00037         this->size = 0;
00038         this->lock = 0;
00039         this->subSpaceId = subSpaceId;
00040         actions=0;
00041         replacedIntermediateNodes = 0;
00042 }


Member Function Documentation

std::list< TreeMessage > LoadBalancingTree::addPlayer ( int  playerId,
IPAddress  playerIp 
)

00045                                                                                   {
00046         actions++;
00047         std::list<TreeMessage> returnList;
00048         bool alreadyWaiting = false;
00049         for( iW = waitingNodes.begin() ; iW != waitingNodes.end(); ++iW ) {
00050                 if( iW->playerId == playerId ) {
00051                         alreadyWaiting = true;
00052                 }
00053         }
00054         if ( searchPlayer(playerId).parent != NULL || alreadyWaiting ) {
00055                 return returnList;
00056         }
00057         TreeMessage msg;
00058         if( ( (size > ( (usedIntermediateNodes.size() + readyIntermediateNodes.size()) * maxPlayerLeafs) + 0.5*maxPlayerLeafs) && lock == 0) || (size > (usedIntermediateNodes.size() + 2)*maxPlayerLeafs ) ) {
00059                 lock = 1;
00060                 TreeMessage newIntMsg;
00061                 newIntMsg.type=2;
00062                 returnList.push_back( newIntMsg);
00063         }
00064         msg.type = 0;
00065         msg.playerip = playerIp;
00066         if( freed.size() > 0 ) {
00067                 TreeNode* foo = freed.front();
00068                 msg.destip = foo->destip;
00069                 if( foo->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg);
00070                 TreeNode blub = TreeNode( foo , playerId, playerIp);
00071                 foo->leafs.push_back( blub );
00072                 freed.pop_front();
00073                 size++;
00074         }
00075         else if ( lastTreeNode->leafs.size() < maxPlayerLeafs) {
00076                 msg.destip = lastTreeNode->destip;
00077                 if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg);
00078                 lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp) );
00079                 size++;
00080         }
00081         else {
00082                 if( readyIntermediateNodes.size() > 0 ) {
00083                         TreeNode* parent = lastTreeNode->parent;
00084                         if( parent == NULL ) {
00085                                 parent = root;
00086                         }
00087                         
00088                         IPAddress destip = readyIntermediateNodes.front();
00089                         readyIntermediateNodes.pop_front();
00090                         usedIntermediateNodes.push_back( destip );
00091                         if( lastTreeNode != root && (parent->childs.size() < treeWidth) ) {
00092                                 //lastTreeNode->parent has enough space for another child
00093                                 parent->childs.push_back( TreeNode(parent, destip) ); 
00094                                 lastTreeNode = &( parent->childs.back()); // set lastTreeNode to the new child
00095                                 msg.destip = lastTreeNode->destip;
00096                                 if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg);
00097                                 lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp)); // add player to new child
00098                                 size++;
00099                         }
00100                         else {
00101                                 lastTreeNode = searchLeftmostNode() ;
00102                                 lastTreeNode->childs.push_back( TreeNode(lastTreeNode, destip) );
00103                                 // Add |treeWidth| Players to the new Node. (specified in protocoll)
00104                                 TreeNode tmp;
00105                                 uint max = treeWidth;
00106                                 if( lastTreeNode->leafs.size() < treeWidth ) max= lastTreeNode->leafs.size();
00107                                 for( unsigned int i=0; i < max; ++i) {
00108                                         tmp = lastTreeNode->leafs.front();
00109                                         TreeMessage msg1;
00110                                         msg1.type = 1;
00111                                         msg1.destip = lastTreeNode->destip;
00112                                         msg1.playerip = tmp.destip;
00113                                         if( lastTreeNode->destip != (IPAddress) "127.0.0.1") returnList.push_back( msg1 );
00114                                         
00115                                         TreeMessage msg2;
00116                                         msg2.type = 0;
00117                                         msg2.destip = lastTreeNode->childs.back().destip; //=new Child
00118                                         msg2.playerip = tmp.destip;             
00119                                         returnList.push_back( msg2 );                    
00120                                         tmp.parent =  &(lastTreeNode->childs.back());
00121                                         lastTreeNode->childs.back().leafs.push_back(tmp);
00122                                         lastTreeNode->leafs.pop_front();
00123                                 }
00124                                 lastTreeNode = &( lastTreeNode->childs.back() );
00125                                 if( treeWidth == maxPlayerLeafs ) { // Not enough space for new Node (only if treeWidth=maxPlayerLeafs)
00126                                         waitingNodes.push_back( TreeNode( lastTreeNode, playerId, playerIp) );
00127                                 }
00128                                 else {
00129                                         msg.destip = lastTreeNode->destip;
00130                                         returnList.push_back( msg);
00131                                         lastTreeNode->leafs.push_back( TreeNode( lastTreeNode, playerId, playerIp)); //add Player to the new Node
00132                                         size++;
00133                                 }
00134                                         
00135                         }
00136                 }
00137                 else {
00138                         waitingNodes.push_back( TreeNode( lastTreeNode, playerId, playerIp) );
00139                 }
00140         }
00141         return returnList;
00142 }

std::list< TreeMessage > LoadBalancingTree::removePlayer ( int  playerId  ) 

00144                                                                  {
00145 
00146         actions++;
00147         std::list<TreeMessage> returnList;
00148         NodePos playerPos = searchPlayer(playerId);
00149         if ( playerPos.parent != NULL) {
00150                 size--;
00151                 TreeMessage msg;
00152                 msg.type = 1;
00153                 msg.destip = playerPos.parent->destip;
00154                 msg.playerip = playerPos.it->destip;
00155                 returnList.push_back( msg );
00156                 playerPos.parent->leafs.erase(playerPos.it);
00157                 freed.push_back( playerPos.parent );
00158                 if( freed.size() > maxPlayerLeafs + 1 ) {
00159                         lastTreeNode = searchLastNode();
00160                         // We have to delete one Intermediate TreeNode
00161                         TreeNode tmp;
00162                         while( lastTreeNode->leafs.size() > 0 && freed.size() > 0 ) {
00163                                 if( &*freed.front() != &*lastTreeNode ) {
00164                                         tmp = lastTreeNode->leafs.front();
00165                                         TreeMessage msg1;
00166                                         msg1.type = 0;
00167                                         msg1.playerip = tmp.destip;
00168                                         msg1.destip = freed.front()->destip;
00169                                         tmp.parent = freed.front();
00170                                         freed.front()->leafs.push_back( tmp );
00171                                         returnList.push_back(msg1);
00172                                         TreeMessage msg2;
00173                                         msg2.type = 1;
00174                                         msg2.playerip = tmp.destip;
00175                                         msg2.destip = lastTreeNode->destip;
00176                                         returnList.push_back(msg2);
00177                                         lastTreeNode->leafs.pop_front();
00178                                 }
00179                                 freed.pop_front();
00180                         }
00181                         //Check if we have an entry in free by ourself
00182                         std::list<TreeNode*>::iterator f = freed.begin();
00183                         while( f != freed.end() ) {
00184                                 if( &**f == &*lastTreeNode ) {
00185                                         f = freed.erase(f);
00186                                 }
00187                                 else { ++f; }
00188                         }
00189                         //check if we're in replace 
00190                         f = inReplace.begin();
00191                         while( f != inReplace.end() ) {
00192                                 if( &**f == &*lastTreeNode ) {
00193                                         f = inReplace.erase(f);
00194                                 }
00195                                 else { ++f; }
00196                         }
00197                         //Remove us from usedIntermediateNodes
00198                         std::list<IPAddress>::iterator ip = usedIntermediateNodes.begin();
00199                         while( ip != usedIntermediateNodes.end() ) {
00200                                 if( *ip == lastTreeNode->destip ) {
00201                                         usedIntermediateNodes.erase(ip);
00202                                         break;
00203                                 }
00204                                 else { ++ip; }
00205                         }
00206                         TreeMessage msg3;
00207                         msg3.type=3;
00208                         msg3.destip = lastTreeNode->destip;
00209                         returnList.push_back( msg3 );
00210                         
00211                         TreeNode* toRemoved = lastTreeNode;
00212                         lastTreeNode = lastTreeNode->parent;
00213                         if( lastTreeNode == NULL ) lastTreeNode = root;
00214                         for(lastTreeNode->ic = lastTreeNode->childs.begin() ; lastTreeNode->ic != lastTreeNode->childs.end(); ++(lastTreeNode->ic) ) {
00215                                 if( &*(lastTreeNode->ic) == toRemoved ) {
00216                                         lastTreeNode->childs.erase(lastTreeNode->ic);
00217                                         break;
00218                                 }
00219                         }
00220                                 
00221                         if( lastTreeNode->childs.size() > 0 ) {
00222                                 lastTreeNode = &( lastTreeNode->childs.back() );
00223                         }
00224                 }
00225         }
00226         else {
00227                 bool found = false;
00228                 for( iW = waitingNodes.begin(); iW != waitingNodes.end(); ++iW ) {
00229                         if( iW->playerId == playerId ) {
00230                                 waitingNodes.erase(iW);
00231                                 found = true;
00232                                 break;
00233                         }
00234                 }
00235         }
00236         return returnList;
00237 }

std::list< TreeMessage > LoadBalancingTree::removePlayer ( IPAddress  playerIp  ) 

00239                                                                        {
00240         actions++;
00241         std::list<TreeMessage> returnList;      
00242         NodePos playerPos = searchPlayer(playerIp);
00243         if( playerPos.parent != NULL ) {
00244                 returnList = removePlayer( playerPos.it->playerId );
00245                 std::list<TreeNode*> toReplace = searchNodes( playerIp);
00246                 if( toReplace.size() > 0 ) {
00247                         while( toReplace.size() > 0 ) {
00248                                 inReplace.push_back ( toReplace.front() );
00249                                 toReplace.pop_front();
00250                                 TreeMessage msg;
00251                                 msg.type = 2;
00252                                 returnList.push_back( msg );    
00253                         }
00254                 }
00255         }
00256         return returnList;
00257 }

std::list< IPAddress > LoadBalancingTree::getList (  ) 

00278                                               {
00279         std::list<IPAddress> ipList; 
00280         for(root->ic = root->childs.begin(); root->ic != root->childs.end(); ++root->ic) {
00281                 ipList.push_back(root->ic->destip);
00282         }
00283         for(root->il = root->leafs.begin(); root->il != root->leafs.end() ; ++root->il) {
00284                 ipList.push_back(root->il->destip);
00285         }
00286         for( iR = inReplace.begin(); iR != inReplace.end(); ++iR) {
00287                 TreeNode* visit = *iR;
00288                 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++(visit->ic) ) {
00289                         ipList.push_back( visit->ic->destip);
00290                 }
00291                 for( visit->il = visit->leafs.begin(); visit->il != visit->leafs.end(); ++(visit->il) ) {
00292                         ipList.push_back( visit->il->destip);
00293                 }
00294         }
00295         
00296         for( iW = waitingNodes.begin(); iW != waitingNodes.end(); ++iW) {
00297                 ipList.push_back( iW->destip );
00298         }
00299         return ipList;
00300 }

std::list< PlayerNode > LoadBalancingTree::getAllPlayers (  ) 

00303                                                      {
00304         std::list<PlayerNode> returnList;
00305         
00306         std::list<TreeNode*> queue;
00307         std::list<TreeNode*>::iterator q;
00308         queue.push_back( root );
00309         TreeNode* visit;
00310         std::list<TreeNode>::iterator il;
00311         std::list<TreeNode>::iterator ic;
00312 
00313         while ( queue.size() > 0 ) {    
00314                 visit = queue.front();
00315                 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) {
00316                         returnList.push_back( PlayerNode( il->playerId, il->destip, 0, 0) );
00317                 }
00318                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00319                         queue.push_back( &(*ic) );
00320                 }
00321                 queue.pop_front();
00322         }
00323         return returnList;
00324 }

std::list< IPAddress > LoadBalancingTree::getAllNodes (  ) 

00326                                                   {
00327         std::list<IPAddress> returnList;
00328         
00329         std::list<TreeNode*> queue;
00330         std::list<TreeNode*>::iterator q;
00331         queue.push_back( root );
00332         TreeNode* visit;
00333         std::list<TreeNode>::iterator il;
00334         std::list<TreeNode>::iterator ic;
00335 
00336         while ( queue.size() > 0 ) {    
00337                 visit = queue.front();
00338                 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) {
00339                         returnList.push_back( il->destip);
00340                 }
00341                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00342                         queue.push_back( &(*ic) );
00343                         returnList.push_back(ic->destip);
00344                 }
00345                 queue.pop_front();
00346         }
00347         return returnList;
00348 }

std::list< IPAddress > LoadBalancingTree::getAllIntNodes (  ) 

00349                                                      {
00350         std::list<IPAddress> returnList;        
00351         std::list<TreeNode*> queue;
00352         std::list<TreeNode*>::iterator q;
00353         queue.push_back( root );
00354         TreeNode* visit;
00355         std::list<TreeNode>::iterator ic;
00356 
00357         while ( queue.size() > 0 ) {    
00358                 visit = queue.front();
00359                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00360                         queue.push_back( &(*ic) );
00361                         returnList.push_back(ic->destip);
00362                 }
00363                 queue.pop_front();
00364         }
00365         return returnList;
00366 }

std::list< TreeMessage > LoadBalancingTree::addIntermediateNode ( IPAddress  destip  ) 

00498                                                                             {
00499         std::list<TreeMessage> returnList;
00500         lock = 0;
00501         if( inReplace.size() > 0 ) {
00502                 returnList = replace(destip);
00503         }
00504         else {
00505                 readyIntermediateNodes.push_back( destip );
00506                 uint i = 0;
00507                 while( waitingNodes.size() > 0 && i < maxPlayerLeafs ) {
00508                         TreeNode tmp2 = waitingNodes.front();
00509                         waitingNodes.pop_front();
00510                         std::list<TreeMessage> tmp = this->addPlayer( tmp2.playerId, tmp2.destip);
00511                         while( tmp.size() > 0 ) {
00512                                 returnList.push_back( tmp.front() );
00513                                 tmp.pop_front();
00514                         }
00515                         i++;
00516                 }
00517         }
00518         return returnList;
00519 
00520 }

std::list< IPAddress > LoadBalancingTree::exchangeNode ( IPAddress  oldNodeIp,
IPAddress  newNodeIp 
)

00259                                                                                            {
00260         std::list<IPAddress> returnList;        
00261         std::list<TreeNode*> toReplace = searchNodes(oldNodeIp);
00262         while( toReplace.size() > 0 ) {
00263                 inReplace.push_front( toReplace.front() );
00264                 std::list<TreeNode>::iterator i;
00265                 for( i = toReplace.front()->childs.begin() ; i != toReplace.front()->childs.end(); ++i) {
00266                         returnList.push_back( i->destip);
00267                 }
00268                 for( i = toReplace.front()->leafs.begin() ; i != toReplace.front()->leafs.end(); ++i) {
00269                         returnList.push_back( i->destip);
00270                 }
00271                 replace(newNodeIp);
00272                 toReplace.pop_front(); //missing messages
00273 
00274         }
00275         return returnList;      
00276 }

std::list< TreeMessage > LoadBalancingTree::replace ( IPAddress  newNodeIp  ) 

00480                                                                    {
00481         std::list<TreeMessage> returnList;
00482         if( inReplace.size() > 0 ) {
00483                 TreeNode* node = inReplace.front();
00484                 node->destip = newNodeIp;
00485                 for(node->il = node->leafs.begin(); node->il != node->leafs.end(); ++(node->il) ) {
00486                         TreeMessage msg1;
00487                         msg1.type = 0;
00488                         msg1.playerip = node->il->destip;
00489                         msg1.destip = newNodeIp;
00490                         returnList.push_back(msg1);
00491                 }
00492                 replacedIntermediateNodes++;
00493                 inReplace.pop_front();
00494         }
00495         return returnList;
00496 }

std::list< TreeNode > LoadBalancingTree::serialize (  ) 

00522                                                {
00523         std::list<TreeNode> returnVector;
00524         std::list<TreeNode*> queue;
00525         queue.push_back( root );
00526         std::list<TreeNode>::iterator ic;
00527         std::list<TreeNode>::iterator il;
00528         std::list<TreeNode*>::iterator ir;
00529         std::list<IPAddress>::iterator ip;
00530         TreeNode* visit;
00531         while ( queue.size() > 0 ) {
00532                 visit = queue.front();
00533                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00534                         queue.push_back( &(*ic) );
00535                         returnVector.push_back(TreeNode(-1, ic->destip));
00536                 }
00537                 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) {
00538                         returnVector.push_back( TreeNode(il->playerId, il->destip) );
00539                 }
00540                 returnVector.push_back( TreeNode(-5, (IPAddress) "127.0.0.1" ) );
00541                 queue.pop_front();
00542         }
00543         returnVector.push_back( TreeNode(-6, (IPAddress) "127.0.0.1" ) );
00544         for(ip = readyIntermediateNodes.begin() ; ip != readyIntermediateNodes.end() ; ++ip) {
00545                 returnVector.push_back( TreeNode( -3, (*ip) ) );
00546         }
00547         returnVector.push_back( TreeNode(-7, (IPAddress) "127.0.0.1" ) );
00548         for(il = waitingNodes.begin(); il != waitingNodes.end(); ++il ) {
00549                 returnVector.push_back( TreeNode(il->playerId, il->destip) );
00550         }
00551         returnVector.push_back( TreeNode(-8, (IPAddress) "127.0.0.1" ) );
00552 
00553         for(ir = inReplace.begin(); ir != inReplace.end(); ++ir) {
00554                 returnVector.push_back( TreeNode( -2 , (*ir)->destip ) );
00555         }
00556         returnVector.push_back( TreeNode( -10 - replacedIntermediateNodes, (IPAddress) "127.0.0.1") );
00557         return returnVector;
00558 }

void LoadBalancingTree::rebuildTree ( std::list< TreeNode source  ) 

00560                                                             {
00561         std::list<TreeNode>::iterator i= source.begin();
00562         this->root->parent = NULL;
00563         int state=0;
00564         std::list<TreeNode*> queue;
00565         std::list<TreeNode*>::iterator q;
00566         queue.push_back( root );
00567         for( i = source.begin(); i != source.end(); ++i ) {
00568                 if( state == 0) {
00569                         if( i->playerId == -1 ) {
00570                                 // create a new child in queue.front
00571                                 (queue.front())->childs.push_back( TreeNode( queue.front(), i->playerId, i->destip ) );
00572                                 queue.push_back( &((queue.front())->childs.back()) );
00573                         }
00574                         else if( i->playerId == -5 ) {
00575                                 // go to next child
00576                                 uint k=0;
00577                                 // has actual node some free leaf slots?
00578                                 for(k=queue.front()->leafs.size(); k < maxPlayerLeafs - treeWidth; ++k) {
00579                                         freed.push_back(queue.front());
00580                                 }
00581                                 queue.pop_front();
00582                         }
00583                         else if ( i->playerId > 0) {
00584                                 (queue.front())->leafs.push_back( TreeNode( queue.front(), i->playerId, i->destip ) );
00585                         }
00586                         else if ( i->playerId == -6 ) {
00587                                 state = 1;
00588                         }
00589                 }
00590                 else if ( state == 1 ) {
00591                         if ( i->playerId == -3 ) {
00592                                 readyIntermediateNodes.push_back( i->destip );
00593                         }
00594                         else if ( i->playerId == -7 ) {
00595                                 state = 2;
00596                         }
00597                 }
00598                 else if ( state == 2) {
00599                         if ( i->playerId > 0 ) {
00600                                 waitingNodes.push_back( TreeNode(queue.front(), i->playerId, i->destip ) );
00601                         }
00602                         else if( i->playerId == -8 ) {
00603                                 state = 3;
00604                         }
00605                 }
00606                 else if ( state == 3) {
00607                         if ( i->playerId == -2 ) {
00608                                 std::list<TreeNode*> pos = searchNodes( i->destip );
00609                                 std::list<TreeNode*>::iterator p;
00610                                 for( p = pos.begin(); p != pos.end(); ++p ) {
00611                                         if( (*p)->playerId == -1 ) {
00612                                                 inReplace.push_back( *p );
00613                                         }
00614                                 }
00615                         }
00616                         else if( i->playerId < -10) {
00617                                 replacedIntermediateNodes = abs(i->playerId) - 10;
00618                         }
00619                 }
00620         }
00621         lastTreeNode = searchLeftmostNode();
00622 }

void LoadBalancingTree::printTree (  ) 

00623                                   {
00624         std::cout << root << " " << lastTreeNode << " " << " " << waitingNodes.size() << " " << inReplace.size() << " " <<freed.size() << "\n"; 
00625         std::list<TreeNode*> queue;
00626         queue.push_back( root );
00627         std::list<TreeNode>::iterator ic;
00628         TreeNode* visit;
00629         int num= 0;
00630         int layer=0;
00631         while ( queue.size() > 0 ) {
00632                 visit = queue.front();
00633                 std::cout << "NodeNum: " << num << " ChildSize: " << visit->childs.size() << " LeafSize: " << visit->leafs.size() << " NodeIp: " << visit->destip << " | ";
00634                 if( num % treeWidth == 0) std::cout << " ### ";
00635                 if( num == pow(treeWidth, layer)  || num == 0 ) {
00636                         std::cout << "\n\n";
00637                         layer++;
00638                 }
00639                 num++;
00640 
00641                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00642                         queue.push_back( &(*ic) );
00643                 }
00644                 queue.pop_front();
00645         }               
00646 }

NodePos LoadBalancingTree::searchPlayer ( int  playerId  )  [protected]

00368                                                     {
00369         std::list<TreeNode*> queue;
00370         std::list<TreeNode*>::iterator q;
00371         queue.push_back( root );
00372         TreeNode* visit;
00373         std::list<TreeNode>::iterator il;
00374         std::list<TreeNode>::iterator ic;
00375 
00376         while ( queue.size() > 0 ) {            
00377                 visit = queue.front();
00378                 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) {
00379                         if( il->playerId == playerId ) {
00380                                 NodePos playerPos;
00381                                 playerPos.parent = il->parent;
00382                                 playerPos.it = il;
00383                                 return playerPos;
00384                         }
00385                 }
00386                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00387                         queue.push_back( &(*ic) );
00388                 }
00389                 queue.pop_front();
00390         }
00391         NodePos playerPos;
00392         playerPos.parent = NULL;
00393         return playerPos;
00394 }

NodePos LoadBalancingTree::searchPlayer ( IPAddress  playerIp  )  [protected]

00398                                                           {
00399         std::list<TreeNode*> queue;
00400         std::list<TreeNode*>::iterator q;
00401         queue.push_back( root );
00402         TreeNode* visit;
00403         std::list<TreeNode>::iterator il;
00404         std::list<TreeNode>::iterator ic;
00405 
00406         while ( queue.size() > 0 ) {
00407                 visit = queue.front();
00408                 for( il = visit->leafs.begin(); il != visit->leafs.end(); ++il) {
00409                         if( il->destip == playerIp ) {
00410                                 NodePos playerPos;
00411                                 playerPos.parent = il->parent;
00412                                 playerPos.it = il;
00413                                 return playerPos;
00414                         }
00415                 }
00416                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00417                         queue.push_back( &(*ic) );
00418                 }
00419                 queue.pop_front();
00420         }
00421         NodePos playerPos;
00422         playerPos.parent = NULL;
00423         return playerPos;
00424 }

std::list< TreeNode * > LoadBalancingTree::searchNodes ( IPAddress  playerIp  )  [protected]

00460                                                                   {
00461         std::list<TreeNode*> returnList;
00462         std::list<TreeNode*> queue;
00463         std::list<TreeNode*>::iterator q;
00464         queue.push_back( root );
00465         std::list<TreeNode>::iterator ic;
00466         TreeNode* visit;
00467         while( queue.size() > 0 ) {
00468                 visit = queue.front();
00469                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00470                         if( ic->destip == destip ) {
00471                                 returnList.push_back( &(*ic) );
00472                         }
00473                         queue.push_back( &(*ic) );
00474                 }
00475                 queue.pop_front();
00476         }
00477         return returnList;
00478 }

TreeNode * LoadBalancingTree::searchLeftmostNode (  )  [protected]

00426                                                 {
00427         std::list<TreeNode*> queue;
00428         std::list<TreeNode*>::iterator q;
00429         queue.push_back( root );
00430         TreeNode* visit;
00431         while ( queue.size() > 0 ) {
00432                 visit = queue.front();
00433                 if( visit->childs.size() < treeWidth ) {
00434                         return visit;
00435                 }
00436                 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++visit->ic) {
00437                         queue.push_back( &(*(visit->ic)) );
00438                 }
00439                 queue.pop_front();
00440         }
00441         return root;
00442 }

TreeNode * LoadBalancingTree::searchLastNode (  )  [protected]

00444                                             {
00445         std::list<TreeNode*> queue;
00446         std::list<TreeNode*>::iterator q;
00447         queue.push_back( root );
00448         TreeNode* visit = root;
00449         while ( queue.size() > 0 ) {
00450                 visit = queue.front();
00451                 for( visit->ic = visit->childs.begin(); visit->ic != visit->childs.end(); ++visit->ic) {
00452                         queue.push_back( &(*(visit->ic)) );
00453                 }
00454                 queue.pop_front();
00455         }
00456         return visit;
00457 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  Stream,
LoadBalancingTree  t 
) [friend]

00648                                                                 {
00649         std::ostream& output = Stream << "Size: " << t.size << "readyIntermediateNodes " << t.readyIntermediateNodes.size() << "InReplace: " << t.inReplace.size() << " Freed: " << t.freed.size() << "\n\n";
00650         
00651         std::list<TreeNode*> queue;
00652         queue.push_back( t.root );
00653         std::list<TreeNode>::iterator ic;
00654         TreeNode* visit;
00655         int num= 0;
00656         int layer=0;
00657         while ( queue.size() > 0 ) {
00658                 visit = queue.front();
00659                 output << "NodeNum: " << num << " ChildSize: " << visit->childs.size() << " LeafSize: " << visit->leafs.size() << " NodeIp: " << visit->destip << " | ";
00660                 if( num % t.treeWidth == 0) output << " ### ";
00661                 if( num == pow(t.treeWidth, layer)  || num == 0 ) {
00662                         output << "\n\n";
00663                         layer++;
00664                 }
00665                 num++;
00666 
00667                 for( ic = visit->childs.begin(); ic != visit->childs.end(); ++ic) {
00668                         queue.push_back( &(*ic) );
00669                 }
00670                 queue.pop_front();
00671         }               
00672         return output;
00673 }


Member Data Documentation

unsigned int LoadBalancingTree::size

std::list<IPAddress> LoadBalancingTree::readyIntermediateNodes

std::list<IPAddress> LoadBalancingTree::usedIntermediateNodes

int LoadBalancingTree::replacedIntermediateNodes

TreeNode* LoadBalancingTree::root [protected]

TreeNode* LoadBalancingTree::lastTreeNode [protected]

std::list<TreeNode> LoadBalancingTree::waitingNodes [protected]

std::list<TreeNode>::iterator LoadBalancingTree::iW [protected]

std::list<TreeNode*> LoadBalancingTree::freed [protected]

std::list<TreeNode*>::iterator LoadBalancingTree::f [protected]

std::list<TreeNode*> LoadBalancingTree::inReplace [protected]

std::list<TreeNode*>::iterator LoadBalancingTree::iR [protected]

std::list<IPAddress>::iterator LoadBalancingTree::rI [protected]

unsigned int LoadBalancingTree::maxPlayerLeafs [protected]

unsigned int LoadBalancingTree::treeWidth [protected]

int LoadBalancingTree::lock [protected]

int LoadBalancingTree::subSpaceId [protected]

int LoadBalancingTree::actions [protected]


The documentation for this class was generated from the following files:
Generated on Tue Jul 24 16:51:18 2007 for ITM OverSim by  doxygen 1.5.1