CSE.cpp

#include "CSE.h"
#include "declarative.h"
#include <algorithm>

bool prefix(const char *pre, const char *str)
{
    return strncmp(pre, str, strlen(pre)) == 0;
}


void CSE::initialize() {
    this->Uri = getId(); // this is the omnet id which is given when creating the module in the NED file (sequential numbering )

    EV << "URI II " << Uri << "\n";
    this->NotificationDepth = par("notification_depth");

    this->multicastAlpha = par("alpha");
    this->multicastBeta = par("beta");
    this->multicastGamma = par("gamma");
    this->multicastDelta = par("delta");
    this->queryBufferTTL = par("queryBufferTTL");
    this->maxHops = par("maxHops");

    number_of_packets = 0;
    totalpacketsSignal = registerSignal("packet_size");
    delay = par("delayTime");

    number_of_hops= 0;
    latency= registerSignal("hop_count");

    number_of_messages= 0;
    flood= registerSignal("flood");

    success= 0;
    success_rate= registerSignal("success");

}

/*
 * routeQuery
 * Used to perform semantic routing
 * Function returns the list of CSEs to redirect query to.
 * It returns the list of URIs of the same relationship type,
 * e.g. Customer, Sibling, Peer, Provider.
 *
 * */
std::vector<URI> CSE::routeQuery(discoveryMessage *msg) {
    std::string feature_type = msg->getFeature_type();
    std::vector<URI> URI_Found;
    auto it = this->SemanticRoutingTable.find(feature_type);
    if (it == this->SemanticRoutingTable.end()) {
        EV << "feature Type not exist" << "\n";
        return URI_Found;
    }

    if (it->second.CSECustomer.size() > 0) {
        for (auto cit = it->second.CSECustomer.begin();
                cit != it->second.CSECustomer.end(); cit++) {
            URI_Found.push_back(cit->first);
        }
        return URI_Found;
    }
    if (it->second.CSESibling.size() > 0) {
        for (auto sit = it->second.CSESibling.begin();
                sit != it->second.CSESibling.end(); sit++) {
            URI_Found.push_back(sit->first);
        }
        return URI_Found;
    }
    if (it->second.CSEPeer.size() > 0) {
        for (auto sit = it->second.CSEPeer.begin();
                sit != it->second.CSEPeer.end(); sit++) {
            URI_Found.push_back(sit->first);
        }
        return URI_Found;
    }
    if (it->second.CSEProvider.size() > 0) {
        for (auto pit = it->second.CSEProvider.begin();
                pit != it->second.CSEProvider.end(); pit++) {
            URI_Found.push_back(pit->first);
        }
        return URI_Found;
    }

    return URI_Found;
}

/*
 * processQuery is used to route query if local DB lookup failed.
 * It tries to perform semantic routing, and if no records satisfying query were found,
 * if uses a so-called fallback routing to multicast query to the best match neighbors.
 */
void CSE::processQuery(discoveryMessage *msg) {
    EV << "The Message is a query \n";
    EV << "DB Lookup not Successful" << "\n";
    if (msg->getHopCount() <= 0) {
        bubble("TTL: expired");
        //Respond to the URI_init that the discovery ends
        // TODO: DBLookup part to be added here
        msg->setOp_code(RESPONSE);
        // TODO: set the message op_codes according to result from DBLookup
        //You extract from the top of the list the gate that has to be used
        EV << "Hop count is 0 so we generate a self response message \n";
        number_of_messages++;
        generateResponseMessage(msg, ResultCode::NOT_FOUND);
        return;
    }

    // decrease the hop count
    EV << "we are in the else :  hop count is currently " << msg->getHopCount()
              << "\n";
    msg->setHopCount(msg->getHopCount() - 1);
    number_of_hops++;
    emit(latency, number_of_hops);
    // TODO: signal for hop count


    EV << "New HopCount=" << msg->getHopCount() << "\n";

    auto res = routeQuery(msg);

    if (res.size() > 0) {
        for (auto it : res) {
            auto gateit = this->Gates[it];
            int gateindex = gateit.second;
            std::string gateName = gateit.first + "$o";
            bubble("Semantic record found");
            number_of_messages++;
            sendDelayed(msg->dup(), delay, gateName.c_str(), gateindex);
        }

        return;
    }
    fallbackRouteQuery(msg);
}

