ResponsibleNodeData Class Reference

#include <ResponsibleNodeData.h>

List of all members.

Public Member Functions

 ~ResponsibleNodeData ()
 ResponsibleNodeData (SubSpace subSpace, int maxPlayerLeafs, int treeWidth, double time)
 ResponsibleNodeData (SubSpace subSpace, int maxPlayerLeafs, int treeWidth, double time, std::list< TreeNode > tree)
std::list< TreeMessagesubscribe (PlayerNode player)
std::list< TreeMessageunsubscribe (int playerId)
std::list< TreeMessageunsubscribe (IPAddress playerIp)
std::list< IPAddress > getList ()
std::list< TreeNodegetPlayerList ()
std::list< IPAddress > getNodeList ()
std::list< TreeMessageaddIntermediateNode (IPAddress intermediateIp)
std::list< IPAddress > replaceIntermediateNode (IPAddress oldip, IPAddress newip)
void addEvent (Event event)
void setNeighbor (int direction, IPAddress resp_ip)
int getEventListSize ()
std::vector< EventendTimeSlot (double now)
int getPlayerListSize ()
std::list< IPAddress > getAllIntNodes ()
SubSpace getSubSpace ()
void setSubSpace (SubSpace subSpace)
void setBackupIp (IPAddress backupIp)
IPAddress getBackupIp ()
int getId ()
double getDroppedEvents ()
int getReplacedIntermediateNodeCount ()
void setMaxPlayerLeafs (int maxPlayerLeafs)
void setTreeWidth (int treeWidth)

Protected Attributes

std::list< Eventeventlist
std::list< Event >
::iterator 
it
std::list< IPAddress > readyIntermediateNodes
std::list< IPAddress >
::iterator 
rdyIp
std::list< PlayerNodetmpList
std::list
< PlayerNode >
::iterator 
tmpListIt
GameState gamestate
int treeWidth
int maxPlayerLeafs
double last_timeslot
int dropped_events
int eventCount
LoadBalancingTreetree
SubSpace subSpace

Private Member Functions

PlayerNodegetPlayerbyId (int id)

Friends

std::ostream & operator<< (std::ostream &Stream, ResponsibleNodeData r)


Constructor & Destructor Documentation

ResponsibleNodeData::~ResponsibleNodeData (  ) 

00019                                           {
00020         // Free Playerlist
00021         //delete tree;
00022         // Free eventlist
00023         eventlist.clear();
00024 }

ResponsibleNodeData::ResponsibleNodeData ( SubSpace  subSpace,
int  maxPlayerLeafs,
int  treeWidth,
double  time 
)

00026                                                                                                             {
00027         this->subSpace = subSpace;
00028         this->maxPlayerLeafs = maxPlayerLeafs;
00029         this->treeWidth = treeWidth;
00030         this->last_timeslot = time;
00031         this->tree = new LoadBalancingTree( subSpace.getId(), maxPlayerLeafs, treeWidth );
00032         gamestate = GameState();
00033         dropped_events=0;
00034         eventCount = 0;
00035 }

ResponsibleNodeData::ResponsibleNodeData ( SubSpace  subSpace,
int  maxPlayerLeafs,
int  treeWidth,
double  time,
std::list< TreeNode tree 
)

00037                                                                                                                                     {
00038         this->subSpace = subSpace;
00039         this->maxPlayerLeafs = maxPlayerLeafs;
00040         this->treeWidth = treeWidth;
00041         this->last_timeslot = time;
00042         gamestate = GameState();
00043         dropped_events=0;
00044         eventCount = 0;
00045         this->tree = new LoadBalancingTree( subSpace.getId(), maxPlayerLeafs, treeWidth );
00046         this->tree->rebuildTree(tree);
00047 };


Member Function Documentation

std::list< TreeMessage > ResponsibleNodeData::subscribe ( PlayerNode  player  ) 

00049                                                                      {
00050         /*std::list<TreeMessage> tmp;
00051         for(tmpListIt=tmpList.begin(); tmpListIt != tmpList.end(); ++tmpListIt) {
00052                 if(tmpListIt->getId() == player.getId() ) {
00053                         return tmp;
00054                 }
00055         }
00056         tmpList.push_back(player);
00057         return tmp;*/
00058         return tree->addPlayer(player.getId() , player.getIp() );
00059 }

std::list< TreeMessage > ResponsibleNodeData::unsubscribe ( int  playerId  ) 

00061                                                                   {
00062         /*
00063         std::list<TreeMessage> tmp;
00064         for(tmpListIt=tmpList.begin(); tmpListIt != tmpList.end(); ++tmpListIt) {
00065                         if(tmpListIt->getId() == playerId) {
00066                                 tmpList.erase(tmpListIt);
00067                                 return tmp;
00068                 }
00069         }
00070         return tmp;
00071         */
00072         std::list<TreeMessage> msgList = tree->removePlayer(playerId);
00073         return msgList;
00074 }

std::list< TreeMessage > ResponsibleNodeData::unsubscribe ( IPAddress  playerIp  ) 

00076                                                                         {
00077 /*      std::list<TreeMessage> tmp;
00078         for(tmpListIt=tmpList.begin(); tmpListIt != tmpList.end(); ++tmpListIt) {
00079                         if(tmpListIt->getIp() == playerIp) {
00080                                 tmpList.erase(tmpListIt);
00081                                 return tmp;
00082                 }
00083         }
00084         return tmp;
00085 */
00086         std::list<TreeMessage> msgList = tree->removePlayer(playerIp);
00087         return msgList;
00088 }

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

