Open Source Projects Europe

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// 

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU Lesser General Public License for more details.

// 

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see http://www.gnu.org/licenses/.

// 

#include "AEBase.h"

Define_Module(AEBase);

const char* PAR_AVGBW               = "averageBandwidth";

const char* PAR_AVGSDUBW            = "averageSDUBandwidth";

const char* PAR_PEAKBWDUR           = "peakBandwidthDuration";

const char* PAR_PEAKSDUBWDUR        = "peakSDUBandwidthDuration";

const char* PAR_BURSTPERIOD         = "burstPeriod";

const char* PAR_BURSTDURATION       = "burstDuration";

const char* PAR_UNDETECTBITERR      = "undetectedBitErr";

const char* PAR_MAXSDUSIZE          = "maxSDUsize";

const char* PAR_PARTIALDELIVER      = "partialDelivery";

const char* PAR_INCOMPLETEDELIVER   = "incompleteDelivery";

const char* PAR_FORCEORDER          = "forceOrder";

const char* PAR_MAXALLOWGAP         = "maxAllowGap";

const char* PAR_DELAY               = "delay";

const char* PAR_JITTER              = "jitter";

const char* PAR_COSTTIME            = "costTime";

const char* PAR_COSTBITS            = "costBits";

const APNamingInfo& AEBase::getApni() const {

    return apni;

}

void AEBase::setApni(const APNamingInfo& apni) {

    this->apni = apni;

}

const Flows& AEBase::getFlows() const {

    return flows;

}

void AEBase::setFlows(const Flows& flows) {

    this->flows = flows;

}

const std::string& AEBase::getSrcAeInstance() const {

    return srcAeInstance;

}

void AEBase::setSrcAeInstance(const std::string& srcAeInstance) {

    this->srcAeInstance = srcAeInstance;

}

const std::string& AEBase::getSrcAeName() const {

    return srcAeName;

}

void AEBase::setSrcAeName(const std::string& srcAeName) {

    this->srcAeName = srcAeName;

}

const std::string& AEBase::getSrcApInstance() const {

    return srcApInstance;

}

void AEBase::setSrcApInstance(const std::string& srcApInstance) {

    this->srcApInstance = srcApInstance;

}

const std::string& AEBase::getSrcApName() const {

    return srcApName;

}

void AEBase::setSrcApName(const std::string& srcApName) {

    this->srcApName = srcApName;

}

void AEBase::initNamingInfo() {

    //Source info

    srcApName = this->getParentModule()->par(PAR_APNAME).stdstringValue();

    srcApInstance = this->getParentModule()->par(PAR_APINSTANCE).stdstringValue();

    srcAeName = this->par(PAR_AENAME).stdstringValue();

    srcAeInstance = this->par(PAR_AEINSTANCE).stdstringValue();

    apni = APNamingInfo(APN(this->srcApName), this->srcApInstance,

            this->srcAeName, this->srcAeInstance);

}

void AEBase::initialize()

{

    initNamingInfo();

    initQoSRequiremets();

}

const QosCube& AEBase::getQoSRequirements() const {

    return QoSRequirements;

}

void AEBase::setQoSRequirements(const QosCube& qoSRequirements) {

    QoSRequirements = qoSRequirements;

}

