RunFinder.cxx

Go to the documentation of this file.

// C
#include <sys/stat.h>

// ROOT
#include "TSystem.h"

// Local
#include "RunFinder.h"

using namespace std;

//------------------------------------------------------------------------------------------
bool Anp::Finder::operator==(const std::string &lhs, const File &rhs)
{
   return (lhs == rhs.name);
}

//------------------------------------------------------------------------------------------
bool Anp::Finder::operator==(const File &lhs, const std::string &rhs)
{
   return (lhs.name == rhs);
}

//------------------------------------------------------------------------------------------
bool Anp::Finder::operator<(const File &lhs, const File &rhs)
{
   return (lhs.name < rhs.name);
}

//------------------------------------------------------------------------------------------
double Anp::Finder::file_size(const std::string &path)
{
   struct stat result;
   if(stat(path.c_str(), &result) != 0)
   {
      return 0.0;
   }
   
   return double(result.st_size)/1038336;
}

//------------------------------------------------------------------------------------------
const std::vector<std::string> Anp::Finder::read_file(const std::string &file)
{
   std::vector<std::string> svec;

   std::ifstream infile(file.c_str());
   if(!infile || !infile.is_open())
   {
      std::cout << "Error! Cannot open file:" << file << std::endl;
      return svec;
   }

   while(infile.good())
   {
      std::string instr;
      std::getline(infile, instr);

      if(instr.size() < 6)
      {
         continue;
      }

      svec.push_back(instr);
   }

   infile.close();

   return svec;
}

//------------------------------------------------------------------------------------------
Anp::RunFinder::RunFinder()
{
}

//------------------------------------------------------------------------------------------
Anp::RunFinder::~RunFinder()
{
}

//-------------------------------------------------------------------------------------------
int Anp::RunFinder::AddDir(const std::string &path, const std::string &key)
{  
   void *dir_ptr = gSystem -> OpenDirectory(path.c_str());
   if(!dir_ptr)
   {
      cout << "RunFinder::AddDir - directory does not exist:" << endl 
           << "   " << path << endl;
      return 0;
   }

   unsigned int count_pass = 0, count_miss = 0;   
   
   const char *entry = gSystem -> GetDirEntry(dir_ptr);
   while(entry)
   {
      const string file = entry;
      entry = gSystem -> GetDirEntry(dir_ptr);

      if(!(file.size() > 1))
      {
         continue;
      }

      const Finder::File newfile = GetFile(path, file);

      if(newfile.name.empty() || newfile.path.empty())
      {
         cerr << "RunFinder::Add() - invalid file: " << file << endl;
         continue;
      }
      
      if(!FindMatch(newfile.name))
      {
         continue;
      }

      if(!key.empty() && newfile.name.find(key, 0) == std::string::npos)
      {
         continue;
      }

      if(!(Finder::file_size(newfile.fullpath()) > 0.0))
      {
         ++count_miss;
      }

      if(std::find(fFiles.begin(), fFiles.end(), newfile.name) == fFiles.end())
      {  
         fFiles.push_back(newfile);
         ++count_pass;
      }
      else
      {
         std::cerr << "RunFinder::AddFileName(): duplicate file " << file << std::endl;
      }
   }
   
   if(count_miss > 0)
   {
      std::cerr << "RunFinder: skipped " << count_miss << " non existing files" << std::endl;
   }

   std::sort(fFiles.begin(), fFiles.end());   

   return count_pass;
}

