Vast Class Reference

#include <Vast.h>

Inheritance diagram for Vast:

BaseOverlay RpcListener List of all members.

Detailed Description

An overlay network based on voronoi diagrams.


Public Member Functions

virtual ~Vast ()
virtual void initializeOverlay (int stage)
 Initializes derived-class-attributes.
virtual void finishOverlay ()
 collects statistical data in derived class
virtual void handleUDPMessage (BaseOverlayMessage *msg)
 Processes messages from underlay.
virtual void handleTimerEvent (cMessage *msg)
 Processes "timer" self-messages.
virtual void handleAppMessage (cMessage *msg)
 Processes non-commonAPI messages.
virtual void receiveChangeNotification (int category, cPolymorphic *details)
int getState ()
double getAOI ()
Point getPosition ()
NeighborsListgetList ()

Protected Member Functions

void sendToApp (SimpleClientMessage *scMsg)
void sendMessage (VastMessage *vastMsg, NodeHandle destAddr)
void setBootstrapedIcon ()
void changeState (int state)
double distance_square (Site *s, VastMessage *msg)
void processJoinTimer ()
void processPingTimer ()
void processSecTimer ()
void handleJoin (SimpleClientMoveMessage *scMsg)
void handleMove (SimpleClientMoveMessage *scMsg)
void handleJoinRequest (VastMessage *vastMsg)
void handleJoinAcknowledge (VastListMessage *vastListMsg)
void handleNodeMove (VastMoveMessage *vastMoveMsg)
void handleNewNeighbors (VastListMessage *vastListMsg)
void handleNodeLeave (VastListMessage *vastListMsg)
void handleEnclosingNeighborsRequest (VastMessage *vastMsg)
void handlePing (VastMessage *vastMsg)
void handlePong (VastMessage *vastMsg)
void handleDiscardNode (VastDiscardMessage *vastMsg)
void sendDiscardNode (VastMessage *vastMsg)
void synchronizeApp ()

Protected Attributes

double AOI_size
Point position
NeighborsListneighborsList
int state
long joinRequestBytesSent
long joinAcknowledgeBytesSent
long nodeMoveBytesSent
long newNeighborsBytesSent
long nodeLeaveBytesSent
long enclosingNeighborsRequestBytesSent
long pingBytesSent
long pongBytesSent
long discardNodeBytesSent
long maxBytesPerSecondSent
long averageBytesPerSecondSent
long bytesPerSecond
bool debugVoronoiOutput
double joinTimeout
double pingTimeout
cMessage * join_timer
cMessage * ping_timer
cMessage * sec_timer


Constructor & Destructor Documentation

Vast::~Vast (  )  [virtual]

00886 {
00887     // destroy self timer messages
00888     cancelAndDelete(join_timer);
00889     cancelAndDelete(ping_timer);
00890     cancelAndDelete(sec_timer);
00891 }


Member Function Documentation

void Vast::changeState ( int  state  )  [protected]

00093 {
00094     switch(state) {
00095         case INIT: {
00096             this->state = INIT;
00097             bootstrapOracle->removePeer(thisNode);
00098         } break;
00099         case JOINING: {
00100             this->state = JOINING;
00101             scheduleAt(simulation.simTime(), join_timer);
00102             scheduleAt(simulation.simTime() + 1.0, sec_timer);
00103         } break;
00104         case READY: {
00105             this->state = READY;
00106             cancelEvent(join_timer);
00107             neighborsList->initializeList(position, thisNode, AOI_size);
00108             bootstrapOracle->registerPeer(thisNode);
00109             scheduleAt(simulation.simTime() + pingTimeout, ping_timer);
00110             // tell the application we are ready
00111             SimpleClientMessage *scMsg = new SimpleClientMessage("OVERLAY_READY");
00112             scMsg->setCommand(OVERLAY_READY);
00113             sendToApp(scMsg);
00114         } break;
00115     }
00116     setBootstrapedIcon();
00117     // debug output
00118     if(debugOutput) {
00119         ev << "VAST: Node " << thisNode.ip << " entered ";
00120         switch(state) {
00121             case INIT: ev << "INIT"; break;
00122             case JOINING: ev << "JOINING"; break;
00123             case READY: ev << "READY"; break;
00124         }
00125         ev << " state." << endl;
00126     }
00127 }

double Vast::distance_square ( Site s,
VastMessage *  msg 
) [protected]

void Vast::finishOverlay (  )  [virtual]

collects statistical data in derived class

Reimplemented from BaseOverlay.

