IoFileListItem.cxx

Go to the documentation of this file.

//
// IoFileListItem
//
// Package: Io (IoModules).
//
// S. Kasahara 02/2003
//
// Purpose: Helper class to associate a file path, including possibly
//          wildcards, with an associated file list and stream list.
//

#include <algorithm>
#include <iostream>
#include <vector>

#include "TFile.h"
#include "TROOT.h"
#include "TKey.h"
#include "TClass.h"
#include "TRegexp.h"
#include "TSystem.h"

#include "IoModules/IoFileListItem.h"
#include "Persistency/PerFileManager.h"
#include "Persistency/PerFile.h"
#include "Util/UtilString.h"

std::ostream& operator << ( std::ostream& os, const IoFileListItem& ifl ) 
                                              { return ifl.Print(os); }

// Definition of methods (alphabetical order)
// ******************************************

std::string IoFileListItem::BuildDefStreamList(std::string filename) {
//
// Purpose:  Open the specified file and determine the default list of
//           streams for that file.
//
// Contact:  S. Kasahara
//

  std::string defstreamlist;
  
  const PerFile* perFile
    = PerFileManager::Instance().OpenFile(filename,Per::kRead);
  if ( !perFile ) return defstreamlist; // file open failed

  TFile* tfile = perFile -> GetTFile();
  // use file keys to determine names of existing trees in input file
  tfile -> ReadKeys();
  TKey* key;
  TIter nextkey(tfile->GetListOfKeys());
  while ((key = (TKey*)nextkey())) {
    TClass* tclass = gROOT -> GetClass(key->GetClassName());
    if ( tclass -> InheritsFrom("TTree") ) {
      // Can be TTree or any of its derived classes
      std::string newstream = key -> GetName();
      if ( defstreamlist.empty() ) defstreamlist = newstream;
      else defstreamlist += "," + newstream;
    }
  }
  PerFileManager::Instance().CloseFile(filename);
  
  return defstreamlist;

}

std::list<std::string> IoFileListItem::BuildFileIndex (std::string filepath) {
//
//  Purpose:  Build file index from input filepath. The filename portion of 
//            the path may include wildcard(s), e.g.
//            /mypath/myfile*.root, or
//            ~kasahara/mypath/*p*.root
//            The directory path may include standard shell characters, 
//            e.g. $,.,~  The input filepath will be used to build a list of 
//            fullfilepathnames to be returned to user.
//
//  Contact: S. Kasahara
//
//  Notes: This code is adapted from ROOT's TChain::Add method, but
//         augmented to allow wildcards in the directory path.
//

  std::list<std::string> fileList;

  if ( strchr(filepath.c_str(),'*') == 0 ) {
    // No wildcard, just push filepath as is
    fileList.push_back(filepath);  
    return fileList;
  }

  // wildcard present
  // Break full directory path up into a set of short strings delimited by "/"
  std::vector<std::string> itemizedpath;
  UtilString::StringTok(itemizedpath,filepath,"/");
  
  // if wildcard present in directory path, there may be multiple directories
  // to search. dirlist is list of directories to search.
  std::vector<std::string> dirlist;
  std::string filename;
  
  if ( itemizedpath.size() <= 1 ) {
    // If no '/' specified in input filepath, use working directory.
    if ( filepath.find("/") == 0 ) dirlist.push_back("/");
    else dirlist.push_back(gSystem->WorkingDirectory());
    filename = filepath;
  }
  else {
    // filename is last of segments
    filename=itemizedpath[itemizedpath.size()-1]; 

    // Seed directory list
    if ( filepath.find("/") == 0 ) 
      BuildDirIndex("/",itemizedpath[0],dirlist);
    else if ( strchr(itemizedpath[0].c_str(),'*') != 0 ) {
      // wildcard, but no initial "/". Assume working directory
      BuildDirIndex("./",itemizedpath[0],dirlist);
    }
    else {
      dirlist.push_back(gSystem->ExpandPathName(itemizedpath[0].c_str()));
    }
    

    for ( unsigned int is = 1; is < itemizedpath.size()-1; is++ ) {
      std::vector<std::string> subdirlist;
      for (unsigned int idir = 0; idir != dirlist.size(); idir++) {
        std::string dirpath = dirlist[idir];
        BuildDirIndex(dirpath,itemizedpath[is],subdirlist);
      }
      dirlist.clear();
      for ( unsigned int isub = 0; isub != subdirlist.size(); isub++) {
        dirlist.push_back(subdirlist[isub]);
      }
    }
  }
  
  // List of directory paths is now final, loop to test filename
  for ( unsigned int idir = 0; idir < dirlist.size(); idir++ ) {
    if ( strchr(filename.c_str(),'*') == 0 ) {
      // No wildcard in filename, test existence in this directory
      std::string fullfilepath = dirlist[idir]+"/"+filename;
      // accesspathname returns false if it was able to access file, bizarre
      Bool_t isFail = gSystem->AccessPathName(fullfilepath.c_str());
      if ( !isFail ) fileList.push_back(fullfilepath);
    }
    else {
      void *dir = gSystem->OpenDirectory(dirlist[idir].c_str());
      if ( dir ) {
        TRegexp re(filename.c_str(),kTRUE); // kTRUE indicates wildcard present
        const char* dirfile;
        while ((dirfile = gSystem->GetDirEntry(dir))) {
          if ( !strcmp(dirfile,".") || !strcmp(dirfile,"..") ) continue;
          if (   !strcmp(filename.c_str(),dirfile) 
              || TString(dirfile).Index(re)!=kNPOS) {
            // filename or regular expression matches dirfile 
            std::string fullfilepathname = dirlist[idir] + "/"
                                         + std::string(dirfile);
            fileList.push_back(fullfilepathname);
          }
        }
        gSystem->FreeDirectory(dir);
      }
    }
  }

  return fileList;

}