/*
 * fallbackRouteQuery is used when semantic routing fails
 * (i.e. semantic routing table lookup returns no results)
 * It multicasts query with coefficients.
 * It routes query in valley-free manner.
 */
void CSE::fallbackRouteQuery(discoveryMessage *msg) {
    int D = msg->getDirection();

    bool successful = false;

    /*
     * We need to send response only if all of the broadcasts have failed
     *
     * Thus, we are performing logical AND between all invocations of broadcast
     *
     * If all of them fail - we will send response
     * */
    switch (D) {
    case DOWN: {
        successful = multicast("customer", msg, this->multicastAlpha);
        number_of_messages++;
        successful =
                !successful ?
                        multicast("sibling", msg, this->multicastGamma) : true;
        break;
    }
    case SIDE_SIBLING: {
        successful = multicast("sibling", msg, this->multicastGamma);
        number_of_messages++;
        successful &= multicast("customer", msg, this->multicastAlpha);
        break;
    }
    case SIDE_PEER: {
        number_of_messages++;
        break;
    }
    case UP: {
        successful = multicast("provider", msg, this->multicastBeta);
        number_of_messages++;
        successful =
                !successful ?
                        multicast("sibling", msg, this->multicastGamma) : true;
        number_of_messages++;
        successful &= multicast("customer", msg, this->multicastDelta);
        number_of_messages++;
        break;
    }
    default:
        break;
    }

    if (!successful) {
        bubble("No result");
        number_of_messages++;
        generateResponseMessage(msg, ResultCode::NOT_FOUND);
    }
}

/*
 * seenQuery is used to check whether the query being processed was previously processed.
 * It checks the local query buffer for the query ID.
 * Also, performs cleanup of stale buffer records.
 */
bool CSE::seenQuery(discoveryMessage *msg) {
    std::map<queryKey, int64_t> newProcessed(this->processedQueries);
    for (auto record : newProcessed) {
        if (record.second < simTime().inUnit(SimTimeUnit::SIMTIME_S)) {
            this->processedQueries.erase(record.first);
        }
    }

    queryKey key;
    key.second = msg->getQueryID();
    key.first = msg->getURI_init();

    if (this->processedQueries.find(key) != this->processedQueries.end()) {
        return true;
    }

    return false;
}

/*
 * handleQuery is used to handle message of type QUERY.
 *
 * It memorizes distinct queries and omits duplicate ones.
 */
void CSE::handleQuery(discoveryMessage *msg) {
    auto cse = msg->getURI_route();
    std::string inputGate = msg->getArrivalGate()->getBaseName();
    this->Gates[cse] = std::make_pair(inputGate,
            msg->getArrivalGate()->getIndex());

    if (seenQuery(msg)) {
        bubble("Dropping seen query");
        return;
    }

    int64_t ttl = SimTime(this->queryBufferTTL).inUnit(SimTimeUnit::SIMTIME_S);
    ttl = ttl + msg->getArrivalTime().inUnit(SimTimeUnit::SIMTIME_S);
    queryKey key;
    key.first = msg->getURI_init();
    key.second = msg->getQueryID();

    this->processedQueries[key] = ttl;

    auto res = DBLookup(msg);
    // If we find the index "NOT_FOUND" in the map, it means that
    // the feature is not present in the database
    if (res == NOT_FOUND) {
        processQuery(msg);
        return;
    }
    DBresult dbres = std::map<int, int>();
    dbres[res] = 0;
    EV << "DB Lookup Successful" << "\n";
    msg->setDbResult(dbres);

    number_of_messages++;
    generateResponseMessage(msg);
}

