QoSCube.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.

/*
 * @file QoSCube.h
 * @author Marcel Marek
 * @date Apr 28, 2014
 * @brief
 * @detail
 */

#ifndef QOSCUBE_H_
#define QOSCUBE_H_

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

extern const char*          STR_DONOTCARE;
extern const char*          STR_YES;
extern const char*          STR_NO;
extern const int            VAL_DEFAULT_QOS;
extern const std::string    VAL_UNDEF_QOSID;
extern const std::string    VAL_MGMTQOSID;

extern const char*          ELEM_ATIME;
extern const char*          ELEM_EFCPPOL;

class QoSCube {

  protected:
    std::string qoSId;

    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

    double aTime;               //A-Timer in ms

    bool rxOn;            //Is retransmission active

    bool windowFCOn;            //Is Window-based Flow Control active

    bool rateFCOn;            //Is Rate-based Flow Control active

    EFCPPolicySet* efcpPolicies;

    int resiliencyFactor;

  public:
    QoSCube();

    QoSCube(cXMLElementList& attrs);

    QoSCube(std::string tqosid,
            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,
            double tatime, bool trxon, bool twinfcon, bool tratefcon
            );

    virtual ~QoSCube();

    static const QoSCube MANAGEMENT;

    bool isDefined();

    std::string getQosId() const;

    void setQosId(std::string qoSId);

    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);

    double getATime() const;

    void setATime(double aTime);

    bool isDTCPNeeded() const;

    int getResiliencyFactor() const {
        return resiliencyFactor;
    }

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

    std::string info() const;

    const EFCPPolicySet* getEfcpPolicies() const;
    void setEfcpPolicies(EFCPPolicySet* efcpPolicies);
    bool isRateFcOn() const;
    bool isRxOn() const;
    bool isWindowFcOn() const;
    void setRateFcOn(bool rateFcOn);
    void setRxOn(bool rxOn);
    void setWindowFcOn(bool windowFcOn);
};

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

#endif /* QOSCUBE_H_ */