void AEBase::initQoSRequiremets() {

    //Check whether module has all QoS parameters

    if (! (hasPar(PAR_AVGBW) &&

           hasPar(PAR_AVGSDUBW) &&

           hasPar(PAR_PEAKBWDUR) &&

           hasPar(PAR_PEAKSDUBWDUR) &&

           hasPar(PAR_BURSTPERIOD) &&

           hasPar(PAR_BURSTDURATION) &&

           hasPar(PAR_UNDETECTBITERR) &&

           hasPar(PAR_MAXSDUSIZE) &&

           hasPar(PAR_PARTIALDELIVER) &&

           hasPar(PAR_INCOMPLETEDELIVER) &&

           hasPar(PAR_FORCEORDER) &&

           hasPar(PAR_MAXALLOWGAP) &&

           hasPar(PAR_DELAY) &&

           hasPar(PAR_JITTER) &&

           hasPar(PAR_COSTTIME) &&

           hasPar(PAR_COSTBITS)

          )

       ) {

        std::stringstream ss;

        ss << "Module " << this->getFullName() << " is not derived from AEBase. It misses some important QoS parameters!";

        error(ss.str().c_str());

    }

    //Create QoS cube according to parameters

    QosCube cube;

    int avgBand                 = VAL_QOSPARAMDONOTCARE;    //Average bandwidth (measured at the application in bits/sec)

    int avgSDUBand              = VAL_QOSPARAMDONOTCARE;    //Average SDU bandwidth (measured in SDUs/sec)

    int peakBandDuration        = VAL_QOSPARAMDONOTCARE;    //Peak bandwidth-duration (measured in bits/sec);

    int peakSDUBandDuration     = VAL_QOSPARAMDONOTCARE;    //Peak SDU bandwidth-duration (measured in SDUs/sec);

    int burstPeriod             = VAL_QOSPARAMDONOTCARE;    //Burst period measured in useconds

    int burstDuration           = VAL_QOSPARAMDONOTCARE;    //Burst duration, measured in usecs fraction of Burst Period

    int undetectedBitErr        = VAL_QOSPARAMDONOTCARE;    //Undetected bit error rate measured as a probability

    int maxSDUsize              = VAL_QOSPARAMDONOTCARE;    //MaxSDUSize measured in bytes

    bool partDeliv              = VAL_QOSPARAMDEFBOOL;      //Partial Delivery - Can SDUs be delivered in pieces rather than all at once?

    bool incompleteDeliv        = VAL_QOSPARAMDEFBOOL;      //Incomplete Delivery - Can SDUs with missing pieces be delivered?

    bool forceOrder             = VAL_QOSPARAMDEFBOOL;      //Must SDUs be delivered in order?

    unsigned int maxAllowGap    = VAL_QOSPARAMDONOTCARE;    //Max allowable gap in SDUs, (a gap of N SDUs is considered the same as all SDUs delivered, i.e. a gap of N is a "don't care.")

    int delay                   = VAL_QOSPARAMDONOTCARE;    //Delay in usecs

    int jitter                  = VAL_QOSPARAMDONOTCARE;    //Jitter in usecs2

    int costtime                = VAL_QOSPARAMDONOTCARE;    //measured in $/ms

    int costbits                = VAL_QOSPARAMDONOTCARE;    //measured in $/Mb

    avgBand = par(PAR_AVGBW);

    if (avgBand < 0)

        avgBand = VAL_QOSPARAMDONOTCARE;

    avgSDUBand = par(PAR_AVGSDUBW);

    if (avgSDUBand < 0)

        avgSDUBand = VAL_QOSPARAMDONOTCARE;

    peakBandDuration = par(PAR_PEAKBWDUR);

    if (peakBandDuration < 0)

        peakBandDuration = VAL_QOSPARAMDONOTCARE;

    peakSDUBandDuration = par(PAR_PEAKSDUBWDUR);

    if (peakSDUBandDuration < 0)

        peakSDUBandDuration = VAL_QOSPARAMDONOTCARE;

    burstPeriod = par(PAR_BURSTPERIOD);

    if (burstPeriod < 0)

        burstPeriod = VAL_QOSPARAMDONOTCARE;

    burstDuration = par(PAR_BURSTDURATION);

    if (burstDuration < 0)

        burstDuration = VAL_QOSPARAMDONOTCARE;

    undetectedBitErr = par(PAR_UNDETECTBITERR);

    if (undetectedBitErr < 0 || undetectedBitErr > 1 )

        undetectedBitErr = VAL_QOSPARAMDONOTCARE;

    maxSDUsize = par(PAR_MAXSDUSIZE);

    if (maxSDUsize < 0)

        maxSDUsize = VAL_QOSPARAMDONOTCARE;

    partDeliv = par(PAR_PARTIALDELIVER);

    incompleteDeliv = par(PAR_INCOMPLETEDELIVER);

    forceOrder = par(PAR_FORCEORDER);

    maxAllowGap = par(PAR_MAXALLOWGAP);

    if (maxAllowGap < 0)

        maxAllowGap = VAL_QOSPARAMDONOTCARE;

    delay = par(PAR_DELAY);

    if (delay < 0)

        delay = VAL_QOSPARAMDONOTCARE;

    jitter = par(PAR_JITTER);

    if (jitter < 0)

        jitter = VAL_QOSPARAMDONOTCARE;

    costtime = par(PAR_COSTTIME);

    if (costtime < 0)

        costtime = VAL_QOSPARAMDONOTCARE;

    costbits = par(PAR_COSTBITS);

    if (costbits < 0)

        costbits = VAL_QOSPARAMDONOTCARE;

    cube.setQosId(0);

    cube.setAvgBand(avgBand);

    cube.setAvgSduBand(avgSDUBand);

    cube.setPeakBandDuration(peakBandDuration);

    cube.setPeakSduBandDuration(peakSDUBandDuration);

    cube.setBurstPeriod(burstPeriod);

    cube.setBurstDuration(burstDuration);

    cube.setUndetectedBitErr(undetectedBitErr);

    cube.setMaxSduSize(maxSDUsize);

    cube.setPartialDelivery(partDeliv);

    cube.setIncompleteDelivery(incompleteDeliv);

    cube.setForceOrder(forceOrder);

    cube.setMaxAllowGap(maxAllowGap);

    cube.setDelay(delay);

    cube.setJitter(jitter);

    cube.setCostBits(costbits);

    cube.setCostTime(costtime);

    this->setQoSRequirements(cube);

    //EV << "QQQQQQ\n" << cube << "\n\nXXXX\n" << this->getQoSRequirements();

}

void AEBase::handleMessage(cMessage *msg)

{

    // TODO - Generated method body

}

void AEBase::insertFlow(Flow& flow) {

    flows.push_back(flow);

}

bool AEBase::hasFlow(const Flow* flow) {

    for (TFlowsIter it = flows.begin(); it != flows.end(); ++it) {

        if (*it == *flow)

            return true;

    }

    return false;

}