/*
 * handleDiscoveryMessage is used to handle `discoveryMessage`.
 */
void CSE::handleDiscoveryMessage(cMessage *msg) {
    EV << "entering the CSE part  " << "\n";
// if the message comes from another resource that an AE
    discoveryMessage *discoveryMsg = check_and_cast<discoveryMessage*>(msg);
    EV << "The Message is of type : " << discoveryMsg->getOp_code() << "\n";
    if (msg->isSelfMessage()) {
        //the discovery message comes from the AE and should be forwarded
        EV << "It is a self Message  " << "\n";
        if (discoveryMsg->getOp_code() == QUERY) {
            processQuery(discoveryMsg);
            delete discoveryMsg;
            return;
        }
    }

    EV << "It is not a self Message  ";
    if (discoveryMsg->getOp_code() == QUERY) {
        EV << "of type query\n";
        std::vector<cGate*> tempGateVector;
        // You put on top of the list  the name of the gate to be used in the return path (getOtherHalf)
        tempGateVector = discoveryMsg->getGateVector();
        tempGateVector.push_back(msg->getArrivalGate()->getOtherHalf());
        discoveryMsg->setGateVector(tempGateVector);
        EV << "A new  gate is added = " << tempGateVector.back()->getFullName()
                  << "\n";
    } else {
        EV << "of type response so no new gate added\n";
    }  // end if self-message

// switch on 2 possible opcodes between CSEs : QUERY or RESPONSE

    int op_code = discoveryMsg->getOp_code();
    EV << "Switch OPCODE  \n";
    switch (op_code) {
    case NOTIFY:
        handleNotify(discoveryMsg);
        break;
    case QUERY:
        handleQuery(discoveryMsg);
        break;
    case RESPONSE: {
        returnResponse(discoveryMsg);
        break;
    }
    }

    delete discoveryMsg;
}

/*
 * returnResponse is used to return response in predefined manner, i.e.
 * unfolding path step by step and sending messages back.
 */
void CSE::returnResponse(discoveryMessage *msg) {
    EV << "The Message is a response \n";
    int i = msg->getGateVector().size();
    if (i <= 0) {
        EV << "We are in the last gate Message Delivered" << "\n";
        return;
    }

    EV << "Size of Gate vector is " << i << "\n";
    std::vector<cGate*> tempGateVector;
    // You put on top of the list  the name of the gate to be used in the return path (getOtherHalf)
    tempGateVector = msg->getGateVector();
    const char *returnGate = tempGateVector.back()->getName();
    int returnIndex = tempGateVector.back()->getIndex();

    tempGateVector.pop_back();
    msg->setGateVector(tempGateVector);
    EV << "gate removed = " << returnGate << "of index " << returnIndex << "\n";
    i = msg->getGateVector().size();
    EV << "New Size of Gate vector is " << i << "\n";
    EV << "<Module Name" << msg->getName() << "gate name" << returnGate << "\n"
              << "gateIndex" << returnIndex << "\n";
    sendDelayed(msg->dup(), delay, returnGate, returnIndex);
}

/*
 * handleAEMessage is used to process message from Application Entities (AEs)
 * Messages include registration, cancellation and queries.
 */
void CSE::handleAEMessage(cMessage *msg) {
    EV << "entering the AE part of the IF " << "\n";
    AEMessage *aeMsg = check_and_cast<AEMessage*>(msg);
// Create message object and set source and destination field.

    int op_code = aeMsg->getOp_code();  // op_code contains the type of message

    switch (op_code) {
    case REGISTRATION: {

        handleAERegistration(aeMsg);
        break;
    }
    case CANCELLATION: {

        handleAECancellation(aeMsg);
        break;
    }
    case QUERY: {
        // if it is a query msg we create a discovery msg and we start ASDR
        number_of_messages++;
        generateDiscoveryMessage(aeMsg);
        break;
    }
    default:
        break;
    }

    delete aeMsg;
}
/*
 * saveAEData is used to save AE data into CSE local database
 */
