#include <Vast.h>
Inheritance diagram for Vast:
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 () |
NeighborsList * | getList () |
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 |
NeighborsList * | neighborsList |
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 |
Vast::~Vast | ( | ) | [virtual] |
00886 { 00887 // destroy self timer messages 00888 cancelAndDelete(join_timer); 00889 cancelAndDelete(ping_timer); 00890 cancelAndDelete(sec_timer); 00891 }
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 | ( | ) |
NeighborsList * Vast::getList | ( | ) |
int Vast::getState | ( | ) |
void Vast::handleAppMessage | ( | cMessage * | msg | ) | [virtual] |
Processes non-commonAPI messages.
Processes non-commonAPI messages if parameter "onlyCommonAPIMessages" is false.
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.
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.
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.
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] |
00361 { 00362 if(bytesPerSecond > maxBytesPerSecondSent) { 00363 maxBytesPerSecondSent = bytesPerSecond; 00364 } 00365 averageBytesPerSecondSent += bytesPerSecond; 00366 bytesPerSecond = 0; 00367 }
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 }
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] |