//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / IE
//
//File: atmcellrate.cpp
//
//Version: $Revision: 1.4 $
//
//State: $State: Exp $
//
//Date: $Date: 1999/03/10 15:01:35 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Sami Raatikainen
//      Timo Kokkonen
//
//Description:
//      See corresponding header file.
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//
//Licence:
//
//
//History: 

#include "atmcellrate.h"

ieATMCellRate :: ieATMCellRate(void)
    : ieInformationElement(),
      _forwardPCR0(0),
      _forwardPCR1(0),
      _backwardPCR0(0),
      _backwardPCR1(0),
      _forwardSCR0(0),
      _forwardSCR1(0),
      _backwardSCR0(0),
      _backwardSCR1(0),
      _forwardMBS0(0),
      _forwardMBS1(0),
      _backwardMBS0(0),
      _backwardMBS1(0),
      _forwardPCR0set(false),
      _forwardPCR1set(false),
      _backwardPCR0set(false),
      _backwardPCR1set(false),
      _forwardSCR0set(false),
      _forwardSCR1set(false),
      _backwardSCR0set(false),
      _backwardSCR1set(false),
      _forwardMBS0set(false),
      _forwardMBS1set(false),
      _backwardMBS0set(false),
      _backwardMBS1set(false),
      _bestEffort(false),
      _tagF(false),
      _tagB(false)
{
    return;
}

ieATMCellRate :: ieATMCellRate(
    const ieATMCellRate &other_)
    : _forwardPCR0(other_._forwardPCR0),
      _forwardPCR1(other_._forwardPCR1),
      _backwardPCR0(other_._backwardPCR0),
      _backwardPCR1(other_._backwardPCR1),
      _forwardSCR0(other_._forwardSCR0),
      _forwardSCR1(other_._forwardSCR1),
      _backwardSCR0(other_._backwardSCR0),
      _backwardSCR1(other_._backwardSCR1),
      _forwardMBS0(other_._forwardMBS0),
      _forwardMBS1(other_._forwardMBS1),
      _backwardMBS0(other_._backwardMBS0),
      _backwardMBS1(other_._backwardMBS1),
      _forwardPCR0set(other_._forwardPCR0set),
      _forwardPCR1set(other_._forwardPCR1set),
      _backwardPCR0set(other_._backwardPCR0set),
      _backwardPCR1set(other_._backwardPCR1set),
      _forwardSCR0set(other_._forwardSCR0set),
      _forwardSCR1set(other_._forwardSCR1set),
      _backwardSCR0set(other_._backwardSCR0set),
      _backwardSCR1set(other_._backwardSCR1set),
      _forwardMBS0set(other_._forwardMBS0set),
      _forwardMBS1set(other_._forwardMBS1set),
      _backwardMBS0set(other_._backwardMBS0set),
      _backwardMBS1set(other_._backwardMBS1set),
      _bestEffort(other_._bestEffort),
      _tagF(other_._tagF),
      _tagB(other_._tagB)
{
    return;
}

ieATMCellRate :: ~ieATMCellRate(void)
{
    return;
}

const ieATMCellRate &ieATMCellRate :: operator=(const ieATMCellRate &other_)
{
    if (&other_ != this)
    {
        _forwardPCR0 = other_._forwardPCR0;
        _forwardPCR1 = other_._forwardPCR1;
        _backwardPCR0 = other_._backwardPCR0;
        _backwardPCR1 = other_._backwardPCR1;
        _forwardSCR0 = other_._forwardSCR0;
        _forwardSCR1 = other_._forwardSCR1;
        _backwardSCR0 = other_._backwardSCR0;
        _backwardSCR1 = other_._backwardSCR1;
        _forwardMBS0 = other_._forwardMBS0;
        _forwardMBS1 = other_._forwardMBS1;
        _backwardMBS0 = other_._backwardMBS0;
        _backwardMBS1 = other_._backwardMBS1;
        _forwardPCR0set = other_._forwardPCR0set;
        _forwardPCR1set = other_._forwardPCR1set;
        _backwardPCR0set = other_._backwardPCR0set;
        _backwardPCR1set = other_._backwardPCR1set;
        _forwardSCR0set = other_._forwardSCR0set;
        _forwardSCR1set = other_._forwardSCR1set;
        _backwardSCR0set = other_._backwardSCR0set;
        _backwardSCR1set = other_._backwardSCR1set;
        _forwardMBS0set = other_._forwardMBS0set;
        _forwardMBS1set = other_._forwardMBS1set;
        _backwardMBS0set = other_._backwardMBS0set;
        _backwardMBS1set = other_._backwardMBS1set;
        _bestEffort = other_._bestEffort;
        _tagF = other_._tagF;
        _tagB = other_._tagB;
    }
    return *this;
}

pfIE *ieATMCellRate :: clone(void) const
{
    ieATMCellRate *newIe = new ieATMCellRate(*this);
    return (pfIE *)newIe;
}

void ieATMCellRate :: setForwardPCR0(pfUlong value_)
{
    _forwardPCR0 = value_;
    _forwardPCR0set = true;
    return;
}