void CSE::saveAEData(std::string feature_type, URI uri, int data) {
// we create an internal map
    std::map<URI, int> internalMap;
// we create an Iterator on the database
    std::map<std::string, std::map<URI, int>>::iterator it;
// we search for the feature_type in the database
    it = database.find(feature_type);
// if we don't find it
    if (it == database.end()) {
        // putting data in the internal map as a new entry
        internalMap[uri] = data;
    }
// if we find the feature_type
    else {
        internalMap = database[feature_type]; // we put the internal map inside the DataBase map next to the feature_type
        internalMap[uri] = data;
    }
    database[feature_type] = internalMap;

    EV << "feature type added in Database" << feature_type << "\n";

}

/*
 * handleAERegistration is used to perform Application Entity (AE) registration at parent CSE.
 * Also, it invokes CSE neighbors notification as a result of new entity registration.
 */
void CSE::handleAERegistration(AEMessage *msg) {
// we extract the feature_type; URI_route; data from the AEmessage
    std::string feature_type = msg->getFeature_type();
    int URI_route = msg->getURI();
    int data = msg->getData();

    bubble(feature_type.c_str());

    registerAE(feature_type, URI_route);

    saveAEData(feature_type, URI_route, data);

    notifyCSE(feature_type, 1);
}

/*
 * handleAECancellation is used to perform Application Entity (AE) deregistration at parent CSE.
 * Also, it invokes CSE neighbors notification as a result of new entity deregistration (cancellation).
 */
void CSE::handleAECancellation(AEMessage *msg) {

    std::string feature_type = msg->getFeature_type();
    int URI_route = msg->getURI();

    deregisterAE(feature_type, URI_route);

    notifyCSE(feature_type, -1);

}

/*
 * registerAE is used to update semantic routing table to accustom for AE registration.
 */
void CSE::registerAE(std::string feature_type, URI uri) {
    auto entry = getOrCreateRoutingEntry(feature_type);
    entry.database.insert(std::pair<URI, int>(uri, 1));

    this->SemanticRoutingTable[feature_type] = entry;
}

/*
 * deregisterAE is used to update semantic routing table to accustom for AE cancellation.
 */
void CSE::deregisterAE(std::string feature_type, URI uri) {
    auto entry = mustGetRoutingEntry(feature_type);
    auto it = entry.database.find(uri);
    if (it == entry.database.end()) {
        EV_FATAL << "Expected routing entry to exist\n";
    }

    if (it->second < 1) {
        EV_FATAL << "Expected to have at least one AE registered\n";
    }

    entry.database.erase(it);

    this->SemanticRoutingTable[feature_type] = entry;
}

/*
 * handleMessage is and entry point for message handling.
 */
void CSE::handleMessage(cMessage *msg) {
// SWITCH ON THE 5 operational codes
    number_of_packets++;
    // assigning the values to the signal
    emit(totalpacketsSignal, number_of_packets);
    EV << "URI " << msg->getSenderModuleId() << "\n";

// if the message comes from the AE
    if (prefix("AE", msg->getSenderModule()->getName())) {
        handleAEMessage(msg);
    } else {
        handleDiscoveryMessage(msg);
        emit(flood, number_of_messages);
    }

} // end of handle message

/*
 * generateResponseMessage is used to generate query response message (scheduling self-message)
 * to be redirected to the source of the query
 */
void CSE::generateResponseMessage(discoveryMessage *msg, ResultCode result) {
    EV << "inside generateResponseMessage Procedure" << "\n";

    auto responseMsg = generateMessage(RESPONSE);
//These data may change during the routing of the query
// we set the direction to NODIR
    responseMsg->setDirection(NODIR);
    responseMsg->setFeature_type(msg->getFeature_type());
    responseMsg->setGateVector(msg->getGateVector());
    responseMsg->setReturnCode(result);
    responseMsg->setURI_init(this->Uri);

    cancelEvent(responseMsg);
    scheduleAt(simTime(), responseMsg);
}

