inet::LibTable Class Reference

Represents the Label Information Base (LIB) for MPLS. More...

#include <LibTable.h>

Inheritance diagram for inet::LibTable:

Classes
struct	LibEntry

Public Member Functions
virtual bool	resolveLabel (std::string inInterface, int inLabel, LabelOpVector &outLabel, std::string &outInterface, int &color)
virtual int	installLibEntry (int inLabel, std::string inInterface, const LabelOpVector &outLabel, std::string outInterface, int color)
virtual void	removeLibEntry (int inLabel)

Static Public Member Functions
static LabelOpVector	pushLabel (int label)
static LabelOpVector	swapLabel (int label)
static LabelOpVector	popLabel ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	readTableFromXML (const cXMLElement *libtable)

Protected Attributes
int	maxLabel
std::vector< LibEntry >	lib

Detailed Description

Represents the Label Information Base (LIB) for MPLS.

Member Function Documentation

handleMessage()

void inet::LibTable::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    ASSERT(false);
}

initialize()

void inet::LibTable::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        maxLabel = 0;
        WATCH_VECTOR(lib);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        // read configuration
        readTableFromXML(par("config"));
    }
}

installLibEntry()

int inet::LibTable::installLibEntry ( int  inLabel, std::string  inInterface, const LabelOpVector &  outLabel, std::string  outInterface, int  color  )

virtual

{
    if (inLabel == -1) {
        LibEntry newItem;
        newItem.inLabel = ++maxLabel;
        newItem.inInterface = inInterface;
        newItem.outLabel = outLabel;
        newItem.outInterface = outInterface;
        newItem.color = color;
        lib.push_back(newItem);
        return newItem.inLabel;
    }
    else {
        for (auto& elem : lib) {
            if (elem.inLabel != inLabel)
                continue;
 
            elem.inInterface = inInterface;
            elem.outLabel = outLabel;
            elem.outInterface = outInterface;
            elem.color = color;
            return inLabel;
        }
        ASSERT(false);
        return 0; // prevent warning
    }
}

numInitStages()

virtual int inet::LibTable::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

popLabel()

LabelOpVector inet::LibTable::popLabel ( )

static

{
    LabelOpVector vec;
    LabelOp lop;
    lop.optcode = POP_OPER;
    lop.label = 0;
    vec.push_back(lop);
    return vec;
}

Referenced by inet::Ldp::processLABEL_REQUEST(), and inet::Ldp::updateFecListEntry().

pushLabel()

LabelOpVector inet::LibTable::pushLabel ( int  label )

static

{
    LabelOpVector vec;
    LabelOp lop;
    lop.optcode = PUSH_OPER;
    lop.label = label;
    vec.push_back(lop);
    return vec;
}

Referenced by inet::Ldp::lookupLabel().

readTableFromXML()

void inet::LibTable::readTableFromXML ( const cXMLElement *  libtable )

protectedvirtual

{
    using namespace xmlutils;
 
    ASSERT(libtable);
    ASSERT(!strcmp(libtable->getTagName(), "libtable"));
    checkTags(libtable, "libentry");
    cXMLElementList list = libtable->getChildrenByTagName("libentry");
    for (auto& elem : list) {
        const cXMLElement& entry = *elem;
 
        checkTags(&entry, "inLabel inInterface outLabel outInterface color");
 
        LibEntry newItem;
        newItem.inLabel = getParameterIntValue(&entry, "inLabel");
        newItem.inInterface = getParameterStrValue(&entry, "inInterface");
        newItem.outInterface = getParameterStrValue(&entry, "outInterface");
        newItem.color = getParameterIntValue(&entry, "color", 0);
 
        cXMLElementList ops = getUniqueChild(&entry, "outLabel")->getChildrenByTagName("op");
        for (auto& ops_oit : ops) {
            const cXMLElement& op = *ops_oit;
            const char *val = op.getAttribute("value");
            const char *code = op.getAttribute("code");
            ASSERT(code);
            LabelOp l;
 
            if (!strcmp(code, "push")) {
                l.optcode = PUSH_OPER;
                ASSERT(val);
                l.label = atoi(val);
                ASSERT(l.label > 0);
            }
            else if (!strcmp(code, "pop")) {
                l.optcode = POP_OPER;
                ASSERT(!val);
            }
            else if (!strcmp(code, "swap")) {
                l.optcode = SWAP_OPER;
                ASSERT(val);
                l.label = atoi(val);
                ASSERT(l.label > 0);
            }
            else
                ASSERT(false);
 
            newItem.outLabel.push_back(l);
        }
 
        lib.push_back(newItem);
 
        ASSERT(newItem.inLabel > 0);
 
        if (newItem.inLabel > maxLabel)
            maxLabel = newItem.inLabel;
    }
}

Referenced by initialize().

removeLibEntry()

void inet::LibTable::removeLibEntry ( int  inLabel )

virtual

{
    for (unsigned int i = 0; i < lib.size(); i++) {
        if (lib[i].inLabel != inLabel)
            continue;
 
        lib.erase(lib.begin() + i);
        return;
    }
    ASSERT(false);
}

resolveLabel()

bool inet::LibTable::resolveLabel ( std::string  inInterface, int  inLabel, LabelOpVector &  outLabel, std::string &  outInterface, int &  color  )

virtual

{
    bool any = (inInterface.length() == 0);
 
    for (auto& elem : lib) {
        if (!any && elem.inInterface != inInterface)
            continue;
 
        if (elem.inLabel != inLabel)
            continue;
 
        outLabel = elem.outLabel;
        outInterface = elem.outInterface;
        color = elem.color;
 
        return true;
    }
    return false;
}

swapLabel()

LabelOpVector inet::LibTable::swapLabel ( int  label )

static

{
    LabelOpVector vec;
    LabelOp lop;
    lop.optcode = SWAP_OPER;
    lop.label = label;
    vec.push_back(lop);
    return vec;
}

Referenced by inet::Ldp::processLABEL_MAPPING(), inet::Ldp::processLABEL_REQUEST(), and inet::Ldp::updateFecListEntry().

Member Data Documentation

lib

std::vector<LibEntry> inet::LibTable::lib

protected

Referenced by initialize(), installLibEntry(), inet::operator<<(), readTableFromXML(), removeLibEntry(), and resolveLabel().

maxLabel

int inet::LibTable::maxLabel

protected

Referenced by initialize(), installLibEntry(), and readTableFromXML().

---

The documentation for this class was generated from the following files:

• LibTable.h
• LibTable.cc