PerStreamManager.cxx

Go to the documentation of this file.

//
// PerStreamManager
//
// Package: Per (Persistency).
//
// S. Kasahara 04/2001
//
// Purpose: Stream manager base class used by persistency package to manage
//          input and output streams.
//

#include <string>

#include "Persistency/PerStreamManager.h"
#include "Persistency/PerStream.h"
#include "MessageService/MsgService.h"

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

ClassImp(PerStreamManager)

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

CVSID("$Id: PerStreamManager.cxx,v 1.18 2007/03/20 22:52:09 schubert Exp $");

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

void PerStreamManager::CloseFile(string streamname) {
  //  Purpose:  Close current file serving specified stream(s).
  //
  //  Argument: streamname  string  name of stream on which to close file.
  //                                if streamname="*" (default), all
  //                                streams will have their files closed.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes:  Invokes PerStream::CloseFile for each requested stream.
  //


  if (streamname == "*") {
    // Close file on all streams
    for (StreamMapConstItr citr = fStreamMap.begin(); 
         citr != fStreamMap.end(); ++citr) 
      citr -> second -> CloseFile(); 
  }
  else {
    // Close stream of specified streamname
    PerStream* stream = GetOpenedStream(streamname);
    if (stream) stream -> CloseFile();
  }

}

void PerStreamManager::CloseStream(string streamname) {
  //  Purpose:  Close specified stream(s) and erase from stream manager's map.
  //
  //  Argument: streamname  string  name of stream to be closed.
  //                                if streamname ="*" (default), all
  //                                streams will be closed.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //

  if ( streamname == "*" ) {
    // Close all streams managed by streammanager.
    for (StreamMapItr itr=fStreamMap.begin();itr != fStreamMap.end(); ++itr) 
      delete (itr -> second); // retrieve stream memory
    fStreamMap.clear(); // clear all map entries
  }
  else {
    // Close stream of specified streamname
    StreamMapItr itr = fStreamMap.find(streamname);
    if (itr != fStreamMap.end()) {
      delete (itr -> second); // retrieve stream memory
      fStreamMap.erase(itr);
    }
  }

}

std::string PerStreamManager::GetCurrentFile(std::string streamname) const {
  //  Purpose:  Return current file name for specified stream.
  //
  //  Argument: streamname  If specified as "*", returns current file of
  //                        first open stream.
  //
  //  Return: current file name
  //
  //  Contact:   S. Kasahara
  //

  if ( streamname == "*" ) {
    for (StreamMapConstItr itr=fStreamMap.begin();itr!=fStreamMap.end();++itr){
      PerStream* stream = itr->second; 
      if ( stream -> IsOpen() ) return stream->GetFullFilePathName();
    }
  }
  else {
    PerStream* stream = this -> GetOpenedStream(streamname);
    if ( stream ) return stream->GetFullFilePathName();
  }

  return "";

}

PerStream* PerStreamManager::GetOpenedStream(std::string streamname) const {
  //
  //  Purpose:  Retrieve stream corresponding to streamname.
  //            Stream must have been previously opened with OpenStream method.
  //
  //  Argument: streamname  string  containing name of stream of interest.
  //
  //  Return:  pointer to a PerStream. If member with name
  //           streamname does not exist, returns (PerStream*)0.  
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: PerStream objects are owned by the PerStreamManager and
  //         should only be deleted through the PerStreamManager::Close method.
  //

  StreamMapConstItr citr = fStreamMap.find(streamname);
  return (citr != fStreamMap.end()) ? citr -> second : (PerStream*)0;

}

UInt_t PerStreamManager::GetNumStreamOpen() const {
  //
  //  Purpose:  Return count of number of streams that are IsOpen() (both
  //            tree and file pointers are non-null)
  //
  //  Argument: none.
  //
  //  Return:  number of open streams.
  //
  //  Contact:   S. Kasahara
  //

  UInt_t nopen = 0;

  for(StreamMapConstItr citr=fStreamMap.begin();citr!=fStreamMap.end();++citr){
    if ( citr->second->IsOpen() ) nopen++;
  }

  return nopen; 

}

PerStreamManager::PerStreamManager() : fPrintOpt("") {
  // Purpose: Default constructor.
  //
  // Arguments: none.
  //
  // Return: none.
  //
  // Contact:  S. Kasahara
  //

}