// this method forward the initial query to CSE
// void CSE::parseRouting(AEMessage *msg) {
// this function is transforming a query message to a discovery message

void CSE::generateDiscoveryMessage(AEMessage *msg) {
// this function transforms a query message to a discovery message
// these data should not change during the routing between CSEs
// TODO lets consider if the URI parameter  is useful ??

// we created a discovery message
    discoveryMessage *queryMsg = new discoveryMessage("QUERY");
// we extract the URI from the AE URI_init of the message
    queryMsg->setURI_init(msg->getURI());
// we extract the msg feature_type from AEmessage and we set it in the discovery Message
    queryMsg->setFeature_type(msg->getFeature_type());

// we set op_code to QUERY
    queryMsg->setOp_code(QUERY);
    queryMsg->setQueryID(msg->getQueryID());

//These data may change during the routing of the query

// set the hop count
    queryMsg->setHopCount(msg->getMaxHop());

// we set the direction UP
    queryMsg->setDirection(UP);

// create a omnet vector of type cGate* named gateVector
    std::vector<cGate*> gateVector = queryMsg->getGateVector();
//You update the discoveryMessage with this object
    queryMsg->setGateVector(gateVector);
// You put on top of the list  the name of the gate to be used in the return path (getOtherHalf)
    gateVector.push_back(msg->getArrivalGate()->getOtherHalf());

    EV << "back cse event7  " << gateVector.back()->getFullName();
    EV << "front  " << gateVector.front()->getFullName();

// We  update the query msg with this vector
    queryMsg->setGateVector(gateVector);
    EV << "back cse event7  "
              << queryMsg->getGateVector().back()->getFullName();
    EV << "front  " << queryMsg->getGateVector().front()->getFullName();

// we schedule this query message to be sent asap in the simulation schedule
    number_of_messages++;
    scheduleAt(simTime(), queryMsg);

// delete the AE message
}

/*
 * multicast is used to send messages in a multicast manner through the specified gate,
 * optionally restricting maximal number of messages.
 */
bool CSE::multicast(std::string gateName, discoveryMessage *discoveryMsg,
        int maxMessages) {

    auto dir = gateToDirection[gateName];
    std::string outGate = gateName + "$o";
    // checking the size of gate
    int t = gateSize(gateName.c_str());
    //if it is greater than zero means if we have customer
    if (t <= 0) {
        return false;
    }

    // it detects the size of the customer gates
    int Uri = gate(outGate.c_str(), 0)->getId();
    EV << "uri of destination " << Uri << "\n";
    int vectSize = gate(outGate.c_str(), 0)->getVectorSize();
    // it register in the scheduler map the UR of the CSE and the parameters of the gate
    // we will forward through the vectSize of customer gate which have all the customer

    int sent = 0;

    for (int i = 0; i < vectSize; i++) {
        if (sent >= maxMessages) {
            break;
        }

        auto gateVector = discoveryMsg->getGateVector();
        bool visited = false;
        cGate *gateToSend = gate(outGate.c_str(), i);
        for (auto g : gateVector) {
            auto gID = g->getConnectionId();
            auto sID = gateToSend->getConnectionId();
            if (gID == sID) {
                visited = true;
                break;
            }
        }
        if (visited) {
            continue;
        }

        auto msg = discoveryMsg->dup();
        msg->setDirection(dir);
        sendDelayed(msg, delay, outGate.c_str(), i);
        sent++;
    }
//    delete discoveryMsg;
    return sent > 0;
}

