SimpleClient Class Reference

#include <SimpleClient.h>

List of all members.


Detailed Description

A simple test application, which simulates node movement based on different movement generators.


Public Member Functions

 SimpleClient ()
virtual ~SimpleClient ()
virtual int numInitStages () const
virtual void initialize (int stage)
virtual void handleMessage (cMessage *msg)

Protected Member Functions

void sendToOverlay (SimpleClientMessage *scMsg)
void updateNeighbors (SimpleClientListMessage *scMsg)

Protected Attributes

Repository * repository
bool debugOutput
bool initialized
double moveDelay
Vector position
MovementGeneratorGenerator
std::map< NodeHandle, VectorNeighbors
std::map< NodeHandle, Vector
>::iterator 
itNeighbors
IPvXAddress ip
cMessage * move_timer


Constructor & Destructor Documentation

SimpleClient::SimpleClient (  ) 

00130 {
00131     move_timer = NULL;
00132     repository = NULL;
00133 }

SimpleClient::~SimpleClient (  )  [virtual]

00136 {
00137     // destroy self timer messages
00138     cancelAndDelete(move_timer);
00139 }


Member Function Documentation

void SimpleClient::handleMessage ( cMessage *  msg  )  [virtual]

00062 {
00063     // catch self timer messages
00064     if(msg->isName("move_timer")) {
00065         //reset timer
00066         cancelEvent(move_timer);
00067         scheduleAt(simulation.simTime() + moveDelay, msg);
00068         // handle event
00069         Generator->move();
00070         position = Generator->getPosition();
00071         SimpleClientMoveMessage *scMsg = new SimpleClientMoveMessage("MOVE_INDICATION");
00072         scMsg->setType(MOVE_INDICATION);
00073         scMsg->setPosX(position.getX());
00074         scMsg->setPosY(position.getY());
00075         sendToOverlay(scMsg);
00076     }
00077     // catch overlay messages
00078     else if(msg->arrivedOn("from_overlay")) {
00079         if(dynamic_cast<SimpleClientMessage*>(msg)) {
00080             SimpleClientMessage* simpleClientMsg = check_and_cast<SimpleClientMessage*>(msg);
00081             switch(simpleClientMsg->getType()) {
00082                 case MOVE_REQUEST: {
00083                     Generator->move();
00084                     position = Generator->getPosition();
00085                     SimpleClientMoveMessage *scMsg = new SimpleClientMoveMessage("MOVE_INDICATION");
00086                     scMsg->setType(MOVE_INDICATION);
00087                     scMsg->setPosX(position.getX());
00088                     scMsg->setPosY(position.getY());
00089                     sendToOverlay(scMsg);
00090                 } break;
00091                 case UPDATE_NEIGHBORS: {
00092                     SimpleClientListMessage* simpleClientListMsg = check_and_cast<SimpleClientListMessage*>(msg);
00093                     updateNeighbors(simpleClientListMsg);
00094                 } break;
00095                 case OVERLAY_READY: {
00096                     initialized = true;
00097                     scheduleAt(simulation.simTime() + moveDelay, move_timer);
00098                 } break;
00099             }
00100             delete msg;
00101         }
00102         else delete msg;
00103     }
00104     else delete msg;
00105 }

void SimpleClient::initialize ( int  stage  )  [virtual]

00022 {
00023     // because of IPAddressResolver, we need to wait until interfaces are registered,
00024     // address auto-assignment takes place etc.
00025     if(stage != 5) return;
00026 
00027     WATCH_MAP(Neighbors);
00028     WATCH(position);
00029 
00030     // fetch parameters
00031     debugOutput = par("debugOutput");
00032     moveDelay = par("moveDelay");
00033 
00034     repository = check_and_cast<Repository*>(parentModule()->parentModule()->submodule("globalObserver")->submodule("repository"));
00035 
00036     if(strcmp(par("movementGenerator"), "greatGathering") == 0) {
00037         // debug output
00038         if(debugOutput) ev << "SIMPLECLIENT: Movement generator: greatGathering" << endl;
00039         Generator = new greatGathering(par("areaDimension"), par("movementSpeed"), &Neighbors, repository);
00040     } else if(strcmp(par("movementGenerator"), "groupRoaming") == 0) {
00041         // debug output
00042         if(debugOutput) ev << "SIMPLECLIENT: Movement generator: groupRoaming" << endl;
00043         Generator = new groupRoaming(par("areaDimension"), par("movementSpeed"), &Neighbors, repository, (int)par("groupSize"));
00044     } else {
00045         // debug output
00046         if(debugOutput) {
00047             if(strcmp(par("movementGenerator"), "randomRoaming") == 0) ev << "SIMPLECLIENT: Movement generator: randomRoaming" << endl;
00048             else ev << "SIMPLECLIENT: Movement generator: <unknown>. Defaulting to: randomRoaming" << endl;
00049         }
00050         Generator = new randomRoaming(par("areaDimension"), par("movementSpeed"), &Neighbors);
00051     }
00052 
00053     ip = IPAddressResolver().addressOf(parentModule()).get4();
00054 
00055     // self-messages
00056     move_timer = new cMessage("move_timer");
00057 
00058     initialized = false;
00059 }

virtual int SimpleClient::numInitStages (  )  const [inline, virtual]

00044 { return 6; }

void SimpleClient::sendToOverlay ( SimpleClientMessage *  scMsg  )  [protected]

00108 {
00109     // debug output
00110     if(debugOutput) ev << "SIMPLECLIENT: Node " << ip << " sending " << scMsg->name() << " to overlay." << endl;
00111     send(scMsg, "to_overlay");
00112 }

void SimpleClient::updateNeighbors ( SimpleClientListMessage *  scMsg  )  [protected]

00115 {
00116     int i;
00117     Vector v;
00118     for(i=0; i<scMsg->getRemove_entry_count(); i++) {
00119         Neighbors.erase(scMsg->getRemove_neighbor(i));
00120     }
00121     for(i=0; i<scMsg->getAdd_entry_count(); i++) {
00122         v.setValue(scMsg->getAdd_neighbor_posX(i), scMsg->getAdd_neighbor_posY(i));
00123         itNeighbors = Neighbors.find(scMsg->getAdd_neighbor(i));
00124         if(itNeighbors != Neighbors.end()) Neighbors.erase(scMsg->getAdd_neighbor(i));
00125         Neighbors.insert(std::make_pair(scMsg->getAdd_neighbor(i), v));
00126     }
00127 }


Member Data Documentation

bool SimpleClient::debugOutput [protected]

MovementGenerator* SimpleClient::Generator [protected]

bool SimpleClient::initialized [protected]

IPvXAddress SimpleClient::ip [protected]

std::map<NodeHandle, Vector>::iterator SimpleClient::itNeighbors [protected]

cMessage* SimpleClient::move_timer [protected]

double SimpleClient::moveDelay [protected]

std::map<NodeHandle, Vector> SimpleClient::Neighbors [protected]

Vector SimpleClient::position [protected]

Repository* SimpleClient::repository [protected]


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