void ieATMCellRate :: setForwardPCR1(pfUlong value_)
{
    _forwardPCR1 = value_;
    _forwardPCR1set = true;
    return;
}

void ieATMCellRate :: setBackwardPCR0(pfUlong value_)
{
    _backwardPCR0 = value_;
    _backwardPCR0set = true;
    return;
}

void ieATMCellRate :: setBackwardPCR1(pfUlong value_)
{
    _backwardPCR1 = value_;
    _backwardPCR1set = true;
    return;
}

pfUlong ieATMCellRate :: getForwardPCR0(void) const
{
    return _forwardPCR0;
}

pfUlong ieATMCellRate :: getForwardPCR1(void) const
{
    return _forwardPCR1;
}

pfUlong ieATMCellRate :: getBackwardPCR0(void) const
{
    return _backwardPCR0;
}

pfUlong ieATMCellRate :: getBackwardPCR1(void) const
{
    return _backwardPCR1;
}

bool ieATMCellRate :: isForwardPCR0(void) const
{
    return _forwardPCR0set;
}

bool ieATMCellRate :: isForwardPCR1(void) const
{
    return _forwardPCR1set;
}

bool ieATMCellRate :: isBackwardPCR0(void) const
{
    return _backwardPCR0set;
}

bool ieATMCellRate :: isBackwardPCR1(void) const
{
    return _backwardPCR1set;
}

// Sustainable
void ieATMCellRate :: setForwardSCR0(pfUlong value_)
{
    _forwardSCR0 = value_;
    _forwardSCR0set = true;
    return;
}

void ieATMCellRate :: setForwardSCR1(pfUlong value_)
{
    _forwardSCR1 = value_;
    _forwardSCR1set = true;
    return;
}

void ieATMCellRate :: setBackwardSCR0(pfUlong value_)
{
    _backwardSCR0 = value_;
    _backwardSCR0set = true;
    return;
}

void ieATMCellRate :: setBackwardSCR1(pfUlong value_)
{
    _backwardSCR1 = value_;
    _backwardSCR1set = true;
    return;
}

pfUlong ieATMCellRate :: getForwardSCR0(void) const
{
    return _forwardSCR0;
}

pfUlong ieATMCellRate :: getForwardSCR1(void) const
{
    return _forwardSCR1;
}

pfUlong ieATMCellRate :: getBackwardSCR0(void) const
{
    return _backwardSCR0;
}

pfUlong ieATMCellRate :: getBackwardSCR1(void) const
{
    return _backwardSCR1;
}

bool ieATMCellRate :: isForwardSCR0(void) const
{
    return _forwardSCR0set;
}

bool ieATMCellRate :: isForwardSCR1(void) const
{
    return _forwardSCR1set;
}

bool ieATMCellRate :: isBackwardSCR0(void) const
{
    return _backwardSCR0set;
}

bool ieATMCellRate :: isBackwardSCR1(void) const
{
    return _backwardSCR1set;
}

// Max Burst Size
void ieATMCellRate :: setForwardMBS0(pfUlong value_)
{
    _forwardMBS0 = value_;
    _forwardMBS0set = true;
    return;
}

void ieATMCellRate :: setForwardMBS1(pfUlong value_)
{
    _forwardMBS1 = value_;
    _forwardMBS1set = true;
    return;
}

void ieATMCellRate :: setBackwardMBS0(pfUlong value_)
{
    _backwardMBS0 = value_;
    _backwardMBS0set = true;
    return;
}

void ieATMCellRate :: setBackwardMBS1(pfUlong value_)
{
    _backwardMBS1 = value_;
    _backwardMBS1set = true;
    return;
}

pfUlong ieATMCellRate :: getForwardMBS0(void) const
{
    return _forwardMBS0;
}

pfUlong ieATMCellRate :: getForwardMBS1(void) const
{
    return _forwardMBS1;
}

pfUlong ieATMCellRate :: getBackwardMBS0(void) const
{
    return _backwardMBS0;
}

pfUlong ieATMCellRate :: getBackwardMBS1(void) const
{
    return _backwardMBS1;
}

bool ieATMCellRate :: isForwardMBS0(void) const
{
    return _forwardMBS0set;
}

bool ieATMCellRate :: isForwardMBS1(void) const
{
    return _forwardMBS1set;
}

bool ieATMCellRate :: isBackwardMBS0(void) const
{
    return _backwardMBS0set;
}

bool ieATMCellRate :: isBackwardMBS1(void) const
{
    return _backwardMBS1set;
}

// Other information (UNI3.1)
void ieATMCellRate :: setBestEffort(void)
{
    _bestEffort = true;
    return;
}

bool ieATMCellRate :: isBestEffortSet(void) const
{
    return _bestEffort;
}

void ieATMCellRate :: setTaggingForward(void)
{
    _tagF = true;
    return;
}

void ieATMCellRate :: setTaggingBackward(void)
{
    _tagB = true;
    return;
}

bool ieATMCellRate :: isTaggingForwardSet(void) const
{
    return _tagF;
}

bool ieATMCellRate :: isTaggingBackwardSet(void) const
{
    return _tagB;
}