STEER/TFndFileManager.cxx

// @(#)fROOT/STEER:$Name:  $:$Id: TFndFileManager.cxx,v 1.3 2007/09/05 11:09:42 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24

//                TFndFileManager                      //
//                                                     //
// Both ROOT and ASCII files can be handled by         //
// this class:                                         //
//           - file existence check                    //
//           - ascii characters search and replace     //
//           - etc...                                  //
//                                                     //

#include <Riostream.h>
#include "TROOT.h"
#include "TSystem.h"
#include "TString.h"
#include "TFile.h"
#include "TObjArray.h"

#include "TFndFileManager.h"

ClassImp(TFndFileManager) 

//__________________________________________________________
TFndFileManager::TFndFileManager()
  :TNamed("",""),fdebug(),fReady(),fAsciiLoaded(),fRootLoaded(),fOriginalPath(),fPath(),fFileName(),fAsciiFile(),fRootFile() {
  
  fFileName = new TString("");
}

//_________________________________________________________
TFndFileManager::TFndFileManager(const char *path, Bool_t debug)
  :TNamed("",""),fdebug(debug),fReady(),fAsciiLoaded(),fRootLoaded(),fOriginalPath(),fPath(),fFileName(),fAsciiFile(),fRootFile(){ 
  
  fFileName = new TString("");
  // remove $ from enviroment variable
  if (path && *path == '$')
    path = gSystem->Getenv(path + 1);
  fPath = new TString(path); 
  fOriginalPath = fPath->Data();
  if(fdebug) cout << "TFndFileManager debug (constr): path is: \"" << fPath->Data() << "\""<< endl;
}

//___________________________________
TFndFileManager::~TFndFileManager()
{
  //
}

//___________________________________
//_________________________________________________________________________

Int_t TFndFileManager::Ascii(Char_t *filename, Char_t *option){
  BuildFileName(filename);
  if(!CheckExistence())return 0;
  if(fdebug) cout << "TFndFileManager debug: accessing to the ascii file in \"" << option << "\" mode." << endl;
  fAsciiFile = fopen(fFileName->Data(),option);
  fAsciiLoaded = kTRUE;
  return 1;
}
//___________________________________
Int_t TFndFileManager::Root(Char_t *filename, Char_t *option){
  BuildFileName(filename);
  if(!CheckExistence())return 0;
  if(fdebug) cout << "TFndFileManager debug: accessing to the root file in \"" << option << "\" mode." << endl;
  fRootFile = new TFile(fFileName->Data(),option);
  if(fdebug) gROOT->ProcessLine(".ls");
  fRootLoaded = kTRUE;
  return 1;
}

//___________________________________
void TFndFileManager::AppendToPath(Char_t *path){
  if(fdebug) cout << "fPath 1: " << fPath->Data() << endl;
  *fPath+="/";
  if(fdebug) cout << "fPath 2: " << fPath->Data() << endl;
  *fPath+=path;
  if(fdebug) cout << "fPath 3: " << fPath->Data() << endl;
}
//___________________________________
Char_t *TFndFileManager::GetFileName() {
  if(!fReady) cout << "filename not complete!" << endl;
  return (Char_t *)fFileName->Data();
}

//___________________________________
void TFndFileManager::ReadAscii(){
  rewind(fAsciiFile);
  char fgets_out[200][200];
  cout << "fgets output: " << fgets(fgets_out[0],200,fAsciiFile) << endl;
  cout << "fgets output: " << fgets(fgets_out[1],200,fAsciiFile) << endl;
  cout << "fgets output: " << fgets(fgets_out[2],200,fAsciiFile) << endl;
  rewind(fAsciiFile);
}

//___________________________________
void TFndFileManager::ReplaceChar(Char_t *ori_char,Char_t *new_char){
  if(!fAsciiLoaded){
    cout << "Ascii file not loaded!" << endl;
    return;  
  }
  if(strlen(ori_char)>1 || strlen(new_char)>1){
    cout << "One character only!!!" << endl;
    return;
  }
  Int_t count = 0;
  Int_t *ori_num = (Int_t *) ori_char;
  Int_t *new_num = (Int_t *) new_char;
  freopen(fFileName->Data(),"r+",fAsciiFile); 

  if(fdebug) cout << "changing \"" << ori_char << "\"( " << *ori_num << " ) to \"" << new_char << "\"( " << *new_num << ")." << endl;
  
  if(fdebug) cout << "resetting position." << endl;
  rewind(fAsciiFile);
  if(fdebug) cout << "current stream pos.: " << ftell(fAsciiFile) << endl;
  Int_t current = 0;
  while(1){
    current = fgetc(fAsciiFile);
    if(current==-1) break; // stop at end of file
    
    if(fdebug) cout << "fgetc output: " << (Char_t) current << " (" << current << ")" << endl; 
    if(current==*ori_num)
      {
        count++;
        if(fdebug) cout << "replacing " << ori_char << " at position: " << ftell(fAsciiFile) << endl;
        fseek(fAsciiFile,-1,SEEK_CUR); // move back the streaming
        fputs(new_char,fAsciiFile);     
      }
  }
  cout << "Replaced " << count << " occurences." << endl;
  freopen(fFileName->Data(),"r",fAsciiFile); 
  rewind(fAsciiFile);
}