00138                                                 {
00139         return tree->getList();
00140 }

std::list< TreeNode > ResponsibleNodeData::getPlayerList (  ) 

00090                                                      {
00091         return tree->serialize() ;
00092 }

std::list< IPAddress > ResponsibleNodeData::getNodeList (  ) 

00093                                                     {
00094         return tree->getAllNodes();
00095 }

std::list< TreeMessage > ResponsibleNodeData::addIntermediateNode ( IPAddress  intermediateIp  ) 

00158                                                                                        {
00159         return tree->addIntermediateNode(intermediateIp);       
00160 }

std::list< IPAddress > ResponsibleNodeData::replaceIntermediateNode ( IPAddress  oldip,
IPAddress  newip 
)

00162                                                                                                 {
00163         return tree->exchangeNode(oldip, newip);
00164 }

void ResponsibleNodeData::addEvent ( Event  event  ) 

00104                                               {
00105         eventCount++;
00106         if( event.getTimeStamp() > last_timeslot ) {
00107                 eventlist.push_back(event);
00108         }
00109         else { dropped_events++; }
00110 }

void ResponsibleNodeData::setNeighbor ( int  direction,
IPAddress  resp_ip 
)

00142                                                                       {
00143         this->subSpace.setNeighbor(direction, resp_ip);
00144 }

int ResponsibleNodeData::getEventListSize (  ) 

00112                                           {
00113         return eventlist.size();
00114 }

std::vector< Event > ResponsibleNodeData::endTimeSlot ( double  now  ) 

00116                                                             {
00117         std::vector<Event> ordered_eventlist;
00118         eventlist.sort();
00119         while( eventlist.size() > 0 ) {
00120                 ordered_eventlist.push_back( eventlist.front() );
00121                 eventlist.pop_front();
00122         }
00123         ordered_eventlist.push_back(Event(now, -1 , NPC, 0 , 0 ) );
00124         subSpace.setTimeSlot( subSpace.getTimeSlot() + 1 );
00125         last_timeslot = now;
00126         return ordered_eventlist;
00127 }

int ResponsibleNodeData::getPlayerListSize (  ) 

00134                                            {
00135         return tree->size;
00136 }

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

00096                                                        {
00097         return tree->getAllIntNodes();
00098 }

SubSpace ResponsibleNodeData::getSubSpace (  ) 

00130                                           {
00131         return subSpace;
00132 }

void ResponsibleNodeData::setSubSpace ( SubSpace  subSpace  ) 

00099                                                         {
00100         if( this->subSpace.getId() == subSpace.getId() ) {
00101                 this->subSpace = subSpace;
00102         }
00103 }

void ResponsibleNodeData::setBackupIp ( IPAddress  backupIp  ) 

00151                                                         {
00152         this->subSpace.setBackupIp(backupIp);
00153 }

IPAddress ResponsibleNodeData::getBackupIp (  ) 

00154                                            {
00155         return this->subSpace.getBackupIp();
00156 }

int ResponsibleNodeData::getId (  ) 

00147                                {
00148         return this->subSpace.getId();
00149 }

double ResponsibleNodeData::getDroppedEvents (  ) 

00168                                              {
00169         double ret = -1;
00170         if (eventCount > 0) {
00171                 ret = (double) dropped_events / eventCount;
00172         }
00173         eventCount = 0;
00174         dropped_events = 0;
00175         return ret;
00176 }

int ResponsibleNodeData::getReplacedIntermediateNodeCount (  ) 

00165                                                           {
00166         return tree->replacedIntermediateNodes;
00167 }

void ResponsibleNodeData::setMaxPlayerLeafs ( int  maxPlayerLeafs  ) 

void ResponsibleNodeData::setTreeWidth ( int  treeWidth  ) 

PlayerNode* ResponsibleNodeData::getPlayerbyId ( int  id  )  [private]


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  Stream,
ResponsibleNodeData  r 
) [friend]

00179 {
00180     return Stream << "ID:" << r.getId() << " Players: " << r.tree->size << " Events: " << r.getEventListSize() << " Dropped Events " << r.getDroppedEvents() << " MaxPlayerLeafs " << r.maxPlayerLeafs << " Real Intermediate Size: " <<  "\nNeighbors: " << r.getSubSpace() << r.tree ;
00181 }


Member Data Documentation

std::list<Event> ResponsibleNodeData::eventlist [protected]

std::list<Event>::iterator ResponsibleNodeData::it [protected]

std::list<IPAddress> ResponsibleNodeData::readyIntermediateNodes [protected]

std::list<IPAddress>::iterator ResponsibleNodeData::rdyIp [protected]

std::list<PlayerNode> ResponsibleNodeData::tmpList [protected]

std::list<PlayerNode>::iterator ResponsibleNodeData::tmpListIt [protected]

GameState ResponsibleNodeData::gamestate [protected]

int ResponsibleNodeData::treeWidth [protected]

int ResponsibleNodeData::maxPlayerLeafs [protected]

double ResponsibleNodeData::last_timeslot [protected]

int ResponsibleNodeData::dropped_events [protected]

int ResponsibleNodeData::eventCount [protected]

LoadBalancingTree* ResponsibleNodeData::tree [protected]

SubSpace ResponsibleNodeData::subSpace [protected]


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:30 2008 for ITM OverSim by  doxygen 1.5.3