//-------------------------------------------------------------------------------------------
int Anp::RunFinder::Add(const std::string &path, const std::string &ifile, const std::string &key)
{  
   const std::vector<std::string> ivec = Anp::Finder::read_file(ifile);
   if(ivec.empty())
   {
      std::cerr << "RunFinder::Add() - failed to read index file" << std::endl;
      return 0;
   }

   unsigned int count_pass = 0, count_miss = 0;
   for(std::vector<std::string>::const_iterator sit = ivec.begin(); sit != ivec.end(); ++sit)
   {               
      std::string filename = *sit;

      const Finder::File newfile = GetFile(path, *sit);

      if(newfile.name.empty() || newfile.path.empty())
      {
         std::cerr << "RunFinder::Add() - invalid file: " << *sit << std::endl;
         continue;
      }
      
      if(!FindMatch(newfile.name))
      {
         continue;
      }

      if(!key.empty() && newfile.name.find(key, 0) == std::string::npos)
      {
         continue;
      }

      if(!(Finder::file_size(newfile.fullpath()) > 0.0))
      {
         ++count_miss;
      }

      if(std::find(fFiles.begin(), fFiles.end(), newfile.name) == fFiles.end())
      {  
         fFiles.push_back(newfile);
         ++count_pass;
      }
      else
      {
         std::cerr << "RunFinder::AddFileName(): duplicate file " << filename << std::endl;
      }
   }
   
   if(count_miss > 0)
   {
      std::cerr << "RunFinder: skipped " << count_miss << " non existing files" << std::endl;
   }

   std::sort(fFiles.begin(), fFiles.end());   

   return count_pass;
}

//-------------------------------------------------------------------------------------------
int Anp::RunFinder::AddIndex(const std::string &ifile, const std::string &key)
{  
   const std::vector<std::string> ivec = Anp::Finder::read_file(ifile);
   if(ivec.empty())
   {
      std::cerr << "RunFinder::AddIndex() - failed to read index file" << std::endl;
      return 0;
   }

   unsigned int count_pass = 0, count_miss = 0;
   for(std::vector<std::string>::const_iterator sit = ivec.begin(); sit != ivec.end(); ++sit)
   {               
      std::string filename = *sit;

      const Finder::File newfile("", filename);

      if(newfile.name.empty())
      {
         std::cerr << "RunFinder::Add() - invalid file: " << *sit << std::endl;
         continue;
      }
      
      if(!FindMatch(newfile.name))
      {
         continue;
      }

      if(!key.empty() && newfile.name.find(key, 0) == std::string::npos)
      {
         continue;
      }

      if(std::find(fFiles.begin(), fFiles.end(), newfile.name) == fFiles.end())
      {  
         fFiles.push_back(newfile);
         ++count_pass;
      }
      else
      {
         ++count_miss;
         std::cerr << "RunFinder::AddFileName(): duplicate file " << filename << std::endl;
      }
   }
   
   if(count_miss > 0)
   {
      std::cerr << "RunFinder: skipped " << count_miss << " non existing files" << std::endl;
   }

   std::sort(fFiles.begin(), fFiles.end());   

   return count_pass;
}

//-------------------------------------------------------------------------------------------
void Anp::RunFinder::Compress()
{
   std::vector<unsigned int> svec;

   for(std::vector<std::string>::const_iterator kit = fKeys.begin(); kit != fKeys.end(); ++kit)
   {
      unsigned int count = 0;
      for(std::vector<Anp::Finder::File>::const_iterator fit = fFiles.begin(); fit != fFiles.end(); ++fit)
      {
         if((fit -> name).find(*kit, 0) != std::string::npos)
         {
            ++count;
         }
      }
      
      if(std::find(svec.begin(), svec.end(), count) == svec.end())
      {
         svec.push_back(count);
      }
   }

   if(svec.empty())
   {
      std::cerr << "Anp::RunFinder::Compress() - no files match any keys" << std::endl;
      return;
   }
   else if(svec.size() == 1)
   {
      return;
   }

   std::sort(svec.begin(), svec.end());

   const unsigned int max = svec.back();
   const unsigned int min = svec.front();

   std::sort(svec.begin(), svec.end());

   std::cout << "Anp::RunFinder::Compress()" << std::endl
             << "   Minimum number of matches per key: " << min << std::endl
             << "   Maximum number of matches per key: " << max << std::endl
             << "   Will forces number of matches pre key to be " << max << std::endl;
   
   unsigned int nremoved = 0;
   for(std::vector<std::string>::const_iterator kit = fKeys.begin(); kit != fKeys.end(); ++kit)
   {
      unsigned int count = 0;
      for(std::vector<Anp::Finder::File>::const_iterator fit = fFiles.begin(); fit != fFiles.end(); ++fit)
      {
         if((fit -> name).find(*kit, 0) != std::string::npos)
         {
            ++count;
         }
      }
      
      if(count == max)
      {
         continue;
      }

      ++nremoved;

      std::vector<Anp::Finder::File>::iterator fit = fFiles.begin();
      while(fit != fFiles.end())
      {
         if((fit -> name).find(*kit, 0) != std::string::npos)
         {
            std::cout << "Removed " << fit -> name << std::endl;
            fit = fFiles.erase(fit);
         }
         else
         {
            ++fit;
         }
      }
   }
 
   std::sort(fFiles.begin(), fFiles.end());
  
   std::cout << "Anp::RunFinder::Compress() - removed " << nremoved << " keys" << std::endl;
}

