genie::Cache Class Reference

GENIE Cache Memory. More...

#include <Cache.h>

Classes
struct	Cleaner
	proper de-allocation of the singleton object More...

Public Member Functions
void	OpenCacheFile (string filename)
	cache file More...
CacheBranchI *	FindCacheBranch (string key)
	finding/adding cache branches More...
void	AddCacheBranch (string key, CacheBranchI *branch)
string	CacheBranchKey (string k0, string k1="", string k2="") const
void	RmCacheBranch (string key)
	removing cache branches More...
void	RmAllCacheBranches (void)
void	RmMatchedCacheBranches (string key_substring)
void	Print (ostream &stream) const
	print cache buffers More...

Static Public Member Functions
static Cache *	Instance (void)

Private Member Functions
void	Load (void)
	load/save More...
void	Save (void)
	Cache ()
	singleton class: constructors are private More...
	Cache (const Cache &cache)
virtual	~Cache ()

Private Attributes
map< string, CacheBranchI * > *	fCacheMap
	map of cache buffers & cache file More...
TFile *	fCacheFile

Static Private Attributes
static Cache *	fInstance = 0
	singleton instance More...

Friends
struct	Cleaner
ostream &	operator<< (ostream &stream, const Cache &cache)

Detailed Description

GENIE Cache Memory.

Author

Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

November 26, 2004

Copyright (c) 2003-2020, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 38 of file Cache.h.

Constructor & Destructor Documentation

genie::Cache::Cache ( )

private

singleton class: constructors are private

Definition at line 37 of file Cache.cxx.

{
  fInstance  = 0;
  fCacheMap  = 0;
  fCacheFile = 0;
}

genie::Cache::Cache ( const Cache &  cache )

private

genie::Cache::~Cache ( )

privatevirtual

Definition at line 44 of file Cache.cxx.

{
  this->Save();

  if(fCacheMap) {
    map<string, CacheBranchI * >::iterator citer;
    for(citer = fCacheMap->begin(); citer != fCacheMap->end(); ++citer) {
      CacheBranchI * branch = citer->second;
      if(branch) {
        delete branch;
        branch = 0;
      }
    }
    fCacheMap->clear();
    delete fCacheMap;
  }
  if(fCacheFile) {
    fCacheFile->Close();
    delete fCacheFile;
  }
  fInstance = 0;
}

Member Function Documentation

void genie::Cache::AddCacheBranch	(	string	key,
		CacheBranchI *	branch
	)

Definition at line 88 of file Cache.cxx.

{
  fCacheMap->insert( map<string, CacheBranchI *>::value_type(key,branch) );
}

string genie::Cache::CacheBranchKey	(	string	k0,
		string	k1 = "",
		string	k2 = ""
	)		const

Definition at line 93 of file Cache.cxx.

{
  ostringstream key;

  key << k0;
  if(k1.size()>0) key << "/" << k1;
  if(k2.size()>0) key << "/" << k2;

  return key.str();
}

CacheBranchI * genie::Cache::FindCacheBranch

(

string

key

)

finding/adding cache branches

Definition at line 80 of file Cache.cxx.

{
  map<string, CacheBranchI *>::const_iterator map_iter = fCacheMap->find(key);

  if (map_iter == fCacheMap->end()) return 0;
  return map_iter->second;
}

Cache * genie::Cache::Instance ( void  )

static

Definition at line 67 of file Cache.cxx.

{
  if(fInstance == 0) {
    static Cache::Cleaner cleaner;
    cleaner.DummyMethodAndSilentCompiler();

    fInstance = new Cache;

    fInstance->fCacheMap = new map<string, CacheBranchI * >;
  }
  return fInstance;
}

void genie::Cache::Load ( void  )

private

load/save

Definition at line 133 of file Cache.cxx.

{
  LOG("Cache", pNOTICE) << "Loading cache";

  if(!fCacheFile) return;
  TList * keys = (TList*) fCacheFile->Get("key_list");
  TIter kiter(keys);
  TObjString * keyobj = 0;
  int ib=0;
  while ((keyobj = (TObjString *)kiter.Next())) {
    string key = string(keyobj->GetString().Data());
    ostringstream bname;
    bname << "buffer_" << ib++;
    CacheBranchI * buffer = (CacheBranchI*) fCacheFile->Get(bname.str().c_str());
    if(buffer) {
     fCacheMap->insert( map<string, CacheBranchI *>::value_type(key,buffer) );
    }
  }
  LOG("Cache", pNOTICE) << "Cache loaded...";
  LOG("Cache", pNOTICE) << *this;
}