00843 {
00844     // collect statistics
00845     recordScalar("JOIN_REQUEST bytes sent", joinRequestBytesSent);
00846     recordScalar("JOIN_ACKNOWLEDGE bytes sent", joinAcknowledgeBytesSent);
00847     recordScalar("NODE_MOVE bytes sent", nodeMoveBytesSent);
00848     recordScalar("NEW_NEIGHBORS bytes sent", newNeighborsBytesSent);
00849     recordScalar("NODE_LEAVE bytes sent", nodeLeaveBytesSent);
00850     recordScalar("ENCLOSING_NEIGHBORS_REQUEST bytes sent", enclosingNeighborsRequestBytesSent);
00851     recordScalar("PING bytes sent", pingBytesSent);
00852     recordScalar("PONG bytes sent", pongBytesSent);
00853     recordScalar("DISCARD_NODE bytes sent", discardNodeBytesSent);
00854 
00855     recordScalar("max bytes/second sent", maxBytesPerSecondSent);
00856     recordScalar("average bytes/second sent", (long)(averageBytesPerSecondSent / simTime()));
00857 
00858     bootstrapOracle->removePeer(thisNode);
00859 }

double Vast::getAOI (  ) 

00868 {
00869     Enter_Method_Silent();
00870     return AOI_size;
00871 }

NeighborsList * Vast::getList (  ) 

00880 {
00881     Enter_Method_Silent();
00882     return neighborsList;
00883 }

Point Vast::getPosition (  ) 

00874 {
00875     Enter_Method_Silent();
00876     return position;
00877 }

int Vast::getState (  ) 

00862 {
00863     Enter_Method_Silent();
00864     return state;
00865 }

void Vast::handleAppMessage ( cMessage *  msg  )  [virtual]

Processes non-commonAPI messages.


Processes non-commonAPI messages if parameter "onlyCommonAPIMessages" is false.

Parameters:
msg non-commonAPIMessage

Reimplemented from BaseOverlay.

00155 {
00156     if(dynamic_cast<SimpleClientMessage*>(msg)) {
00157         SimpleClientMessage* simpleClientMsg = check_and_cast<SimpleClientMessage*>(msg);
00158         // debug output
00159         if(debugOutput) ev << "VAST: Node " << thisNode.ip << " received " << simpleClientMsg->name() << " from application." << endl;
00160         switch(simpleClientMsg->getCommand()) {
00161             case MOVE_INDICATION: {
00162                 SimpleClientMoveMessage* simpleClientMoveMsg = check_and_cast<SimpleClientMoveMessage*>(msg);
00163                 if(state == JOINING) {
00164                     handleJoin(simpleClientMoveMsg);
00165                     delete msg;
00166                 }
00167                 else if(state == READY) {
00168                     handleMove(simpleClientMoveMsg);
00169                     delete msg;
00170                 }
00171             } break;
00172                 //TODO insert handling for additional application messages like events etc. here
00173             default: {
00174                 delete msg;
00175             }
00176         }
00177     }
00178     else delete msg;
00179 }

void Vast::handleDiscardNode ( VastDiscardMessage *  vastMsg  )  [protected]

void Vast::handleEnclosingNeighborsRequest ( VastMessage *  vastMsg  )  [protected]

void Vast::handleJoin ( SimpleClientMoveMessage *  scMsg  )  [protected]

void Vast::handleJoinAcknowledge ( VastListMessage *  vastListMsg  )  [protected]

void Vast::handleJoinRequest ( VastMessage *  vastMsg  )  [protected]

void Vast::handleMove ( SimpleClientMoveMessage *  scMsg  )  [protected]

