ComtreeTable.h

Go to the documentation of this file.

#ifndef COMTREETABLE_H
#define COMTREETABLE_H

#include <set>
#include "Forest.h"
#include "Dlist.h"
#include "Hash.h"
#include "HashMap.h"
#include "LinkTable.h"

using namespace grafalgo;

namespace forest {


class ComtreeTable {
public:
                struct ClnkInfo {                               
                public:
                                ClnkInfo();
                                ~ClnkInfo();
                string          toString() const;
                friend ostream& operator<<(ostream& out, const ClnkInfo& cli) {
                return out << cli.toString();
                }

                fAdr_t          dest;                                           
                int             qnum;                                           
                RateSpec rates;                                 
                };

                struct Entry {
                public:
                                Entry();
                                ~Entry();
                Entry&          operator=(const Entry&);
                Entry&          operator=(Entry&&);
                string          toString() const;
                friend          ostream& operator<<(ostream& out, const Entry& e) {
                return out << e.toString();
                }

                int             pLnk;                                           
                int             pClnk;                                          
                bool            coreFlag;                       

                HashMap<int,ClnkInfo,Hash::s32> *clMap;
                Dlist           *rtrLinks;                      
                Dlist           *coreLinks;                     
                };

                                ComtreeTable(int, int);
                                ~ComtreeTable();

                // predicates
                bool            validComtree(comt_t) const;                     
                bool            validCtx(int) const;                            
                bool            validClnk(int, int) const;                      
                bool            checkEntry(int) const;
                bool            inCore(int) const;
                bool            isLink(int, int) const;
                bool            isRtrLink(int, int) const;
                bool            isCoreLink(int, int) const;

                // iteration methods
                int             firstComt() const;
                int             nextComt(int) const;
                int             firstComtLink(int) const;
                int             nextComtLink(int, int) const;
                int             firstRtrLink(int) const;
                int             nextRtrLink(int, int) const;
                int             firstCoreLink(int) const;
                int             nextCoreLink(int, int) const;

                // access routines 
                int             getComtIndex(comt_t) const;                     
                Entry&          getEntry(int) const;
                comt_t          getComtree(int) const;
                int             getLink(int, int) const;
                int             getPlink(int) const;
                int             getPClink(int) const;
                int             getLinkCount(int) const;
                int             getClnkNum(int, int) const;
                ClnkInfo& getClnkInfo(int, int) const;
                int             getLinkQ(int, int) const;
                fAdr_t          getDest(int, int) const;
                RateSpec& getRates(int, int) const;
                const Dlist& getComtList(int) const;

                // add/remove/modify table entries
                int             addEntry(comt_t);
                bool            removeEntry(int);
                bool            addLink(int, int, bool, bool);
                bool            removeLink(int, int);
                void            setCoreFlag(int, bool);
                void            setPlink(int, int);
                void            setLinkQ(int, int, int);
                void            purgeLink(int);

                // input/output of table contents 
                bool            read(istream&);
                string          toString() const;
                string          entry2string(int) const;
private:
                int             maxLnk;                                         
                int             maxCtx;                                         
                HashMap<comt_t,Entry,Hash::u32> *comtMap;
                Dlist           *comtList;                      