//___________________________________
const Int_t TFndFileManager::GetNumOfColumns(Char_t *delimiter){
  rewind(fAsciiFile);

  Int_t check = 0;
  Int_t count_col = 0;
  for(Int_t line=0;line<10;line++){ // check the first ten lines
    Char_t *cur_str = "";     // get the line from the file 
    cur_str = GetNextLine(); // get the line from the file 
    if(!cur_str) break;
    
    TString cur_char;
    Int_t i = 0;
    if(strlen(cur_str)==0) count_col = 0;
    else count_col = 1;
    while(i<(Int_t)strlen(cur_str)){
      cur_char = TString(*(cur_str+i));
      if(fdebug) cout << "cur_char: " << cur_char.Data() << endl;
      if(!strcmp(cur_char.Data(),delimiter)){
        if(fdebug) cout << "delimiter found at position " << i << endl;
        count_col++;
      }
      i++;
    }
    if(line==0) check = count_col;
    else{
      if(check!=count_col){
        cout << "Number of columns not constant! (first ten lines)" << endl;
        check = count_col;}
      else if(fdebug) cout << "Number of columns constant." << endl;
    }
  }
  return count_col;

}

//___________________________________
Char_t *TFndFileManager::GetNextLine(){
  Char_t line_content[1][7000];
  Char_t *out = ""; 
  out = fgets(line_content[0],7000,fAsciiFile);
  if(!out){
    cout << "End of file reached." << endl;
    return 0;
  }
  out[strlen(out)-1]='\0';
  if(fdebug) cout << "Line content: " << out << endl; 
  return out; 
}

//___________________________________
Char_t *TFndFileManager::GetLine(Int_t n){
  Char_t line_content[1][7000];
  Char_t *out = ""; 
  rewind(fAsciiFile);

  for(Int_t l=0;l<n;l++){
    out = fgets(line_content[0],7000,fAsciiFile);
    if(!out){
      cout << "Line out of file range!" << endl;
      return 0;
    }
  }
  return out; 
}

//___________________________________
Int_t TFndFileManager::GetNextLine(Float_t *array,Int_t nvar,Char_t *delimiter){
  // retuns -1 if end of file
  Char_t *cur_str = ""; // get the line from the file 
  cur_str = GetNextLine(); // get the line from the file 
  if(!cur_str) return -1;
  //  Char_t cur_char[2];
  //  Char_t *cur_char = "";
  Int_t i = 0;
  Int_t var_ID = 0;
  TString cur_char;
  TString cur_word = TString("");
  while(i<(Int_t)strlen(cur_str)){
    cur_char = TString(*(cur_str+i));
    if(fdebug) cout << "cur_char: " << cur_char.Data() << endl;
    if(!strcmp(cur_char.Data(),delimiter)){
      if(fdebug) cout << "delimiter found at position " << i << endl;
      Float_t var = ::atof(cur_word.Data());
      if(fdebug) cout << "atof: " << var << endl;
      if(var_ID<nvar){
        array[var_ID] = var;
        var_ID++;
      }
      cur_word.Resize(0);
    }
    else{
      cur_word+=cur_char;
      if(fdebug) cout << "cur_word: " << cur_word.Data() << endl;
    }
    i++;
  }
  if(fdebug) cout << "end of line found." << endl;
  Float_t var = ::atof(cur_word.Data());
  if(fdebug) cout << "atof: " << var << endl;
  if(var_ID<nvar){
    array[var_ID] = var;
    var_ID++;
  }
  return 0;
}

//___________________________________
void TFndFileManager::Close(){
  if(!fAsciiFile && !fRootFile){
    cout << "TFndFileManager message: No file to be closed." << endl;
    return;
  }
  if(fAsciiFile){
    cout << "Closing ASCII file" << endl;
    fclose(fAsciiFile);
  }
  if(fRootFile){
    cout << "Closing ROOT file" << endl;
    fRootFile->Close();
  }
}


