QoSReq.h

Go to the documentation of this file.

// The MIT License (MIT)
//
// Copyright (c) 2014-2016 Brno University of Technology, PRISTINE project
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.


#ifndef QOSREQ_H_
#define QOSREQ_H_

//Standard libraries
#include <vector>
//RINASim libraries
#include "ExternConsts.h"
#include "QoSCube.h"

extern const char* STR_DONOTCARE;
extern const char* STR_YES;
extern const char* STR_NO;
extern const int   VAL_DEFAULT_QOS;

class QoSReq {

  protected:

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

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

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

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

    int burstPeriod;            //Burst period measured in useconds

    int burstDuration;          //Burst duration, measured in useconds fraction of Burst Period

    double undetectedBitErr;    //Undetected bit error rate measured as a probability

    double pduDropProbability;  //Probability of dropping PDUs

    int maxSDUsize;             //MaxSDUSize measured in bytes

    bool partDeliv;             //Partial Delivery - Can SDUs be delivered in pieces rather than all at once? (SHOULD NOT be part of QoS cube see EFCPSpec)

    bool incompleteDeliv;       //Incomplete Delivery - Can SDUs with missing pieces be delivered? (SHOULD NOT be part of QoS cube see EFCPSpec)

    bool forceOrder;            //Must SDUs be delivered in-order bits

    int maxAllowGap;            //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;                  //Delay in usecs

    int jitter;                 //Jitter in usecs

    int costTime;               //measured in $/ms

    int costBits;               //measured in $/Mb

    int resiliencyFactor;


  public:
    QoSReq();

    QoSReq(int tavgBand, int tavgSDUBand, int tpeakBandDuration, int tpeakSDUBandDuration, int tburstPeriod, int tburstDuration,
           double tundetectedBitErr, double tpduDropProbab,
           int tmaxSDUsize, bool tpartDeliv, bool tincompleteDeliv, bool tforceOrder,
           unsigned int tmaxAllowGap, int tdelay, int tjitter, int tcosttime, int tcostbits);

    QoSReq(cXMLElementList& attrs);

    static const QoSReq MANAGEMENT;

    virtual ~QoSReq();

    bool compare(const QoSReq& other) const;

    int getAvgBand() const;

    void setAvgBand(int avgBand);

    int getAvgSduBand() const;

    void setAvgSduBand(int avgSduBand);

    int getPeakBandDuration() const;

    void setPeakBandDuration(int peakBandDuration);

    int getPeakSduBandDuration() const;

    void setPeakSduBandDuration(int peakSduBandDuration);

    int getBurstDuration() const;

    void setBurstDuration(int burstDuration);

    int getBurstPeriod() const;

    void setBurstPeriod(int burstPeriod);

    int getMaxSduSize() const;

    void setMaxSduSize(int maxSdUsize);

    double getUndetectedBitErr() const;

    void setUndetectedBitErr(double undetectedBitErr);

    double getPduDropProbability() const;

    void setPduDropProbability(double pduDropProbability);

    bool isPartialDelivery() const;

    void setPartialDelivery(bool partDeliv);

    bool isIncompleteDelivery() const;

    void setIncompleteDelivery(bool incompleteDeliv);

    bool isForceOrder() const;

    void setForceOrder(bool forceOrder);

    int getMaxAllowGap() const;

    void setMaxAllowGap(int maxAllowGap);

    int getDelay() const;

    void setDelay(int delay);

    int getJitter() const;

    void setJitter(int jitter);

    double getCostTime() const;

    void setCostTime(double costTime);

    double getCostBits() const;

    void setCostBits(double costBits);

    int getResiliencyFactor() const {
        return resiliencyFactor;
    }

    void setResiliencyFactor(int resiliencyFactor) {
        this->resiliencyFactor = resiliencyFactor;
    }


    std::string info() const;
};

//Free function
std::ostream& operator<< (std::ostream& os, const QoSReq& cube);

#endif /* QOSREQ_H_ */