FileFinder.cxx

Go to the documentation of this file.

#include <algorithm>
#include <cstdlib>

#include "TSystem.h"

#include "FileFinder.h"

using namespace RootUtil;
using namespace std;

//------------------------------------------------------------------------------------------
FileFinder::FileFinder()
   :fFirstRun(0),
    fLastRun(0),
    fRunNumberPos(0),
    fRunNumberLen(0),
    fRecursiveDepth(1),
    fUseIndex(false),
    fKeys(),
    fNames(),
    fFiles()
{    
}

//------------------------------------------------------------------------------------------
FileFinder::~FileFinder()
{
}

//------------------------------------------------------------------------------------------
void FileFinder::SetKey(const string &value)
{
   if(value.size() < 1)
   {
      cerr << "Key search substring must be non empty" << endl;
      return;
   }

   if(find(fKeys.begin(), fKeys.end(), value) != fKeys.end())
   {
      cout << "Ignoring already existing key: " << value << endl;
   }
   fKeys.push_back(value);
}

//------------------------------------------------------------------------------------------
void FileFinder::SetRunRange(const int first_run, const int last_run)
{
   if(first_run < 1 || first_run < 1 || last_run < first_run)
   {
      cerr << "Bad run numbers range: " << first_run << " - " << last_run << endl;
      return;
   }
   
   fFirstRun = first_run;
   fLastRun  = last_run;
}

//------------------------------------------------------------------------------------------
void FileFinder::SetRunPosition(const int beg_pos, const int length)
{
   if(beg_pos < 0 || length < 0)
   {
      cerr << "Invalid position = " << beg_pos << " or length = " << length << " setting" << endl;
      return;
   }
   
   fRunNumberPos = beg_pos;
   fRunNumberLen = length;
}

//------------------------------------------------------------------------------------------
void FileFinder::SetRecursiveDepth(const short depth)
{
   if(depth < 1 || depth > 100)
   {
      cerr << "Invalid recursive depth setting: " << depth << endl;
      return;
   }
   fRecursiveDepth = depth;  
}

//-------------------------------------------------------------------------------------------
int FileFinder::Search(string path, const short depth)
{
   int nfiles = 0;

   void *dir_ptr = gSystem -> OpenDirectory(path.c_str());
   if(!dir_ptr)
   {
      return 0;
   }

   cout << "Looking into directory: " << path << endl;

   if(path.find_last_of("/") != path.size() - 1)
   {
      path += "/";
   }

   const char *entry = gSystem -> GetDirEntry(dir_ptr);      
   while(entry)
   {
      const string file_name = entry;
      entry = gSystem -> GetDirEntry(dir_ptr);
      
      ++nfiles;

      //if(nfiles > 1000) break;

      if(file_name.size() < 3) continue;

      //iterate over directories
      if(depth < fRecursiveDepth)
      {
         nfiles += Search(path + file_name, depth + 1);
      }

      if(!FindMatch(file_name)) continue;
            
      const int run_number = GetRunNumber(file_name);
      
      if(run_number > 0 && fFirstRun > 0 && fLastRun > fFirstRun)
      {
         if(run_number < fFirstRun || run_number > fLastRun)
         {
            continue;
         }
      }

      const string full_path = path + file_name; 

      FileStat_t stat;
      stat.fSize = 0;
      if(gSystem -> GetPathInfo(full_path.c_str(), stat) != 0 || stat.fSize < 1)
      {
         continue;
      }

      if(!CheckFileName(file_name, full_path))
      {
         continue;
      }

      fFiles.push_back(full_path);
   }

   gSystem -> FreeDirectory(dir_ptr);

   return nfiles;
}

//------------------------------------------------------------------------------------------
void FileFinder::SetIndexFile(const std::string &index_file)
{
   ifstream infile(index_file.c_str());

   if(!infile)
   {
      cerr << "Failed to open file " << index_file << endl;
      return;
   }
   
   fUseIndex = true;

   do
   {
      string tmp;
      infile >> tmp;
      
      if(infile.eof()) break;

      fIndex.push_back(tmp);
   } while(!infile.eof());
}

//-------------------------------------------------------------------------------------------
int FileFinder::GetRunNumber(const string &filename) const
{
   if(fRunNumberLen < 1 || fRunNumberPos + fRunNumberLen > int(filename.size()) - 1)
   {
      return 0;
   }

   return atoi(filename.substr(fRunNumberPos,fRunNumberLen).c_str());
}

//-------------------------------------------------------------------------------------------
bool FileFinder::CheckFileName(const std::string &name, const std::string &path)
{
   if(find(fNames.begin(), fNames.end(), name) != fNames.end())
   {
      cerr << "Error: found duplicate files: " << endl;
      cerr << path << endl;
      
      for(vector<string>::const_iterator it = fFiles.begin(); it != fFiles.end(); ++it)
      {
         if(it -> find(name) != string::npos)
         {
            cerr << *it << endl;
         }
      }
      return false;
   }
   
   fNames.push_back(name);
   return true;
}

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

   return true;
}

//-------------------------------------------------------------------------------------------
string FileFinder::GetFile(const int index) const
{
   if(index < 0 || index >= int(fFiles.size()))
   {
      cerr << "Index is out of range, returning empty string" << endl;
      return string();
   }

   return fFiles[index];
}

//-------------------------------------------------------------------------------------------
double FileFinder::FileSize(int index) const
{
   if(index >= 0)
   {
      const string filepath = GetFile(index);
      FileStat_t stat;
      stat.fSize = 0;
      if(gSystem -> GetPathInfo(filepath.c_str(), stat) == 0 && stat.fSize > 1)
      {
         return double(stat.fSize)/1048576.0;
      }

      return 0.0;
   }
      
   double size = 0.0;
   for(vector<string>::const_iterator it = fFiles.begin(); it != fFiles.end(); ++it)
   {
      FileStat_t stat;
      stat.fSize = 0;
      
      const string &file = *it;

      if(gSystem -> GetPathInfo(file.c_str(), stat) == 0 && stat.fSize > 1)
      {
         size += double(stat.fSize);
      }
   }
   return size/1048576.0;
}

//------------------------------------------------------------------------------------------
void FileFinder::Print() const
{
   cout << "FileFinder: printing config parameters "<< endl;
   
   cout << "Recurisive depth of directory search = " << fRecursiveDepth << endl;

   if(!fUseIndex)
   {
      cout << "Searching for files containing the following substrings " << endl;
      for(vector<string>::const_iterator it = fKeys.begin(); it != fKeys.end(); ++it)
      {
         cout << "Key: " << *it << endl;
      }
   }
   if(fUseIndex)
   {
      cout << "Searching for the following files: " << endl;
      for(vector<string>::const_iterator it = fIndex.begin(); it != fIndex.end(); ++it)
      {
         cout << *it; 
      }
   }
   
   if(fFirstRun > 0 && fLastRun > fFirstRun)
   {
      cout << "File's run number must be in the range " << fFirstRun << " - " << fLastRun << endl;
      cout << "In file name string run number starts at " << fRunNumberPos << " position and extends for "
           << fRunNumberLen << " characters" << endl;
   }
}

---