void IoFileListItem::BuildDirIndex(std::string dirpath,std::string subdir,
                                 std::vector<std::string>& subdirlist) const {
  // Search for directories matching character string subdir in directory
  // dirpath.  subdir may include wildcards.  Matching subdirs are
  // pushed to subdirlist.
  
  std::string separator = "/";
  if ( dirpath.find("/") == dirpath.size()-1 ) separator = "";

  if ( strchr(subdir.c_str(),'*') == 0 ) {
    // No wildcard in subdirectory.
    subdirlist.push_back(dirpath+separator+subdir);
    return;
  }

  void *dir = gSystem->OpenDirectory(dirpath.c_str());
  if ( !dir ) return;
  
  // kTRUE indicates wildcard present
  TRegexp re(subdir.c_str(),kTRUE); 
  const char* dirfile;
  while ((dirfile = gSystem->GetDirEntry(dir))) {
    if ( !strcmp(dirfile,".") || !strcmp(dirfile,"..") ) continue;
    if (!strcmp(subdir.c_str(),dirfile) 
        || TString(dirfile).Index(re)!=kNPOS) {
      // filename matches subdir
      std::string fulltestpath = dirpath + separator + std::string(dirfile);
      
      // check to see that it's a directory
      FileStat_t filestatbuf;
      int isFailed 
           = gSystem->GetPathInfo(fulltestpath.c_str(),filestatbuf);
      if ( !isFailed ) {
        if ( R_ISDIR(filestatbuf.fMode) ) 
          subdirlist.push_back(fulltestpath.c_str());
      }  
    }
  }

  gSystem->FreeDirectory(dir);

  return;

}


IoFileListItem::IoFileListItem(const char* filepath, int at,
                           const char* streams): fFilePath(filepath),fAt(at) {
  //
  //  Purpose:  Constructor 
  //
  //  Arguments: filepath      May include wildcards
  //             at            Index position to which this file list should
  //                           be added for each stream
  //             streams       Delimiter separated list of streams (if "*", =>
  //                           will open file and use default list of trees)
  //
  //  Contact:   S. Kasahara
  //

  std::list<std::string> filelist = this->BuildFileIndex(filepath);
  std::list<std::string>::iterator fileitr;

  std::string streamlist;
  std::string s(streams);

  for ( fileitr = filelist.begin(); fileitr != filelist.end(); fileitr++ ) {
    std::string filename = *fileitr;
    if ( s == "*" ) streamlist = BuildDefStreamList(filename);
    else streamlist = s;

    fFileStreamMap[filename] = streamlist;
  }

}

IoFileListItem::~IoFileListItem() {
  //
  //  Purpose:  Destructor
  //
  //  Contact:   S. Kasahara
  //

}


std::ostream& IoFileListItem::Print(std::ostream& os) const {
  //
  //  Purpose:  Print status of file/stream associations on ostream.
  //
  //  Contact:   S. Kasahara
  //

  FileStreamMapConstItr itr = fFileStreamMap.begin();
  for ( ; itr != fFileStreamMap.end(); itr++ ) {
    os << itr->first << "\t" << itr->second << endl;
  }

  return os;

}


void IoFileListItem::RemoveFile(const char* filename, const char* streams) {
  //
  //  Purpose:  Remove specified stream(s) from specified file.
  //            If streams = "*", remove file from list.
  //            If filename = "*", apply to all files.
  //
  //  Contact:   S. Kasahara
  //

  std::string f(filename);
  std::string s(streams);

  FileStreamMapItr fileItr = fFileStreamMap.end();
  while ( !fFileStreamMap.empty() && fileItr != fFileStreamMap.begin() ) {
    fileItr--;
    if ( f == "*" || f == (fileItr->first) ) { 
      if ( s == "*" ) {
        fFileStreamMap.erase(fileItr);  // remove file from map
      }
      else {
        std::vector<std::string> vrm;
        std::vector<std::string>::iterator vrmitr;
        UtilString::StringTok(vrm,streams,":,;/ ");

        std::string oldstreams = fileItr->second;
        std::vector<std::string> vold;
        UtilString::StringTok(vold,oldstreams,":,;/ ");
        std::vector<std::string>::iterator volditr = vold.end();
        
        while ( volditr !=  vold.begin() ) {
          volditr--;
          vrmitr = std::find(vrm.begin(),vrm.end(),*volditr);
          if ( vrmitr != vrm.end() ) vold.erase(volditr);      
        }
        if ( vold.empty() ) fFileStreamMap.erase(fileItr);
        else {
          std::string revisedstreams;
          for ( volditr = vold.begin(); volditr != vold.end(); volditr++ ) {
            if ( revisedstreams.empty() ) revisedstreams = *volditr;
            else revisedstreams += "," + *volditr;
          }
          fileItr->second = revisedstreams;
        }
      }
    }
  }
  return;

}

---