AdminTable.cpp

Go to the documentation of this file.

#include "AdminTable.h"

namespace forest {


AdminTable::AdminTable(int maxAdmins) : maxAdm(maxAdmins) {
                avec = new Admin[maxAdm+1];
                admins = new UiSetPair(maxAdm);
                nameMap = new map<string, int>();
                maxAdx = 0;
}
                
AdminTable::~AdminTable() {
                delete [] avec; delete admins; delete nameMap;
                pthread_mutex_destroy(&mapLock);
}

bool AdminTable::init() {
        if (pthread_mutex_init(&mapLock,NULL) != 0) return false;
                for (int adx = 1; adx <= maxAdm; adx++) {
                                avec[adx].busyBit = false;
                                if (pthread_cond_init(&avec[adx].busyCond,NULL) != 0)
                                                return false;
                }
                return true;
}

int AdminTable::getAdmin(const string& aname) {
                lockMap();
                map<string, int>::iterator p = nameMap->find(aname);
                if (p == nameMap->end()) { unlockMap(); return 0; }
                int adx = p->second;
                while (avec[adx].busyBit) { // wait until admin's entry is not busy
                                pthread_cond_wait(&avec[adx].busyCond,&mapLock);
                                p = nameMap->find(aname);
                                if (p == nameMap->end()) {
                                                pthread_cond_signal(&avec[adx].busyCond);
                                                unlockMap(); return 0;
                                }
                }
                avec[adx].busyBit = true; // set busyBit to lock admin table entry
                unlockMap();
                return adx;
}

void AdminTable::releaseAdmin(int adx) {
                lockMap();
                avec[adx].busyBit = false;
                pthread_cond_signal(&avec[adx].busyCond);
                unlockMap();
}

int AdminTable::firstAdmin() {
                lockMap();
                int adx = admins->firstIn();
                if (adx == 0) { unlockMap(); return 0; }
                while (avec[adx].busyBit) {
                                pthread_cond_wait(&avec[adx].busyCond,&mapLock);
                                adx = admins->firstIn(); // first admin may have changed
                                if (adx == 0) {
                                                pthread_cond_signal(&avec[adx].busyCond);
                                                unlockMap(); return 0;
                                }
                }
                avec[adx].busyBit = true;
                unlockMap();
                return adx;
}

int AdminTable::nextAdmin(int adx) {
                lockMap();
                int nuAdx = admins->nextIn(adx);
                if (nuAdx == 0) {
                                avec[adx].busyBit = false;
                                pthread_cond_signal(&avec[adx].busyCond);
                                unlockMap();
                                return 0;
                }
                while (avec[nuAdx].busyBit) {
                                pthread_cond_wait(&avec[nuAdx].busyCond,&mapLock);
                                nuAdx = admins->nextIn(adx);
                                if (nuAdx == 0) {
                                                avec[adx].busyBit = false;
                                                pthread_cond_signal(&avec[adx].busyCond);
                                                pthread_cond_signal(&avec[nuAdx].busyCond);
                                                unlockMap();
                                                return 0;
                                }
                }
                avec[nuAdx].busyBit = true;
                avec[adx].busyBit = false;
                pthread_cond_signal(&avec[adx].busyCond);
                unlockMap();
                return nuAdx;
}

int AdminTable::addAdmin(string& aname, string& pwd, int adx) {
                lockMap();
                map<string,int>::iterator p = nameMap->find(aname);
                if (p != nameMap->end()) { unlockMap(); return 0; }
                if (adx != 0) {
                                if (admins->isIn(adx)) adx = 0;
                } else {
                                adx = admins->firstOut();
                }
                if (adx == 0) { unlockMap(); return 0;}
                nameMap->insert(pair<string,int>(aname,adx));
                admins->swap(adx);
                avec[adx].busyBit = true;
                unlockMap();

                setAdminName(adx,aname); setPassword(adx,pwd);
                setRealName(adx,"noname"); setEmail(adx,"nomail");

                maxAdx = max(adx,maxAdx);
                return adx;
}

void AdminTable::removeAdmin(int adx) {
                lockMap();
                nameMap->erase(avec[adx].aname);
                admins->swap(adx);
                avec[adx].busyBit = false;
                pthread_cond_signal(&avec[adx].busyCond);
                unlockMap();
}

bool AdminTable::readEntry(istream& in, int adx) {
                string aname, pwd, realName, email;

                if (!in.good()) return false;
        if (Misc::verify(in,'+')) {
                        if (!Misc::readName(in, aname)      || !Misc::verify(in,',') ||
                                    !Misc::readWord(in, pwd)        || !Misc::verify(in,',') || 
                                    !Misc::readString(in, realName) || !Misc::verify(in,',') ||
                                    !Misc::readWord(in, email)) {
                                return false;
                                }
                                Misc::cflush(in,'\n');
                } else if (Misc::verify(in,'-')) {
                                maxAdx = max(adx, maxAdx);
                                Misc::cflush(in,'\n'); return true;
                } else {
                                Misc::cflush(in,'\n'); return false;
                }

                if (addAdmin(aname, pwd, adx) == 0) return false;
                setRealName(adx,realName); setEmail(adx,email);
                releaseAdmin(adx);
        return true;
}

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

string& AdminTable::admin2string(int adx, string& s) const {
                string s1;
                s  = getAdminName(adx) + ", " + getPassword(adx) + ", ";
                s += ", \"" + getRealName(adx) + "\", " + getEmail(adx) + "\n";
                return s;
}


string& AdminTable::toString(string& s) {
                string s1; s = "";
                for (int adx = firstAdmin(); adx != 0; adx = nextAdmin(adx))
                s += admin2string(adx,s1);
                return s;
}

void AdminTable::write(ostream& out) {
                string s;
                for (int adx = firstAdmin(); adx != 0; adx = nextAdmin(adx))
                out << admin2string(adx,s);
}

} // ends namespace