00390 {
00391     Point pos;
00392     pos.x = scMsg->getPosX();
00393     pos.y = scMsg->getPosY();
00394     // test if new position is legal
00395     neighborsList->initIterator();
00396     Site *currentSite = neighborsList->next();
00397     while(currentSite) {
00398         if(currentSite->coord.x == pos.x && currentSite->coord.y == pos.y && !(currentSite->type & THIS)) {
00399             SimpleClientMessage *scMsg = new SimpleClientMessage("MOVE_REQUEST");
00400             scMsg->setType(MOVE_REQUEST);
00401             sendToApp(scMsg);
00402             return;
00403         }
00404         else currentSite = neighborsList->next();
00405     }
00406     // send position update to neighbors
00407     neighborsList->initIterator();
00408     currentSite = neighborsList->next();
00409     while(currentSite) {
00410         if(!(currentSite->type & THIS)) {
00411             VoronoiMoveMessage *voroMoveMsg = new VoronoiMoveMessage("NODE_MOVE");
00412             voroMoveMsg->setType(NODE_MOVE);
00413             voroMoveMsg->setSourceNode(thisNode);
00414             voroMoveMsg->setPosX(position.x);
00415             voroMoveMsg->setPosY(position.y);
00416             voroMoveMsg->setNew_posX(pos.x);
00417             voroMoveMsg->setNew_posY(pos.y);
00418             voroMoveMsg->setIs_boundary(currentSite->type & BOUNDARY);
00419             voroMoveMsg->setLength(BASE_L + MOVE_L);
00420             sendMessage(voroMoveMsg, currentSite->addr);
00421         }
00422         currentSite = neighborsList->next();
00423     }
00424     // set new position
00425     position = pos;
00426     neighborsList->changePosition(pos);
00427     // update voronoi
00428     neighborsList->buildVoronoi();
00429     synchronizeApp();
00430     neighborsList->removeNeighbors();
00431 }

void Vast::handleNewNeighbors ( VastListMessage *  vastListMsg  )  [protected]

void Vast::handleNodeLeave ( VastListMessage *  vastListMsg  )  [protected]

void Vast::handleNodeMove ( VastMoveMessage *  vastMoveMsg  )  [protected]

void Vast::handlePing ( VastMessage *  vastMsg  )  [protected]

void Vast::handlePong ( VastMessage *  vastMsg  )  [protected]

void Vast::handleTimerEvent ( cMessage *  msg  )  [virtual]

Processes "timer" self-messages.

Parameters:
msg A self-message

Reimplemented from BaseOverlay.

00130 {
00131     if(msg->isName("join_timer")) {
00132         //reset timer
00133         cancelEvent(join_timer);
00134         scheduleAt(simulation.simTime() + joinTimeout, msg);
00135         // handle event
00136         processJoinTimer();
00137     }
00138     else if(msg->isName("ping_timer")) {
00139         //reset timer
00140         cancelEvent(ping_timer);
00141         scheduleAt(simulation.simTime() + pingTimeout, msg);
00142         // handle event
00143         processPingTimer();
00144     }
00145     else if(msg->isName("sec_timer")) {
00146         //reset timer
00147         cancelEvent(sec_timer);
00148         scheduleAt(simulation.simTime() + 1, msg);
00149         // handle event
00150         processSecTimer();
00151     }
00152 }

void Vast::handleUDPMessage ( BaseOverlayMessage *  msg  )  [virtual]

Processes messages from underlay.

Parameters:
msg Message from UDP

Implements BaseOverlay.

00182 {
00183     if(state == INIT) {
00184         delete msg;
00185         return;
00186     }
00187     if(dynamic_cast<VastMessage*>(msg)) {
00188         VastMessage* vastMsg = check_and_cast<VastMessage*>(msg);
00189         if(vastMsg->getDestKey() == thisNode.key) {
00190             // debug output
00191             if(debugOutput) ev << "VAST: Node " << thisNode.ip << " received " << vastMsg->name() << " from " << vastMsg->getSourceNode().ip << "." << endl;
00192             if(state == READY) {
00193                 bool doUpdate = true;
00194                 switch(vastMsg->getCommand()) {
00195                     case JOIN_REQUEST: {
00196                         handleJoinRequest(vastMsg);
00197                         doUpdate = false; // do not update timestamp cause requester is not yet ready
00198                     } break;
00199                     case NODE_MOVE: {
00200                         VastMoveMessage* vastMoveMsg = check_and_cast<VastMoveMessage*>(msg);
00201                         handleNodeMove(vastMoveMsg);
00202                     } break;
00203                     case NEW_NEIGHBORS: {
00204                         VastListMessage* vastListMsg = check_and_cast<VastListMessage*>(msg);
00205                         handleNewNeighbors(vastListMsg);
00206                     } break;
00207                     case NODE_LEAVE: {
00208                         VastListMessage* vastListMsg = check_and_cast<VastListMessage*>(msg);
00209                         handleNodeLeave(vastListMsg);
00210                     } break;
00211                     case ENCLOSING_NEIGHBORS_REQUEST: {
00212                         handleEnclosingNeighborsRequest(vastMsg);
00213                     } break;
00214                     case PING: {
00215                         handlePing(vastMsg);
00216                     } break;
00217                     case PONG: {
00218                         handlePong(vastMsg);
00219                     } break;
00220                     case DISCARD_NODE: {
00221                         VastDiscardMessage* vastDiscardMsg = check_and_cast<VastDiscardMessage*>(msg);
00222                         handleDiscardNode(vastDiscardMsg);
00223                     } break;
00224                 }
00225                 // update timestamp
00226                 if(doUpdate) {
00227                     Point p;
00228                     p.x = vastMsg->getPosX();
00229                     p.y = vastMsg->getPosY();
00230                     neighborsList->updateTimeStamp(p);
00231                     delete msg;
00232                 }
00233             }
00234             else if(vastMsg->getCommand() == JOIN_ACKNOWLEDGE && state == JOINING) {
00235                 VastListMessage* vastListMsg = check_and_cast<VastListMessage*>(msg);
00236                 handleJoinAcknowledge(vastListMsg);
00237                 delete msg;
00238             }
00239             else delete msg;
00240         }
00241         else {
00242             sendDiscardNode(vastMsg);
00243             delete msg;
00244         }
00245     }
00246     else delete msg;
00247 }

