inet::LIBTable Class Reference

TODO documentation. 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

TODO documentation.

Member Function Documentation

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

overrideprotectedvirtual

{
    ASSERT(false);
}

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").xmlValue());
    }
}

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

virtual

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

{
    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
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

LabelOpVector inet::LIBTable::popLabel ( )

static

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

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

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

static

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

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

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

protectedvirtual

Referenced by initialize().

{
    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;
    }
}

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

virtual

Referenced by inet::LDP::processLABEL_RELEASE(), and inet::LDP::rebuildFecList().

{
    for (unsigned int i = 0; i < lib.size(); i++) {
        if (lib[i].inLabel != inLabel)
            continue;

        lib.erase(lib.begin() + i);
        return;
    }
    ASSERT(false);
}

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

virtual

Referenced by inet::MPLS::processMPLSPacketFromL2().

{
    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;
}

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

static

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

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

Member Data Documentation

std::vector<LIBEntry> inet::LIBTable::lib

protected

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

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