//-------------------------------------------------------------------------------------------
bool Anp::RunFinder::FindMatch(const std::string &filename) const
{
   for(std::vector<std::string>::const_iterator it = fKeys.begin(); it != fKeys.end(); ++it)
   {
      if(filename.find(*it, 0) == std::string::npos)
      {
         return false;
      }
   }

   return true;
}

//-------------------------------------------------------------------------------------------
const Anp::Finder::File Anp::RunFinder::GetFile(std::string path, const std::string &entry) const
{
   if(path.empty() || entry.empty())
   {
      std::cerr << "RunFinder::GetFile() - empty path or filename" << std::endl;
      return Anp::Finder::File(path, entry);
   }

   if(path.find_last_of("/") == path.size() - 1)
   {
      path.erase(path.size() - 1, std::string::npos);
   }

   const std::string::size_type lpos = entry.find_last_of("/", std::string::npos);
   const std::string::size_type fpos = entry.find_first_of("/", 0);

   // entry does not contain "/"
   if(lpos == std::string::npos)
   {
      return Anp::Finder::File(path, entry);
   }
   
   // check that "/" is not first or last
   if(fpos == 0 || lpos == entry.size() - 1)
   {
      std::cerr << "RunFinder::GetFile() - file format error!" << std::endl;
      return Anp::Finder::File(path, entry);
   }   

   // must never happen unless there is error in this code
   if(fpos > lpos)
   {
      std::cerr << "RunFinder::GetFile() - logic error!" << std::endl;
      return Anp::Finder::File(path, entry);
   }
   
   path = path + "/" + entry.substr(0, lpos);

   return Anp::Finder::File(path, entry.substr(lpos + 1, std::string::npos));
}

//-------------------------------------------------------------------------------------------
const std::string Anp::RunFinder::GetFile(const int index) const
{
   if(index >= int(fFiles.size()) || index < 0)
   {
      std::cerr << "RunFinder::GetFile() - index is out of range" << std::endl;
      return std::string();
   }
   
   return fFiles[index].name;
}

//-------------------------------------------------------------------------------------------
const std::string Anp::RunFinder::GetPath(const int index) const
{
   if(index >= int(fFiles.size()) || index < 0)
   {
      std::cerr << "RunFinder::GetFile() - index is out of range" << std::endl;
      return std::string();
   }
   
   return fFiles[index].fullpath();
}

//-------------------------------------------------------------------------------------------
double Anp::RunFinder::GetFileSize(const int index) const
{
   if(index < 0)
   {
      double size = 0.0;
      for(std::vector<Anp::Finder::File>::const_iterator it = fFiles.begin(); it != fFiles.end(); ++it)
      {
         size += Anp::Finder::file_size(it -> fullpath());
      }

      return size;
   }
      
   return Anp::Finder::file_size(GetPath(index));
}

---