/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/fcache

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_fcache
#define inlib_fcache

#include <ostream>
#include <map>
#include <string>
#include <cstdio> //::remove

#include "sys/file"

namespace inlib {
namespace file {

class cache {
public:
  virtual ~cache(){}
public:
  virtual bool fetch(const std::string& a_what,std::string& a_file) = 0;
};

class base_cache : public virtual cache {
public:
  virtual bool fetch(const std::string& a_what,std::string& a_file){
    std::map<std::string,std::string>::iterator it = m_cache.find(a_what);
    if(it!=m_cache.end()) { //a_what in the cache.
      if(exists((*it).second)) {
        a_file = (*it).second;
        //std::cout << "inlib::file::base_cache::fetch :"
        //          << " for what " << sout(a_what)
        //          << " file in the cache : " << sout(a_file)
        //          << std::endl;
        return true;
      }
      m_out << "inlib::file::base_cache::fetch :"
            << " WARNING : for " << sout(a_what)
            << ", file in the map no more here. We fetch again the file."
            << std::endl;
      m_cache.erase(it);
    }

    std::string file;
    if(!inlib::tmpname(m_tmp_dir,"inlib_base_cache_",m_tmp_suffix,file)) {
      m_out << "inlib::file::base_cache::fetch :"
            << " can't get a tmpname."
            << std::endl;
      a_file.clear();
      return false;
    }
  
    //std::cout << "inlib::file::base_cache::fetch :"
    //          << " for what " << sout(a_what)
    //          << " fetch ..."
    //          << std::endl;

    if(!fetch_file(a_what,file)) {
      m_out << "inlib::file::base_cache::fetch :"
            << " failed to fetch " << sout(a_what)
            << std::endl;
      ::remove(file.c_str());
      a_file.clear();
      return false;
    }
    m_cache[a_what] = file;
    a_file = file;

    //std::cout << "inlib::file::base_cache::fetch :"
    //          << " for what " << sout(a_what)
    //          << " fetch done."
    //          << std::endl;

    return true;
  }
protected:
  virtual bool fetch_file(const std::string& a_what,const std::string& a_file) = 0;
public:
  base_cache(std::ostream& a_out,bool a_verbose)
  :m_out(a_out)
  ,m_verbose(a_verbose)
  {}
  virtual ~base_cache(){clear();}
protected:
  base_cache(const base_cache& a_from)
  : cache(a_from)
  ,m_out(a_from.m_out)
  ,m_verbose(a_from.m_verbose)
  {}
  base_cache& operator=(const base_cache&){return *this;}
public:
  void set_tmp_dir(const std::string& a_dir) {m_tmp_dir = a_dir;}
  void set_tmp_suffix(const std::string& a_suffix) {
    m_tmp_suffix = a_suffix;
  }
  void clear() {
    std::map<std::string,std::string>::iterator it;
    for(it = m_cache.begin();it!=m_cache.end();++it) {
      ::remove((*it).second.c_str());    
    }
    m_cache.clear();
  }
private:
  //to avoid a #include "file".
  static std::string sout(const std::string& a_string) {
    return std::string("\"")+a_string+"\"";
  }
  static bool exists(const std::string& a_string) {
    FILE* file = ::fopen(a_string.c_str(),"rb");
    if(!file) return false;
    ::fclose(file);
    return true;
  }
protected:
  std::ostream& m_out;
  bool m_verbose;
private:
  std::map<std::string,std::string> m_cache; 
  std::string m_tmp_dir;
  std::string m_tmp_suffix;
};

}}

#endif