PubSubSubspaceResponsible Class Reference

#include <PubSubSubspace.h>

Inheritance diagram for PubSubSubspaceResponsible:

PubSubSubspaceIntermediate PubSubSubspace

List of all members.

Public Member Functions

 PubSubSubspaceResponsible (PubSubSubspaceId id)
void setBackupNode (NodeHandle b)
const NodeHandlegetBackupNode ()
void setHeartbeatTimer (PubSubTimer *t)
PubSubTimer * getHeartbeatTimer ()
int getHeartbeatFailCount ()
void incHeartbeatFailCount ()
void resetHeartbeatFailCount ()
int getTotalChildrenCount ()
void fixTotalChildrenCount ()
int getNumIntermediates ()
IntermediateNodegetNextFreeIntermediate ()
virtual bool addChild (NodeHandle node)
virtual IntermediateNoderemoveAnyChild (NodeHandle node)

Public Attributes

std::deque< IntermediateNodeintermediateNodes
std::map< NodeHandle, bool > cachedChildren
std::deque< PubSubMoveMessage * > waitingMoveMessages

Static Public Attributes

static unsigned int maxChildren

Protected Attributes

int totalChildrenCount
NodeHandle backupNode
PubSubTimer * heartbeatTimer
int heartbeatFailCount

Friends

std::ostream & operator<< (std::ostream &o, const PubSubSubspaceResponsible &subspace)

Classes

class  IntermediateNode


Constructor & Destructor Documentation

PubSubSubspaceResponsible::PubSubSubspaceResponsible ( PubSubSubspaceId  id  ) 

00064     : PubSubSubspaceIntermediate( id )
00065 {
00066     backupNode = NodeHandle::UNSPECIFIED_NODE;
00067     heartbeatTimer = NULL;
00068     heartbeatFailCount = 0;
00069     totalChildrenCount = 0;
00070 }


Member Function Documentation

void PubSubSubspaceResponsible::setBackupNode ( NodeHandle  b  )  [inline]

const NodeHandle& PubSubSubspaceResponsible::getBackupNode (  )  [inline]

void PubSubSubspaceResponsible::setHeartbeatTimer ( PubSubTimer *  t  )  [inline]

Referenced by PubSubMMOG::handleBackupCall().

00103 { heartbeatTimer = t; }

PubSubTimer* PubSubSubspaceResponsible::getHeartbeatTimer (  )  [inline]

00104 { return heartbeatTimer; }

int PubSubSubspaceResponsible::getHeartbeatFailCount (  )  [inline]

00106 { return heartbeatFailCount; }

void PubSubSubspaceResponsible::incHeartbeatFailCount (  )  [inline]

00107 { ++heartbeatFailCount; }

void PubSubSubspaceResponsible::resetHeartbeatFailCount (  )  [inline]

00108 { heartbeatFailCount = 0; }

int PubSubSubspaceResponsible::getTotalChildrenCount (  )  [inline]

void PubSubSubspaceResponsible::fixTotalChildrenCount (  ) 

int PubSubSubspaceResponsible::getNumIntermediates (  )  [inline]

PubSubSubspaceResponsible::IntermediateNode * PubSubSubspaceResponsible::getNextFreeIntermediate (  ) 

Referenced by PubSubMMOG::unsubscribeChild().

00107 {
00108     std::deque<IntermediateNode>::iterator it;
00109     for( it = intermediateNodes.begin(); it != intermediateNodes.end(); ++it ){
00110         if( it->node.isUnspecified() ) continue;
00111         int childIntermediates = intermediateNodes.size() - (it - intermediateNodes.begin() +1 )* maxChildren;
00112         if( childIntermediates < 0 ) childIntermediates = 0;
00113         if( it->children.size() + it->waitingChildren + childIntermediates < maxChildren ) return &*it;
00114     }
00115     return NULL;
00116 }

bool PubSubSubspaceResponsible::addChild ( NodeHandle  node  )  [virtual]

Reimplemented from PubSubSubspaceIntermediate.

Referenced by PubSubMMOG::handleSubscriptionBackup().

00073 {
00074     if( getNumChildren() + getNumIntermediates() < (int) maxChildren ) {
00075         // we still have room in our children list, add to our own
00076         if( PubSubSubspaceIntermediate::addChild( child ) ){
00077             ++totalChildrenCount;
00078         }
00079         return true;
00080     } else {
00081         // Child has to go to an intermediate
00082         if( cachedChildren.insert( make_pair(child, false) ).second ){
00083             ++totalChildrenCount;
00084         }
00085         return false;
00086     }
00087 }

PubSubSubspaceResponsible::IntermediateNode * PubSubSubspaceResponsible::removeAnyChild ( NodeHandle  node  )  [virtual]

Referenced by PubSubMMOG::unsubscribeChild().

00090 {
00091     if( removeChild( child ) || cachedChildren.erase( child )){
00092         --totalChildrenCount;
00093         return NULL;
00094     } else {
00095         std::deque<IntermediateNode>::iterator it;
00096         for( it = intermediateNodes.begin(); it != intermediateNodes.end(); ++it ){
00097             if( it->children.erase( child ) ) {
00098                 --totalChildrenCount;
00099                 return &*it;
00100             }
00101         }
00102         return NULL;
00103     }
00104 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  o,
const PubSubSubspaceResponsible subspace 
) [friend]

00128 {
00129     o << dynamic_cast<const PubSubSubspaceIntermediate&>(subspace) << "  BackupNode: " << subspace.backupNode;
00130     o << "\n  cachedChildren:\n";
00131     map<NodeHandle, bool>::const_iterator iit;
00132     for( iit = subspace.cachedChildren.begin(); iit != subspace.cachedChildren.end(); ++iit ){
00133         o << "    " << iit->first << " waiting: " << iit->second << "\n";
00134     }
00135     o << "  totalChildrenCount: " << subspace.totalChildrenCount;
00136     o << "\n  IntermediateNodes:\n";
00137     std::deque<PubSubSubspaceResponsible::IntermediateNode>::const_iterator it;
00138     for( it = subspace.intermediateNodes.begin(); it != subspace.intermediateNodes.end(); ++it ){
00139         o << "    " << it->node;
00140             o << "\n    Children:\n";
00141         for( set<NodeHandle>::iterator iit = it->children.begin(); iit != it->children.end(); ++iit ){
00142             o << "      " << *iit << "\n";
00143         }
00144     }
00145     return o;
00146 }


Member Data Documentation

std::deque<PubSubMoveMessage*> PubSubSubspaceResponsible::waitingMoveMessages


The documentation for this class was generated from the following files:

Generated on Fri Sep 19 13:05:08 2008 for ITM OverSim by  doxygen 1.5.5