HandleCache.h

/*
 *  HandleCache.h
 *  DavisDB
 *
 *  Created by Todd J. Green on 5/20/10.
 *  Copyright 2010 University of California, Davis. All rights reserved.
 *
 */

#ifndef HANDLECACHE_H_
#define HANDLECACHE_H_

#include "Common.h"
#include <assert.h>
#include <map>
#include <string>

template <class M, class H>
class HandleCache {
public:
        HandleCache(M* mgr);
        ~HandleCache();
        ReturnCode openFile(const char* fileName, H** handle);
        ReturnCode closeFile(H* handle);
        bool isOpen(const char* fileName);
        
private:
        M* mgr_;
        std::map<std::string, H*> handles_;     // maps fileName -> handle
        std::map<H*, uint> counts_;                     // maps handle -> # times open
        std::map<H*, std::string> names_;       // maps handle -> fileName
};


template <class M, class H>
HandleCache<M,H>::HandleCache(M* mgr) {
        mgr_ = mgr;
}


template <class M, class H>
HandleCache<M,H>::~HandleCache() {
        assert(handles_.empty() && counts_.empty() && names_.empty());
        mgr_ = 0;
}


template <class M, class H>
ReturnCode HandleCache<M,H>::openFile(const char* fileName, H** handle) {
        typename std::map<std::string, H*>::iterator hit = handles_.find(fileName);
        if (hit == handles_.end()) {
                // cache miss
                ReturnCode code = mgr_->open(fileName, handle);
                if (code == RC_OK) {
                        handles_[fileName] = *handle;
                        counts_[*handle] = 1;
                        names_[*handle] = fileName;
                }
                return code;
        } else {
                // cache hit
                typename std::map<H*, uint>::iterator cit = counts_.find((*hit).second);
                assert(cit != counts_.end());
                assert(names_.find((*hit).second) != names_.end());
                ++((*cit).second);
                *handle = (*hit).second;
                return RC_OK;
        }               
}


template <class M, class H>
ReturnCode HandleCache<M,H>::closeFile(H* handle) {
        typename std::map<H*, uint>::iterator cit = counts_.find(handle);
        assert(cit != counts_.end() && (*cit).second != 0);
        if ((*cit).second == 1) {
                // time to actually close the file
                ReturnCode code = mgr_->close(handle);
                if (code == RC_OK) {
                        counts_.erase(cit);
                        handles_.erase(names_.find(handle)->second);
                        names_.erase(handle);
                }
                return code;
        } else {
                --((*cit).second);
                return RC_OK;
        }               
}


template <class M, class H>
bool HandleCache<M,H>::isOpen(const char* fileName) {
        return handles_.find(fileName) != handles_.end();
}

#endif /* HANDLECACHE_H_ */

---