ComtreeRegister.cpp

Go to the documentation of this file.

#include "ComtreeRegister.h"

namespace forest {


ComtreeRegister::ComtreeRegister(int maxComtrees) : maxComt(maxComtrees) {
                cvec = new Comtree[maxComt+1];
                comtMap = new IdMap(maxComt);
                maxCtx = 0;
}
                
ComtreeRegister::~ComtreeRegister() {
                delete [] cvec; delete comtMap;
                pthread_mutex_destroy(&mapLock);
}

bool ComtreeRegister::init() {
        if (pthread_mutex_init(&mapLock,NULL) != 0) return false;
                for (int ctx = 1; ctx <= maxComt; ctx++) {
                                cvec[ctx].busyBit = false;
                                if (pthread_cond_init(&cvec[ctx].busyCond,NULL) != 0)
                                                return false;
                }
                return true;
}

int ComtreeRegister::getComtIndex(comt_t comt) {
                lockMap();
                int ctx = comtMap->getId(key(comt));
                if (ctx == 0) { unlockMap(); return 0; }
                while (cvec[ctx].busyBit) { // wait until client's entry is not busy
                                pthread_cond_wait(&cvec[ctx].busyCond,&mapLock);
                                if (ctx == 0) { unlockMap(); return 0; }
                }
                cvec[ctx].busyBit = true; // set busyBit to lock entry
                unlockMap();
                return ctx;
}

void ComtreeRegister::releaseComtree(int ctx) {
                lockMap();
                cvec[ctx].busyBit = false;
                pthread_cond_signal(&cvec[ctx].busyCond);
                unlockMap();
}

ctx ComtreeRegister::firstComtree() {
                lockMap();
                int ctx = comtMap->firstId();
                if (ctx == 0) { unlockMap(); return 0; }
                while (cvec[ctx].busyBit) {
                                pthread_cond_wait(&cvec[ctx].busyCond,&mapLock);
                                ctx = comtMap->firstId();
                                if (ctx == 0) {
                                                pthread_cond_signal(&cvec[ctx].busyCond);
                                                unlockMap(); return 0;
                                }
                }
                cvec[ctx].busyBit = true;
                unlockMap();
                return ctx;
}

int ComtreeRegister::nextComtree(int ctx) {
                lockMap();
                int nuCtx = comtMap->nextId(ctx);
                if (nuCtx == 0) {
                                cvec[ctx].busyBit = false;
                                pthread_cond_signal(&cvec[ctx].busyCond);
                                unlockMap();
                                return 0;
                }
                while (cvec[nuCtx].busyBit) {
                                pthread_cond_wait(&cvec[nuCtx].busyCond,&mapLock);
                                nuCtx = comtMap->nextId(ctx);
                                if (nuCtx == 0) {
                                                cvec[ctx].busyBit = false;
                                                pthread_cond_signal(&cvec[ctx].busyCond);
                                                pthread_cond_signal(&cvec[nuCtx].busyCond);
                                                unlockMap();
                                                return 0;
                                }
                }
                cvec[nuCtx].busyBit = true;
                cvec[ctx].busyBit = false;
                pthread_cond_signal(&cvec[ctx].busyCond);
                unlockMap();
                return nuCtx;
}

int ComtreeRegister::addComtree(comt_t comt, int ctx) {
                lockMap();
                if (ctx == 0) ctx = comtMap->addPair(key(comt));
                else ctx = comtMap->addPair(key(comt),ctx);
                if (ctx == 0) { unlockMap(); return 0;}
                cvec[ctx].busyBit = true;
                unlockMap();

                cvec[ctx].comt = comt;
                maxCtx = max(ctx,maxCtx);
                return ctx;
}

void ComtreeRegister::removeComtree(int ctx) {
                lockMap();
                comtMap->dropPair(key(getComtree(ctx)));
                cvec[ctx].busyBit = false;
                pthread_cond_signal(&cvec[ctx].busyCond);
                unlockMap();
}

bool ComtreeRegister::readEntry(istream& in, int ctx) {
                comt_t comt, string owner, pwd, cfgString, axsString;
                fAdr_t rootZip, super;
                int repInterval; time_t start;

                ss << getComtree(ctx) << ", " << getOwner(ctx) << ", ";
                ss << Forest::fAdr2string(getRootZip(ctx),s) << ", ";
                ss << Forest::fAdr2string(getSuper(ctx),s) << ", ";

                if (!in.good()) return false;
        if (Misc::verify(in,'+')) {
                        if (!Misc::readNum(in, comt) ||
                                    !Misc::verify(in,',') ||
                                    !Misc::readWord(in, owner)  ||
                                    !Misc::verify(in,',') || 
                                    !Forest::readForestAdr(in, rootZip) ||
                                    !Misc::verify(in,',') || 
                                    !Forest::readForestAdr(in, super) ||
                                    !Misc::verify(in,',') || 
                                    !Misc::readWord(in, cfgString) ||
                                    !Misc::verify(in,',') || 
                                    !Misc::readString(in, axsString) ||
                                    !Misc::verify(in,',') ||
                                    !Misc::readWord(in, pwd) ||
                                    !Misc::verify(in,',') ||
                                    !Misc::readNum(in, repInterval) ||
                                    !Misc::verify(in,',') ||
                                    !Misc::readNum(in, start)) {
                                return false;
                                }
                                Misc::cflush(in,'\n');
                } else if (Misc::verify(in,'-')) {
                                maxCtx = max(ctx, maxCtx);
                                Misc::cflush(in,'\n'); return true;
                } else {
                                Misc::cflush(in,'\n'); return false;
                }

                Forest::ConfigMode cfg;
                     if (cfgString == "static")                 cfg = STATIC;
                else if (cfgString == "leafAdjust")             cfg = LEAFADJUST;
                else if (cfgString == "stepAdjust")             cfg = STEPADJUST;
                else                                                                            cfg = NUL_CFG;

                Forest::AccessMethod axs;
                     if (axsString == "open")                   axs = OPEN;
                else if (axsString == "byPermission")           axs = BYPERMISSION;
                else if (axsString == "byPassword")             axs = BYPASSWORD;
                else                                                                            axs = NUL_AXS;
                
                if (addComtree(comt, ctx) == 0) return false;
                setOwner(ctx,owner);
                setRootZip(ctx,rootZip); setSuper(ctx,super);
                setConfigMode(ctx) = cfg; setAccessMethod(ctx) = axs;
                setPassword(ctx,password);
                setReportInterval(ctx) = repInterval; setStartTime(ctx) = start;
                releaseComtree(ctx);
        return true;
}

bool ComtreeRegister::read(istream& in) {
                int i = 0;
                while (readEntry(in,i)) i++;
                cout << "read " << i << " client records, producing "
                     << clients->getNumIn() << "table entries\n";
        return true;
}

string& ComtreeRegister::comtree2string(int ctx, string& s) const {
                stringstream ss;
                ss << getComtree(ctx) << ", " << getOwner(ctx) << ", ";
                ss << Forest::fAdr2string(getRootZip(ctx),s) << ", ";
                ss << Forest::fAdr2string(getSuper(ctx),s) << ", ";

                Forest::ConfigMode cfg = getConfigMode(ctx);
                switch (cfg) {
                case STATIC:    ss << "static"; break;
                case LEAFADJUST: ss << "leafAdjust"; break;
                case STEPADJUST: ss << "stepAdjust"; break;
                default: ss << "-";
                }
                ss << ", ";

                Forest::AccessMethod axs = getAccessMethod(ctx);
                switch (axs) {
                case OPEN:      ss << "open"; break;
                case BYPERMISSION: ss << "byPermission"; break;
                case BYPASSWORD: ss << "byPassword"; break;
                default: ss << "-";
                }
                ss << ", ";

                ss << getPassword(ctx) << ", " << getReportInterval(ctx) << ", "
                   << getStartTime(ctx) << endl;

                s = ss.str();
                return s;
}

string& ComtreeRegister::toString(string& s) {
                string s1; s = "";
                for (int ctx = firstComtree(); ctx != 0; ctx = nextComtree(ctx))
                s += client2string(ctx,s1);
                return s;
}

void ComtreeRegister::write(ostream& out) {
                string s;
                for (int ctx = firstComtree(); ctx != 0; ctx = nextComtree(ctx))
                out << client2string(ctx,s);
}

} // ends namespace