/*std::vector<URI> CSE::UpdateBucket(discoveryMessage *msg) {
    std::string feature_type = msg->getFeature_type();
    auto entry = getOrCreateRoutingEntry(feature_type);
    int uri = msg->getSenderModuleId();
    auto f = std::find(entry.CSEBucket.begin(), entry.CSEBucket.end(), uri);
// if the response is positive, we check the URI in the
    if (f != entry.CSEBucket.end()) {
        entry.CSEBucket.insert(entry.CSEBucket.begin(),
                msg->getSenderModuleId());
        return entry.CSEBucket.second;
    }
    //otherwise
    if (entry.CSEBucket.size() <= 100) {
        entry.CSEBucket.insert(entry.CSEBucket.begin(),
                msg->getSenderModuleId());
        return entry.CSEBucket;
    }
    // otherwise
    int i = entry.CSEBucket
    auto it = this->Gates[i];
    int gateIndex = it.second;
    std::string gateName = it.first + "$o";
    pingMessage *pingMsg = new pingMessage("ping");
    pingMsg->setURI(uri);
    pingMsg->setFeature_type(feature_type);
    pingMsg->setFlag(PING);
    // ping message
    send(pingMsg, gateName.c_str(), gateIndex);

    // after receiving ping

    if()
    entry.CSEBucket.pop_back();
    entry.CSEBucket.insert(entry.CSEBucket.begin(), msg->getSenderModuleId());
    return entry.CSEBucket;
    // save the data in Routing Table
    this->SemanticRoutingTable[feature_type] = entry;
}*/

/*
 * getOrCreateRoutingEntry is a primitive to avoid cumbersome map access and entry creation
 * if map element with such key is missing
 *
 */
RoutingEntry CSE::getOrCreateRoutingEntry(std::string feature_type) {
    auto it = this->SemanticRoutingTable.find(feature_type);
    if (it == this->SemanticRoutingTable.end()) {
        return RoutingEntry { };
    }

    return it->second;
}

/*
 * mustGetRoutingEntry is used to always get non-empty routing entry by key.
 * If it fails, fatal error will be thrown.
 */
RoutingEntry CSE::mustGetRoutingEntry(std::string feature_type) {
    auto it = this->SemanticRoutingTable.find(feature_type);
    if (it == this->SemanticRoutingTable.end()) {
        EV_INFO<< "Expected routing entry to exist\n";
        return RoutingEntry { };
    }

    return it->second;
}

/*
 * handleNotify is used to process `discoveryMessage` of type NOTIFY.
 * It updates sematic routing table for specific relationship type
 * (e.g. Customer, Peer, Sibling, Provider)
 */
void CSE::handleNotify(discoveryMessage *msg) {
    std::string feature_type = msg->getFeature_type();
    URI cse = msg->getURI_route();
    int delta = msg->getDelta();
    int direction = msg->getDirection();

    auto entry = getOrCreateRoutingEntry(feature_type);

    std::string inputGate = msg->getArrivalGate()->getBaseName();
    this->Gates[cse] = std::make_pair(inputGate,
            msg->getArrivalGate()->getIndex());

    switch (direction) {
    case UP:
        entry.CSECustomer[cse] += delta;
        break;
    case DOWN:
        entry.CSEProvider[cse] += delta;
        break;
    case SIDE_SIBLING:
        entry.CSESibling[cse] += delta;
        break;
    case SIDE_PEER:
        entry.CSEPeer[cse] += delta;
        break;
    }

    this->SemanticRoutingTable[feature_type] = entry;

    // notification depth reached
    if (msg->getHopCount() >= this->NotificationDepth) {
        return;
    }

    EV << "Redirecting notify\n";

    // notify
    msg->setHopCount(msg->getHopCount() + 1);
    msg->setURI_route(this->Uri);
    notifyNeighbors(msg->dup());
}

/*
 * notifyCSE is used to create and broadcast notification message to the neighbors.
 */
void CSE::notifyCSE(std::string feature_type, int delta) {

    EV << "inside notify\n";
//assemble message
    auto msg = generateMessage(NOTIFY);
    msg->setFeature_type(feature_type.c_str());
    msg->setDelta(delta);

// send to CSEs
    notifyNeighbors(msg);
}