//___________________________________
//___________________________________
void TFndFileManager::Print(Option_t *)const{

  cout << "   __________________________________________________" << endl;
  cout << "  |               TFndFileManager::Print()            |" << endl;
  cout << "  | debug is:=======> " << fdebug << endl;
  cout << "  | path is:========> " << fPath->Data() << endl;
  if(fFileName) cout << "  | filename is:====> " << fFileName->Data() << endl;
}
//___________________________________
void TFndFileManager::HowTo(){
  cout << "   ________________________________________________________________" << endl;
  cout << "  |               TFndFileManager::HowTo()                          |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |  This class is designed for the ACII and the ROOT files        |" << endl;
  cout << "  |  management.                                                   |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |  Usage:                                                        |" << endl;
  cout << "  |   - Constructor:                                               |" << endl;
  cout << "  |     TFndFileManager(Char_t *path,Bool_t debug=kFALSE)           |" << endl;
  cout << "  |       It requires a \'path\'                                     |" << endl;
  cout << "  |       The path can be passed as:                               |" << endl;
  cout << "  |             a) enviroment variable (with \"$\")                  |" << endl;
  cout << "  |             a) standard path (for instance \"/data/test\")       |" << endl;
  cout << "  |       NOTE: don't use a \"mixed\" path ($DATA/test)!             |" << endl;
  cout << "  |       You can specify the debug flag value (default:false).    |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |    - AppendToPath(Char_t *path)                                |" << endl;
  cout << "  |       Use this method if you want to add a sub-path to the     |" << endl;
  cout << "  |       path that you have set in the constructor.               |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |       IMPORTANT NOTE:                                          |" << endl;
  cout << "  |          Remember not to use the \"/\" in the end of the path    |" << endl;
  cout << "  |                                                                |" << endl;  
  cout << "  |    - Ascii(Char_t *filename, Char_t *option=\"r\")               |" << endl;
  cout << "  |        to access to an ACII file;                              |" << endl;
  cout << "  |        available options are:                                  |" << endl;
  cout << "  |        r  => Open text file for reading.  The stream is        |" << endl;
  cout << "  |              positioned at the beginning of the file.          |" << endl;
  cout << "  |        r+ => Open for reading and writing.  The stream is      |" << endl;
  cout << "  |              positioned at the beginning of the file.          |" << endl;
  cout << "  |        w  => Truncate  file  to  zero length or create         |" << endl;
  cout << "  |              text file for writing.  The stream is             |" << endl;
  cout << "  |              positioned at the beginning of the file.          |" << endl;
  cout << "  |        w+ => Open for reading and writing. The file is created |" << endl;
  cout << "  |              if it does not exist, otherwise it is truncated.  |" << endl;
  cout << "  |              Stream  at the beginning of the file.             |" << endl;
  cout << "  |        a  => Open for appending (writing at end of file).      |" << endl;  
  cout << "  |              The file is created if it does not exist.         |" << endl;  
  cout << "  |              Stream  at the end of the file.                   |" << endl;  
  cout << "  |        a+ => Open for reading and appending                    |" << endl;  
  cout << "  |              (writing at end of file)                          |" << endl;  
  cout << "  |              The file is created if it does not exist.         |" << endl;  
  cout << "  |              Stream  at the end of the file.                   |" << endl;  
  cout << "  |                                                                |" << endl;
  cout << "  |    - Root(Char_t *filename, Char_t *option=\"OPEN\")             |" << endl;
  cout << "  |       to access to a root file in the standard root way        |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |    - GetRootFile()                                             |" << endl;
  cout << "  |       returns a pointer to TFile                               |" << endl;
  cout << "  |       (if already opened with Root(...) method                 |" << endl;
  cout << "  |                                                                |" << endl;
  cout << "  |    - GetAsciiFile()                                            |" << endl;
  cout << "  |       returns a pointer to FILE                                |" << endl;
  cout << "  |       (if already opened with Ascii(...) method                 |" << endl;
  cout << "  |                                                                |" << endl;

  cout << "  |                                                                |" << endl;
  cout << "  |________________________________________________________________|" << endl;
}
//____________________
//_____ private ______
//____________________
void TFndFileManager::BuildFileName(Char_t *filename){
  fFileName = new TString(fPath->Data());
  *fFileName+="/";
  *fFileName+=filename;
  SetName(filename);
  SetTitle(filename);
  fReady = kTRUE;
}
//___________________________________
Bool_t TFndFileManager::CheckExistence() 
{ // kTRUE if the file exists
  if(fdebug) cout << "TFndFileManager debug: Checking existence." << endl;
  if(gSystem->AccessPathName(fFileName->Data())){
    cout << "file \"" << fFileName->Data() << "\" not found!" << endl; 
    return kFALSE;
  }
  else 
    {
      if(fdebug) cout << "TFndFileManager debug: file \"" << fFileName->Data() << "\" found." << endl;
      return kTRUE;
    }
}

---