                bool            readEntry(istream&);
                void            readLinks(istream&, set<int>&); 
                string          links2string(int) const;
};

inline ComtreeTable::ClnkInfo::ClnkInfo() {
                dest = 0; qnum = 0;
}

inline ComtreeTable::ClnkInfo::~ClnkInfo() { }

inline string ComtreeTable::ClnkInfo::toString() const {
                string s = Forest::fAdr2string(dest) + " "
                                   + to_string(qnum) + " " + rates.toString();
                return s;
}

inline ComtreeTable::Entry::Entry() {
                pLnk = 0; pClnk = 0; coreFlag = false;
                clMap = new HashMap<int,ClnkInfo,Hash::s32>;
                rtrLinks = new Dlist(); coreLinks = new Dlist();
}

inline ComtreeTable::Entry::~Entry() {
                delete clMap; delete rtrLinks; delete coreLinks;
}

inline ComtreeTable::Entry& ComtreeTable::Entry::operator=(const Entry& src) {
                pLnk = src.pLnk; pClnk = src.pClnk; coreFlag = src.coreFlag;
                *clMap = *(src.clMap);
                *rtrLinks = *(src.rtrLinks);
                *coreLinks = *(src.coreLinks);
                return *this;
}

inline ComtreeTable::Entry& ComtreeTable::Entry::operator=(Entry&& src) {
                pLnk = src.pLnk; pClnk = src.pClnk; coreFlag = src.coreFlag;
                delete clMap; clMap = src.clMap; src.clMap = nullptr;
                delete rtrLinks; rtrLinks = src.rtrLinks; src.rtrLinks = nullptr;
                delete coreLinks; coreLinks = src.coreLinks; src.coreLinks = nullptr;
                return *this;
}

inline string ComtreeTable::Entry::toString() const {
                string s = (coreFlag ? "* " : " ") + to_string(pLnk) + " {";
                for (int cLnk = clMap->first(); cLnk != 0; cLnk = clMap->next(cLnk)) {
                                if (cLnk != clMap->first()) s += " ";
                                s += to_string(clMap->getKey(cLnk));
                                if (coreLinks->member(cLnk)) s += "*";
                                else if (rtrLinks->member(cLnk)) s += "+";
                }
                s += "}";
                return s;
}

inline bool ComtreeTable::validComtree(comt_t comt) const {
                return comtMap->contains(comt);
}

inline bool ComtreeTable::validCtx(int ctx) const {
                return comtMap->valid(ctx);
}

inline bool ComtreeTable::validClnk(int ctx, int cLnk) const {
                Entry& e = getEntry(ctx);
                return e.clMap->valid(cLnk);
}

inline bool ComtreeTable::inCore(int ctx) const {
                Entry& e = getEntry(ctx); return e.coreFlag;
}

inline bool ComtreeTable::isLink(int ctx, int lnk) const {
                if (!validCtx(ctx)) return false;
                Entry& e = getEntry(ctx);
                return e.clMap->contains(lnk);
}

inline bool ComtreeTable::isRtrLink(int ctx, int cLnk) const {
                if (cLnk == 0 || !validCtx(ctx)) return false;
                Entry& e = getEntry(ctx);
                return e.rtrLinks->member(cLnk);
}

inline bool ComtreeTable::isCoreLink(int ctx, int cLnk) const {
                if (!validCtx(ctx)) return false;
                Entry& e = getEntry(ctx);
                return e.coreLinks->member(cLnk);
}
                
inline int ComtreeTable::firstComt() const {
                return comtMap->first();
}

inline int ComtreeTable::nextComt(int ctx) const {
                return comtMap->next(ctx);
}

inline comt_t ComtreeTable::getComtree(int ctx) const {
                return comtMap->getKey(ctx);
}

inline ComtreeTable::Entry& ComtreeTable::getEntry(int ctx) const {
                return comtMap->getValue(ctx);
}

inline int ComtreeTable::getComtIndex(comt_t comt) const {
                return comtMap->find(comt);
}

inline int ComtreeTable::getLinkCount(int ctx) const {
                Entry& e = getEntry(ctx);
                return e.clMap->size();
}

inline int ComtreeTable::getClnkNum(int comt, int lnk) const {
                int ctx = getComtIndex(comt);
                if (ctx == 0) return 0;
                Entry& e = getEntry(ctx);
                return e.clMap->find(lnk);
}

inline ComtreeTable::ClnkInfo&
ComtreeTable::getClnkInfo(int ctx, int cLnk) const {
                Entry& e = getEntry(ctx);
                return e.clMap->getValue(cLnk);
}

inline int ComtreeTable::getPlink(int ctx) const { return getEntry(ctx).pLnk; }

inline int ComtreeTable::getPClink(int ctx) const {
                return getEntry(ctx).pClnk;
}

inline int ComtreeTable::getLink(int ctx, int cLnk) const {
                Entry& e = getEntry(ctx);
                return e.clMap->getKey(cLnk);
}

inline int ComtreeTable::getLinkQ(int ctx, int cLnk) const {
                return getEntry(ctx).clMap->getValue(cLnk).qnum;
}

inline fAdr_t ComtreeTable::getDest(int ctx, int cLnk) const {
                return getEntry(ctx).clMap->getValue(cLnk).dest;
}

inline RateSpec& ComtreeTable::getRates(int ctx, int cLnk) const {
                return getEntry(ctx).clMap->getValue(cLnk).rates;
}

inline int ComtreeTable::firstComtLink(int ctx) const {
                return getEntry(ctx).clMap->first();
}

inline int ComtreeTable::nextComtLink(int ctx, int cLnk) const {
                return getEntry(ctx).clMap->next(cLnk);
}

inline int ComtreeTable::firstRtrLink(int ctx) const {
                return getEntry(ctx).rtrLinks->first();
}

inline int ComtreeTable::nextRtrLink(int ctx, int cLnk) const {
                return getEntry(ctx).rtrLinks->next(cLnk);
}

inline int ComtreeTable::firstCoreLink(int ctx) const {
                return getEntry(ctx).coreLinks->first();
}

inline int ComtreeTable::nextCoreLink(int ctx, int cLnk) const {
                return getEntry(ctx).coreLinks->next(cLnk);
}

inline void ComtreeTable::setPlink(int ctx, int plink) {
                if (!validCtx(ctx)) return;
                Entry& e = getEntry(ctx);
                if (plink == 0) { e.pLnk = 0; e.pClnk = 0; return; }
                int cLnk = e.clMap->find(plink);
                if (cLnk == 0 || !e.rtrLinks->member(cLnk)) return;
                e.pLnk = plink; e.pClnk = cLnk;
}

inline void ComtreeTable::setCoreFlag(int ctx, bool f) {
                if (validCtx(ctx)) getEntry(ctx).coreFlag = f;
}

inline void ComtreeTable::setLinkQ(int ctx, int cLnk, int q) {
                if (!validCtx(ctx)) return;
                Entry& e = getEntry(ctx);
                if (validClnk(ctx,cLnk)) e.clMap->getValue(cLnk).qnum = q;
}

} // ends namespace

#endif