PerFileManager.cxx

Go to the documentation of this file.

//
// PerFileManager
//
// Package: Per (Persistency).
//
// S. Kasahara 11/00
//
// Purpose: Utility singleton file manager used by persistency package to open
//          and close files. 
//
// Based in part on the ideas of the BaBar Kanga(roo) RooFileManager class

#include <string>
#include "TEnv.h"

#include "Persistency/PerFileManager.h"
#include "Persistency/PerFile.h"
#include "MessageService/MsgService.h"

std::ostream& operator<<(std::ostream& ms, const PerFileManager& fm) 
{
  return fm.Print(ms);
}

ClassImp(PerFileManager)

//   Definition of static data members
//   *********************************

CVSID("$Id: PerFileManager.cxx,v 1.12 2005/09/25 19:25:52 schubert Exp $");

PerFileManager* PerFileManager::fgInstance = 0;


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


const PerFile* PerFileManager::ChangeFile(std::string oldfilepathname, 
                               std::string newfilepathname,TFile* newfileptr) {
  //  Purpose:  This method is useful when TTree::Fill has closed the current
  //            file and opened a new one with extension _1 because it has
  //            detected that the file limit of 2 GByte is near.  Its purpose
  //            is to swap the new file name and file pointer for the old
  //            filename and pointer in its file map, without actually
  //            closing the old file or opening the new file, since this
  //            has already been done by root.
  //
  //  Arguments:oldfilepathname  full file path name of old file.
  //            newfilepathname  full file path name of new file.
  //            newfileptr       pointer to new file opened by root.
  //
  //  Return:  pointer to new PerFile.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: Caution: this method is only meant to be used under the
  //         special circumstances described above. 
  //

  FileMapItr itr = fFileMap.find(oldfilepathname);

  if ( itr == fFileMap.end() ) {
    // Nothing to be done if conversion already made
    FileMapItr newItr = fFileMap.find(newfilepathname);
    if ( newItr == fFileMap.end() ) {
      MSG("Per",Msg::kWarning) << "ChangeFile unable to find old file "
         << oldfilepathname << " or new file " << newfilepathname 
                               << " in file map." << endl; 
      return (PerFile*)0;
    }
    else return itr->second;
  }

  // Else convert PerFile attributes and replace entry in map
  PerFile* perFile = itr->second;
  perFile -> ChangeFile(newfilepathname,newfileptr);

  fFileMap.erase(itr);  // erase old entry
  fFileMap[newfilepathname] = perFile;  // replace it with new

  return perFile;

}

void PerFileManager::CloseAll() {
  //  Purpose:  Close all files managed by PerFileManager.
  //
  //  Argument: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: Files are closed regardless of remaining number of clients.
  //


  for (FileMapItr itr = fFileMap.begin(); itr != fFileMap.end(); ++itr) {
    PerFile *file = itr -> second;
    file -> Close(true); // close file 
    delete file; // retrieve file memory
  }
  fFileMap.clear(); // clear all map entries

}

void PerFileManager::CloseFile(string fullfilepathname) {
  //  Purpose:  Close file with name fullfilepathname.  If file has more
  //            than one client, number of clients is just decremented by
  //            one and the file is left open.
  //
  //  Argument: fullfilepathname string containing name of file of interest.
  //
  //  Return:  none
  //
  //  Contact:   S. Kasahara
  //

  FileMapItr itr = fFileMap.find(fullfilepathname);
  if (itr != fFileMap.end()) {
    UInt_t clientsleft = (itr -> second) -> Close();
    if(clientsleft <= 0) {
      // Retrieve file memory and clear entry from map 
      delete (itr->second); 
      fFileMap.erase(itr);
    }
  }
  else {
    MSG("Per",Msg::kInfo) << "Unable to close file " << fullfilepathname <<
      ". File was not opened by PerFileManager. " << endl;
  }
  
}


const PerFile* PerFileManager::GetOpenedFile(string fullfilepathname) const {
  //  Purpose:  Retrieve file corresponding to fullfilepathname.
  //            File must have been previously opened with OpenFile method.
  //
  //  Argument: fullfilepathname string containing name of file of interest.
  //
  //  Return:  pointer to a constant PerFile. If file member with name
  //           fullfilepathname does not exist, returns (PerFile*)0.  
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: User may not modify PerFile data directly.  All
  //         modifications should be handled through the PerFileManager. 

  FileMapConstItr citr = fFileMap.find(fullfilepathname);
  return (citr != fFileMap.end()) ? citr -> second : (PerFile*)0;

}