void Vast::initializeOverlay ( int  stage  )  [virtual]

Initializes derived-class-attributes.


Initializes derived-class-attributes, called by BaseOverlay::initialize(). By default this method is called once. If more stages are needed one can overload numInitStages() and add more stages.

Parameters:
stage the init stage

Reimplemented from BaseOverlay.

00029 {
00030     // because of IPAddressResolver, we need to wait until interfaces are registered,
00031     // address auto-assignment takes place etc.
00032     if(stage != MIN_STAGE_OVERLAY) return;
00033 
00034     // fetch parameters
00035     debugVoronoiOutput = par("debugVoronoiOutput");
00036     AOI_size = par("AOI_size");
00037     joinTimeout = par("joinTimeout");
00038     pingTimeout = par("pingTimeout");
00039     onlyCommonAPIMessages = false;
00040 
00041     // find friend modules
00042     neighborsList = check_and_cast<NeighborsList*>(parentModule()->submodule("neighborsList"));
00043 
00044     // set node key
00045     thisNode.key = OverlayKey::random();
00046 
00047     // initialize neighborsList
00048     neighborsList->setDebug(debugVoronoiOutput);
00049 
00050     // self-messages
00051     join_timer = new cMessage("join_timer");
00052     ping_timer = new cMessage("ping_timer");
00053     sec_timer = new cMessage("sec_timer");
00054 
00055     // statistics
00056     joinRequestBytesSent = 0;
00057     joinAcknowledgeBytesSent = 0;
00058     nodeMoveBytesSent = 0;
00059     newNeighborsBytesSent = 0;
00060     nodeLeaveBytesSent = 0;
00061     enclosingNeighborsRequestBytesSent = 0;
00062     pingBytesSent = 0;
00063     pongBytesSent = 0;
00064     discardNodeBytesSent = 0;
00065 
00066     maxBytesPerSecondSent = 0;
00067     averageBytesPerSecondSent = 0;
00068     bytesPerSecond = 0;
00069 
00070     // watch some variables
00071     WATCH(position);
00072     WATCH(AOI_size);
00073 
00074     WATCH(joinRequestBytesSent);
00075     WATCH(joinAcknowledgeBytesSent);
00076     WATCH(nodeMoveBytesSent);
00077     WATCH(newNeighborsBytesSent);
00078     WATCH(nodeLeaveBytesSent);
00079     WATCH(enclosingNeighborsRequestBytesSent);
00080     WATCH(pingBytesSent);
00081     WATCH(pongBytesSent);
00082     WATCH(discardNodeBytesSent);
00083     
00084     WATCH(maxBytesPerSecondSent);
00085     WATCH(bytesPerSecond);
00086     
00087     // set initial state
00088     changeState(INIT);
00089     changeState(JOINING);
00090 }

void Vast::processJoinTimer (  )  [protected]

00305 {
00306     SimpleClientMessage *scMsg = new SimpleClientMessage("MOVE_REQUEST");
00307     scMsg->setCommand(MOVE_REQUEST);
00308     sendToApp(scMsg);
00309 }

void Vast::processPingTimer (  )  [protected]