void genie::Cache::OpenCacheFile

(

string

filename

)

cache file

Definition at line 183 of file Cache.cxx.

{
  if(filename.size() == 0) return;

  if(fCacheFile) {
    if(fCacheFile->IsOpen()) {
       delete fCacheFile;
       fCacheFile = 0;
    }
  }

  LOG("Cache", pNOTICE) << "Using cache file: " << filename;

  fCacheFile = new TFile(filename.c_str(),"update");
  if(!fCacheFile->IsOpen()) {
     delete fCacheFile;
     fCacheFile = 0;
     LOG("Cache", pWARN) << "Could not open cache file: " << filename;
  }

  this->Load();
}

void genie::Cache::Print

(

ostream &

stream

)

const

print cache buffers

Definition at line 206 of file Cache.cxx.

{
  stream << "\n [-] GENIE Cache Buffers:";
  stream << "\n  |";
  map<string, CacheBranchI * >::iterator citer;
  for(citer = fCacheMap->begin(); citer != fCacheMap->end(); ++citer) {
    string key = citer->first;
    CacheBranchI * branch = citer->second;
    stream << "\n  |--o  " << key;
    if(!branch) {
      stream << " *** NULL *** ";
    }
  }
  stream << "\n";
}

void genie::Cache::RmAllCacheBranches

(

void

)

Definition at line 110 of file Cache.cxx.

{
  LOG("Cache", pNOTICE) << "Removing cache branches";

  if(fCacheMap) {
    map<string, CacheBranchI * >::iterator citer;
    for(citer = fCacheMap->begin(); citer != fCacheMap->end(); ++citer) {
      CacheBranchI * branch = citer->second;
      if(branch) {
        delete branch;
        branch = 0;
      }
    }
    fCacheMap->clear();
  }
}

void genie::Cache::RmCacheBranch

(

string

key

)

removing cache branches

Definition at line 104 of file Cache.cxx.

{
  LOG("Cache", pNOTICE) << "Removing cache branch: " << key;

}

void genie::Cache::RmMatchedCacheBranches

(

string

key_substring

)

Definition at line 127 of file Cache.cxx.

{
  LOG("Cache", pNOTICE) << "Removing cache branches: *"<< key_substring<< "*";

}

void genie::Cache::Save ( void  )

private

Definition at line 155 of file Cache.cxx.

{
  if(!fCacheFile) {
    return;
  }
  fCacheFile->cd();

  int ib=0;
  TList * keys = new TList;
  keys->SetOwner(true);

  map<string, CacheBranchI * >::iterator citer;
  for(citer = fCacheMap->begin(); citer != fCacheMap->end(); ++citer) {
    string key = citer->first;
    CacheBranchI * branch = citer->second;
    if(branch) {
      ostringstream bname;
      bname << "buffer_" << ib++;
      keys->Add(new TObjString(key.c_str()));
      branch->Write(bname.str().c_str(), TObject::kOverwrite);
    }
  }
  keys->Write("key_list", TObject::kSingleKey | TObject::kOverwrite );

  keys->Clear();
  delete keys;
}

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 89 of file Cache.h.

ostream& operator<< ( ostream &  stream, const Cache &  cache  )

friend

Definition at line 29 of file Cache.cxx.

{
  cache.Print(stream);
  return stream;
}

Member Data Documentation

TFile* genie::Cache::fCacheFile

private

Definition at line 72 of file Cache.h.

map<string, CacheBranchI * >* genie::Cache::fCacheMap

private

map of cache buffers & cache file

Definition at line 71 of file Cache.h.

Cache * genie::Cache::fInstance = 0

staticprivate

singleton instance

Definition at line 68 of file Cache.h.

---

The documentation for this class was generated from the following files:

• Generator/src/Framework/Utils/Cache.h
• Generator/src/Framework/Utils/Cache.cxx