PerStreamManager::~PerStreamManager() {
  //  Purpose:  Destructor.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  
  // Close all managed streams and retrieve allocated memory
  CloseStream();

}

ostream& PerStreamManager::Print(ostream& ms,
                                 Option_t* /* option */) const {
  //  Purpose:  Print current map of streams maintained by stream manager on
  //            std::ostream.
  //
  //  Arguments: ms       std::ostream to display on.
  //             option   print option
  //
  //  Return:  std::ostream reference.
  //
  //  Contact:   S. Kasahara
  //

  ms << "StreamManager is currently managing " << GetNumStream() 
     << " stream(s):" << endl;

  Int_t nstream=0;
  for( StreamMapConstItr citr = fStreamMap.begin();
       citr != fStreamMap.end(); ++citr ) {
    ms << ++nstream << ")" << "Streamname " << citr -> first << endl;
    ms << *(citr -> second);
  }

  return ms;

}

void PerStreamManager::SetEnable(string streamname, bool enable) {
  //
  //  Purpose:  Enable/disable specified stream(s).
  //
  //  Argument: streamname  string  name of stream on which to close file.
  //                                if streamname="*" (default), all
  //                                streams will have their files closed.
  //            enable      bool    if true (default) stream is enabled.
  //                                disabled streams are skipped over
  //                                during stream manager i/o calls.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  //  Notes:  Invokes PerStream::SetEnable for each requested stream.
  //

  if (streamname == "*") {
    // Close file on all streams
    for (StreamMapConstItr citr = fStreamMap.begin(); 
         citr != fStreamMap.end(); ++citr) 
      citr -> second -> SetEnable(enable); 
  }
  else {
    // Close stream of specified streamname
    PerStream* stream = GetOpenedStream(streamname);
    if (stream) stream -> SetEnable(enable);
  }
  
}


bool PerStreamManager::SetFile(string streamname,string fullfilepathname, 
                               Per::EAccessMode accessmode) {
  //  Purpose:  Sets new file for specified stream.
  //
  //  Arguments:streamname       string  name of stream to set file.
  //                             if streamname="*", all streams will have
  //                             their file set.
  //            fullfilepathname string  new filename.
  //            accessmode       Per::EAccessMode accessmode in which to open
  //                                              file.
  //
  //  Return:  bool  set true if PerStream::SetFile returned true
  //                 for at least one of the requested streams. 
  //
  //  Contact:   S. Kasahara
  //
  //  Notes: Invokes PerStream::SetFile (or PerOutputStream/
  //         PerInputStream::SetFile as appropriate) for each requested stream.
  //         Note that PerOutputStream::SetFile enforces the uniqueness
  //         of treenames in any given file to avoid overwriting trees.

  bool openok = false;

  if (streamname == "*") {
    // Set new file for all streams.  
    for (StreamMapConstItr citr=fStreamMap.begin();
                          citr!=fStreamMap.end();++citr) { 
      if (  citr -> second -> IsEnabled() && 
          !(citr -> second -> SetFile(fullfilepathname,accessmode)) ) {
        MSG("Per",Msg::kWarning) << "Failed to set new file for stream "
                                 << citr->first << endl;
      }
      else {
        openok=true;
      } 
    }
  }
  else {
    // SetFile for stream of specified streamname
    PerStream* stream = GetOpenedStream(streamname);
    if (stream) {
      if (!stream -> SetFile(fullfilepathname,accessmode)) {
        MSG("Per",Msg::kWarning) << "Failed to set new file for stream "
                                 << streamname << endl;
      }
      else {
        openok=true;
      }
    }
  }

  return openok;

}

void PerStreamManager::SetTestMode(string streamname, bool testmode) {
  //
  //  Purpose:  Set streams to i/o test mode.
  //
  //  Argument: streamname  string  name of stream.
  //                                if streamname="*" (default), action
  //                                is applied to all streams.
  //            testmode    bool    if true, testmode is enabled.
  //                                one application is that the job
  //                                won't abort on the read of corrupt 
  //                                record.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //

  if (streamname == "*") {
    // Apply to all streams
    for (StreamMapConstItr citr = fStreamMap.begin(); 
         citr != fStreamMap.end(); ++citr) 
      citr -> second -> SetTestMode(testmode); 
  }
  else {
    // Apply to specified stream
    PerStream* stream = GetOpenedStream(streamname);
    if (stream) stream -> SetTestMode(testmode);
  }
  
}

---