PerFileManager& PerFileManager::Instance() {
  //  Purpose:  Return unique instance of PerFileManager, creating it
  //            if necessary.
  //
  //  Arguments: none.
  //
  //  Return:  reference to PerFileManager.
  //
  //  Contact:   S. Kasahara
  //

  static Cleaner cleaner; // Cleaner destructor provides cleanup of singleton
  if (fgInstance == 0) {
    cleaner.UseMe(); // dummy call to quiet compiler warnings
    fgInstance = new PerFileManager();
  }
  return *fgInstance;

}


const PerFile* PerFileManager::OpenFile(string fullfilepathname, Per::EAccessMode accessmode) {
  //  Purpose:  Open file with name fullfilepathname in specified accessmode.
  //            If file is already open, adds a new client to this file if
  //            new accessmode is compatible with the accessmode in which the
  //            file was initially opened.
  //
  //  Arguments:fullfilepathname string containing full file path name of
  //                             file to be opened.  File may be local
  //                             or remote.  See PerFile::OpenFile
  //                             for information about the remote filename
  //                             format.
  //            accessmode       EAccessMode in which file is to be opened
  //                             (defined in Per.h).
  //                             kRead = open file in read only mode.
  //                             kNew = open new file in read/write. If file
  //                                    already exists, do not overwrite.
  //                             kRecreate = same as kNew, but if file already
  //                                         exists overwrite.
  //                             kUpdate = open existing file in read/write.
  //                                
  //
  //  Return:  pointer to a constant PerFile. If unable to open
  //           file, or if requested accessmode is incompatible with the
  //           accessmode in which the file was originally opened, 
  //           returns (PerFile*)0.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: User may not modify PerFile data directly.  All
  //         modifications should be handled through the PerFileManager.
  //         See PerFile::OpenFile for information about specifying
  //         the authentication information required for remote access.
  //         If file fails to open, PerFileManager::GetErrorCode can
  //         be used to determine source of failure.

  bool openok = false;

  fErrorCode = Per::kErrSuccess;

  PerFile* file = fFileMap[fullfilepathname];
  if (!file) {
    // File not found in map, need to create new one
    file = new PerFile(fullfilepathname,accessmode);
    fFileMap[fullfilepathname] = file;
    if(!file || !file -> IsOpen()) {
      fErrorCode = Per::kErrFileError;
      if (file) {
        fErrorCode = file -> GetErrorCode();
        delete file; file = 0; // retrieve memory
      }
#ifndef IRIX6
      fFileMap.erase(fullfilepathname); // erase entry from map
#else
      // erase entry from map -- SGI barfs at fFileMap.erase(fullfilepathname);
      FileMapItr itr = fFileMap.find(fullfilepathname);
      fFileMap.erase(itr);
#endif
    }
    else {
      openok = true;
    }  
  }
  else {
    // File has already been opened, attempt to add new client if 
    // accessmodes are compatible
    openok = file -> AddNewClient(accessmode);
    if (!openok) fErrorCode = Per::kErrFileConflict;
  }

  return (openok) ? file : (PerFile*)0;

}

PerFileManager::PerFileManager() : fErrorCode(Per::kErrSuccess) {
  // Purpose: Default constructor.
  //
  // Arguments: none.
  //
  // Return: none.
  //
  // Contact:  S. Kasahara
  //
  // Notes: Not called directly, use PerFileManager::Instance() instead.

  // Initialize environment variable to force use of TNetFile in TFile::Open 
  // when path to file is prefaced by "root(s):", even when file path host
  // indicates a local file.
  gEnv -> SetValue("TFile.ForceRemote",1);

}

PerFileManager::~PerFileManager() {
  //  Purpose:  Destructor.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  
  // Close all managed files and retrieve allocated memory
  CloseAll();

}

std::ostream& PerFileManager::Print(std::ostream& ms) const {
  //  Purpose:  Print current map of files maintained by file manager on
  //            ostream.
  //
  //  Arguments: ms ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  //

  ms << "Number of files currently open = " << GetNumFile() << "." << endl;

  int ifile=0;
  for (FileMapConstItr itr = fFileMap.begin(); itr != fFileMap.end(); ++itr) {
    ms << ++ifile << ")" << itr -> second;
  }

  return ms;
}

---