/*
 * notifyNeighbors is used to broadcast notification to all neighbors,
 * excluding the neighbor that sent the message to the current CSE.
 * Also, populates gate vector of the message with the arrival gate.
 */
   // TODO: change the name of the notify message
void CSE::notifyNeighbors(discoveryMessage *msg) {
    std::vector<cGate*> gateVector = msg->getGateVector();
    //You update the discoveryMessage with this object
    msg->setGateVector(gateVector);

    if (msg->getArrivalGate() != nullptr) {
        gateVector.push_back(msg->getArrivalGate()->getOtherHalf());
        msg->setGateVector(gateVector);
    }

    EV << "sending messages to downstream\n";
    multicast("customer", msg);

    EV << "sending messages to sidestream\n";
    multicast("peer", msg);
    multicast("sibling", msg);

    EV << "sending messages to upsteam\n";
    multicast("provider", msg);
    delete msg;
}

/*
 * DBLookup is used to perform lookup in the semantic routing table for
 * AEs children of the current CSE.
 */
URI CSE::DBLookup(discoveryMessage *msg)
{

    auto feature_type = msg->getFeature_type();
// extracting the feature_type
    auto it = this->SemanticRoutingTable.find(feature_type);
// if we find the data correspond to the feature_type
    if (it == this->SemanticRoutingTable.end()) {
        return NOT_FOUND;
    }

    if (it->second.database.size() == 0) {
        return NOT_FOUND;
    }

    bubble("Success");
    return it->second.database.begin()->first;
}

/*
 * generateMessage is used to generate message of specified type.
 */
discoveryMessage* CSE::generateMessage(int op_code) {
    switch (op_code) {
    case QUERY: {
        // Produce source and destination addresses.
        int URI_route = getId();
        char msgname[20];
        sprintf(msgname, "Q");
        // Create message object and set source and destination field.
        discoveryMessage *msg = new discoveryMessage(msgname);
        msg->setDirection(DOWN);
        msg->setOp_code(QUERY);
        msg->setURI_route(URI_route);
        return msg;
        break;
    }
    case RESPONSE: {
        int URI_route = getId();
        char msgname[20];
        sprintf(msgname, "Rsp");
        // Create message object and set source and destination field.
        discoveryMessage *msg = new discoveryMessage(msgname);
        //msg->setPayload("thermometer");
        msg->setDirection(DOWN);
        msg->setOp_code(RESPONSE);
        msg->setURI_route(URI_route);
        return msg;
        break;
    }
    case NOTIFY: {
        int URI_route = getId();
        char msgname[20];
        sprintf(msgname, "N");
        // Create message object and set source and destination field.
        discoveryMessage *msg = new discoveryMessage(msgname);
        //msg->setPayload("thermometer");
        msg->setDirection(DOWN);
        msg->setOp_code(NOTIFY);
        msg->setURI_route(URI_route);
        msg->setURI_init(URI_route);
        return msg;
        break;
    }
    case REGISTRATION: {
        int URI_route = getId();
        char msgname[20];
        sprintf(msgname, "Rg");
        // Create message object and set source and destination field.
        discoveryMessage *msg = new discoveryMessage(msgname);
        //msg->setPayload("thermometer");
        msg->setDirection(DOWN);
        msg->setOp_code(REGISTRATION);
        msg->setURI_route(URI_route);
        return msg;
        break;
    }
    case CANCELLATION: {
        int URI_route = getId();
        char msgname[20];
        sprintf(msgname, "C");
        // Create message object and set source and destination field.
        discoveryMessage *msg = new discoveryMessage(msgname);
        //msg->setPayload("thermometer");
        msg->setDirection(DOWN);
        msg->setOp_code(REGISTRATION);
        msg->setURI_route(URI_route);
        return msg;
        break;
    }
    default:
        break;
    }

    return nullptr;
}

void CSE::orderingMap(std::map<int, int>) {
    return;
}