d6/da6/FairDbCache_8h_source.html

#ifndef FAIRDBCACHE_H

#define FAIRDBCACHE_H


#include <list>

#include <map>

#include <string>

using std::string;


#include "FairDb.h"


class ValContext;

class FairDbResult;

class FairDbTableProxyRegistry;

class FairDbTableProxy;

class FairDbValidityRec;

//class MsgStream;


class FairDbCache

{


  public:


// Typedefs


    typedef std::list<FairDbResult*> ResultList_t;


// Constructors and destructors.


    FairDbCache(FairDbTableProxy& qp,

                const string& tableName);

    virtual ~FairDbCache();


// State testing member functions

    UInt_t GetMaxSize() const { return fMaxSize; }

    UInt_t GetCurSize() const { return fCurSize; }

    UInt_t GetNumAdopted() const { return fNumAdopted; }

    UInt_t GetNumReused() const { return fNumReused; }

    const FairDbResult* Search(const ValContext& vc,

                               const FairDb::Task& task) const;

    const FairDbResult* Search(const string& sqlQualifiers) const;


    const FairDbResult* Search(const FairDbValidityRec& vr,

                               const string& sqlQualifiers = "") const;

//      MsgStream& ShowStatistics(MsgStream& msg) const;


// State changing member functions

    void Adopt(FairDbResult* res,bool registerKey = true);

    void Purge();

    void SetStale();


  protected:


  private:


    FairDbCache(const FairDbCache&);

    FairDbCache& operator=(const FairDbCache&);


    const ResultList_t* GetSubCache(Int_t aggNo) const;

    void Purge(ResultList_t& subCache, const FairDbResult* res=0);


    FairDbTableProxy&  fTableProxy;


    const string& fTableName;

    std::map<Int_t,ResultList_t> fCache;

    mutable UInt_t fCurSize;

    mutable UInt_t fMaxSize;

    mutable UInt_t fNumAdopted;

    mutable UInt_t fNumReused;


    ClassDef(FairDbCache,0)  //Query result cache for specific database table.


};


#endif  // FAIRDBCACHE_H