00312 {
00313     bool abnormalLeave = false;
00314     bool boundaryLeave = false;
00315     neighborsList->initIterator();
00316     Site *currentSite = neighborsList->next();
00317     while(currentSite) {
00318         if(!(currentSite->type & THIS)) {
00319             if(currentSite->tstamp < 0.0) { // node is dropped cause no pong has been received see below
00320                 abnormalLeave = true;
00321                 if(!(currentSite->type & NEIGHBOR)) boundaryLeave = true;
00322                 currentSite->type = UNDEF;
00323             }
00324             else if(currentSite->tstamp < simulation.simTime() - pingTimeout) { // node showed no activity for some time request pong and mark it to be dropped next time
00325                 VastMessage *vastMsg = new VastMessage("PING");
00326                 vastMsg->setCommand(PING);
00327                 vastMsg->setSourceNode(thisNode);
00328                 vastMsg->setPosX(position.x);
00329                 vastMsg->setPosY(position.y);
00330                 vastMsg->setLength(BASE_L);
00331                 sendMessage(voroMsg, currentSite->addr);
00332                 currentSite->tstamp = -1.0;
00333             }
00334         }
00335         currentSite = neighborsList->next();
00336     }
00337     if(abnormalLeave) {
00338         synchronizeApp();
00339         neighborsList->removeNeighbors();
00340         if(boundaryLeave) {
00341             neighborsList->initIterator();
00342             currentSite = neighborsList->next();
00343             while(currentSite) {
00344                 if(!(currentSite->type & NEIGHBOR) && !(currentSite->type & THIS)) {
00345                     VoronoiMessage *voroMsg = new VoronoiMessage("ENCLOSING_NEIGHBORS_REQUEST");
00346                     voroMsg->setType(ENCLOSING_NEIGHBORS_REQUEST);
00347                     voroMsg->setSourceNode(thisNode);
00348                     voroMsg->setPosX(position.x);
00349                     voroMsg->setPosY(position.y);
00350                     voroMsg->setLength(BASE_L);
00351                     sendMessage(voroMsg, currentSite->addr);
00352                 }
00353                 currentSite = neighborsList->next();
00354             }
00355         }
00356         neighborsList->buildVoronoi();
00357     }
00358 }

void Vast::processSecTimer (  )  [protected]

void Vast::receiveChangeNotification ( int  category,
cPolymorphic *  details 
) [virtual]

00250 {
00251     /*if(category == NF_OVERLAY_NODE_LEAVE && state == READY) {
00252         int i;
00253         // debug output
00254         if(debugOutput) ev << "OVERLAY: Node " << thisNode.ip << " is leaving the overlay." << endl;
00255 
00256         // generate node leave messages
00257         VoronoiListMessage *voroListMsg = new VoronoiListMessage("NODE_LEAVE");
00258         voroListMsg->setType(NODE_LEAVE);
00259         voroListMsg->setSourceNode(thisNode);
00260         voroListMsg->setPosX(position.x);
00261         voroListMsg->setPosY(position.y);
00262 
00263         voroListMsg->setNeighborNodeArraySize(neighborsList->getSize());
00264         voroListMsg->setNeighbor_posXArraySize(neighborsList->getSize());
00265         voroListMsg->setNeighbor_posYArraySize(neighborsList->getSize());
00266 
00267         i = 0;
00268         neighborsList->initIterator();
00269         Site *currentSite = neighborsList->next();
00270         while(currentSite) {
00271             if(currentSite->type & ENCLOSING) {
00272                 voroListMsg->setNeighborNode(i, currentSite->addr);
00273                 voroListMsg->setNeighbor_posX(i, currentSite->coord.x);
00274                 voroListMsg->setNeighbor_posY(i, currentSite->coord.y);
00275                 ++i;
00276             }
00277             currentSite = neighborsList->next();
00278         }
00279         voroListMsg->setEntry_count(i);
00280         voroListMsg->setNeighborNodeArraySize(i);
00281         voroListMsg->setNeighbor_posXArraySize(i);
00282         voroListMsg->setNeighbor_posYArraySize(i);
00283 
00284         voroListMsg->setLength(BASE_L + COUNT_L + voroListMsg->getEntry_count() * ENTRY_L);
00285         if(voroListMsg->getEntry_count() > 0) {
00286             neighborsList->initIterator();
00287             currentSite = neighborsList->next();
00288             while(currentSite) {
00289                 if(!(currentSite->type & THIS)) {
00290                     VoronoiListMessage *voroCopyMsg = new VoronoiListMessage(*voroListMsg);
00291                     // prevent notification board from taking the message
00292                     take(voroCopyMsg);
00293                     sendMessage(voroCopyMsg, currentSite->addr);
00294                 }
00295                 currentSite = neighborsList->next();
00296             }
00297         }
00298         delete voroListMsg;
00299 
00300         changeState(INIT);
00301     }*/
00302 }

