ComtreeRegister.h

Go to the documentation of this file.

#ifndef CLIENTREGISTER_H
#define CLIENTREGISTER_H

#include <map>
#include "Forest.h"
#include "RateSpec.h"
#include "UiClist.h"
#include "UiSetPair.h"
#include "IdMap.h"

namespace forest {

class ComtreeRegister {
public:
                                ComtreeRegister(int,int);
                                ~ComtreeRegister();
                bool            init();

                bool            validComtree(int) const;

                // iteration methods
                int             firstComtree();
                int             nextComtree(int);

                // access routines for comtree info
                bool            isLocked(int) const;
                int             getComtIndex(comt_t);                           
                void            releaseComtree(int);
                comt_t          getComtree(int);                                
                const string& getOwner(int) const;
                fAdr_t          getSuper(int) const;
                Forest::ConfigMode getConfigMode(int) const;
                Forest::AccessMethod getAccessMethod(int) const;
                int             getRepInterval(int) const;
                time_t          getStartTime(int) const;

                // add/remove/modify table entries
                int             addComtree(comt_t, string&);
                void            removeComtree(int);

                void            setOwner(int, const string&);
                void            setSuper(int, fAdr_t);
                void            setConfigMode(int, Forest::ConfigMode);                         
                void            setAccessMethod(int, Forest::ConfigMode);                       
                void            setRepInterval(int, int);
                void            setStartTime(int, time_t);

                // input/output of table contents 
                bool            readEntry(istream&, int=0);
                bool            read(istream&);
                string&         toString(string&);
                string&         comtree2string(int, string&) const;
                void            write(ostream&);

                // locking/unlocking the internal maps
                // (client name-to-index, client address-to-session)
                void            lockMap();
                void            unlockMap();
private:
                int             maxComt;                        
                int             maxCtx;                                         

                struct Comtree {                                
                comt_t          comtree;                        
                string          owner;                                          
                string          password;                       
                fAdr_t          rootZip;                        
                fAdr_t          supervisor;                     
                Forest::ConfigMode cfgMode;     
                Forest::AccessMethod axsMethod; 
                int             reportInterval;                 
                time_t          start;                                          
                bool            busyBit;                        
                pthread_cond_t busyCond;        
                };

                Comtree *cvec;                                  

                IdMap *comtMap;                                 

                pthread_mutex_t mapLock;        

                uint64_t key(comt_t) const;
                bool            readEntry(istream&);
                int             fileSize();

};

inline bool ComtreeRegister::validComtIndex(int ctx) const {
                return comtMap->validId(ctx);
}

inline int ComtreeRegister::getNumComtrees() const {
                return comtMap->size();
}

inline int ComtreeRegister::getMaxComtrees() const { return maxComt; }

inline int ComtreeRegister::getMaxClx() const { return maxClx; }

inline comt_t ComtreeRegister::getComtree(int ctx) const {
                return cvec[ctx].comtree;
}

inline const string& ComtreeRegister::getOwner(int ctx) const {
                return cvec[ctx].owner;
}

inline const string& ComtreeRegister::getPassword(int ctx) const {
                return cvec[ctx].password;
}

inline fAdr_t ComtreeRegister::getSuper(int ctx) const {
                return cvec[ctx].supervisor;
}

inline Forest::ConfigMode ComtreeRegister::getConfigMode(int ctx) const {
                return cvec[ctx].configMode;
}

inline Forest::AccessMethod ComtreeRegister::getAccessMethod(int ctx) const {
                return cvec[ctx].accessMethod;
}

inline int ComtreeRegister::getRepInterval(int ctx) const {
                return cvec[ctx].repInterval;
}

inline time_t ComtreeRegister::getStartTime(int ctx) const {
                return cvec[ctx].repInterval;
}

inline bool ComtreeRegister::isLocked(int ctx) const {
                return cvec[ctx].busyBit;
}

inline void ComtreeRegister::setOwner(int ctx, const string& owner) const {
                return cvec[ctx].owner = owner;
}

inline void ComtreeRegister::setPassword(int ctx, const string& pwd) const {
                return cvec[ctx].password = pwd;
}

inline void ComtreeRegister::setSuper(int ctx, fAdr_t super) const {
                return cvec[ctx].supervisor = super;
}

inline void ComtreeRegister::setConfigMode(int ctx, Forest::ConfigMode cfg) const {
                return cvec[ctx].configMode = cfg;
}

inline void ComtreeRegister::setConfigMode(int ctx, Forest::AccessMethod axs) {
                return cvec[ctx].accessMethod = axs;
}

inline void ComtreeRegister::setRepInterval(int ctx, int interval) {
                return cvec[ctx].repInterval = interval;
}

inline void ComtreeRegister::setStartTime(int ctx, time_t t) {
                return cvec[ctx].repInterval = t;
}

inline uint64_t ComtreeRegister::key(comt_t comt) const {
        return (uint64_t(comt) << 32) | comt;
}

inline void ComtreeRegister::lockMap() { pthread_mutex_lock(&mapLock); }

inline void ComtreeRegister::unlockMap() { pthread_mutex_unlock(&mapLock); }

} // ends namespace

#endif