void Vast::sendDiscardNode ( VastMessage *  vastMsg  )  [protected]

void Vast::sendMessage ( VastMessage *  vastMsg,
NodeHandle  destAddr 
) [protected]

void Vast::sendToApp ( SimpleClientMessage *  scMsg  )  [protected]

00760 {
00761     // debug output
00762     if(debugOutput) ev << "OVERLAY: Node " << thisNode.ip << " sending " << scMsg->name() << " to application." << endl;
00763     send(scMsg, "to_app");
00764 }

void Vast::setBootstrapedIcon (  )  [protected]

00825 {
00826     if(ev.isGUI()) {
00827         if(state == READY) {
00828             parentModule()->parentModule()->displayString().setTagArg("i2", 1, "green");
00829             displayString().setTagArg("i", 1, "green");
00830         }
00831         else if(state == JOINING) {
00832             parentModule()->parentModule()->displayString().setTagArg("i2", 1, "yellow");
00833             displayString().setTagArg("i", 1, "yellow");
00834         }
00835         else {
00836             parentModule()->parentModule()->displayString().setTagArg("i2", 1, "red");
00837             displayString().setTagArg("i", 1, "red");
00838         }
00839     }
00840 }

void Vast::synchronizeApp (  )  [protected]

00716 {
00717     int i, j;
00718     SimpleClientListMessage *scMsg = new SimpleClientListMessage("UPDATE_NEIGHBORS");
00719     scMsg->setType(UPDATE_NEIGHBORS);
00720 
00721     scMsg->setRemove_neighborArraySize(neighborsList->getSize());
00722     scMsg->setAdd_neighborArraySize(neighborsList->getSize());
00723     scMsg->setAdd_neighbor_posXArraySize(neighborsList->getSize());
00724     scMsg->setAdd_neighbor_posYArraySize(neighborsList->getSize());
00725 
00726     i = j = 0;
00727     neighborsList->initIterator();
00728     Site *currentSite = neighborsList->next();
00729     while(currentSite) {
00730         if(currentSite->type == UNDEF) {
00731             scMsg->setRemove_neighbor(i, currentSite->addr);
00732             ++i;
00733         }
00734         else if(!currentSite->isAdded && !(currentSite->type & THIS)) {
00735             scMsg->setAdd_neighbor(j, currentSite->addr);
00736             scMsg->setAdd_neighbor_posX(j, currentSite->coord.x);
00737             scMsg->setAdd_neighbor_posY(j, currentSite->coord.y);
00738             currentSite->isAdded = true;
00739             ++j;
00740         }
00741         currentSite = neighborsList->next();
00742     }
00743     scMsg->setRemove_entry_count(i);
00744     scMsg->setRemove_neighborArraySize(i);
00745     scMsg->setAdd_entry_count(j);
00746     scMsg->setAdd_neighborArraySize(j);
00747     scMsg->setAdd_neighbor_posXArraySize(j);
00748     scMsg->setAdd_neighbor_posYArraySize(j);
00749 
00750     if(scMsg->getAdd_entry_count() || scMsg->getRemove_entry_count()) {
00751         sendToApp(scMsg);
00752     }
00753     else
00754     {
00755         delete scMsg;
00756     }
00757 }


Member Data Documentation

double Vast::AOI_size [protected]

long Vast::averageBytesPerSecondSent [protected]

long Vast::bytesPerSecond [protected]

bool Vast::debugVoronoiOutput [protected]

long Vast::discardNodeBytesSent [protected]

long Vast::enclosingNeighborsRequestBytesSent [protected]

cMessage* Vast::join_timer [protected]

long Vast::joinAcknowledgeBytesSent [protected]

long Vast::joinRequestBytesSent [protected]

double Vast::joinTimeout [protected]

long Vast::maxBytesPerSecondSent [protected]

NeighborsList* Vast::neighborsList [protected]

long Vast::newNeighborsBytesSent [protected]

long Vast::nodeLeaveBytesSent [protected]

long Vast::nodeMoveBytesSent [protected]

cMessage* Vast::ping_timer [protected]

long Vast::pingBytesSent [protected]

double Vast::pingTimeout [protected]

long Vast::pongBytesSent [protected]

Point Vast::position [protected]

cMessage* Vast::sec_timer [protected]

int Vast::state [protected]


The documentation for this class was generated from the following files:
Generated on Wed Apr 4 13:37:07 2007 for ITM OverSim by  doxygen 1.4.7