RecRecordImp.cxx

Go to the documentation of this file.

//
// RecRecordImp
//
// RecRecordImp is the Base Class for MINOS records
//
// Author:  S. Kasahara   9/02
//

#include "Record/RecRecordImp.h"

#ifdef MACOSX
 using namespace std;
#endif

ClassImpT(RecRecordImp,T)

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

template<class T>
const VldContext* RecRecordImp<T>::GetVldContext() const {
  //
  //  Purpose:  Return a const pointer to the VldContext in the header.
  //
  //  Arguments: none.
  //
  //  Return:  ptr to VldContext or null if none.  
  //
  //  Contact:   S. Kasahara
  // 

  const RecHeader* hdr = dynamic_cast<const RecHeader*>(&GetHeader());
  if ( hdr) 
    return &(hdr->GetVldContext());
  else
    return 0;

}

template<class T>
void RecRecordImp<T>::HasBeenModified() {
  //
  //  Purpose:  Handle generic record tasks appropriate for when record
  //            has been newly modified.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  The default behavior provided by this method is to clear
  //          the Registry value associated with the key "outstream" in
  //          the Registry fTempTags data member.  This indicates to
  //          any output module(s) in the user's job path(s) that the modified
  //          record should be re-persisted.
  // 

  fTempTags.RemoveKey("outstream");
  return;

}

template<class T>
void RecRecordImp<T>::PersistedToOutputStream(const char* stream,
                      const char* file, const char* tree, int index) {
  //
  //  Purpose:  Mark the record as having been stored in the named stream,file,
  //            tree, tree index location.
  //
  //  Arguments: stream name, file name, tree name, tree index to which record 
  //             was stored.  
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  The output stream,file,tree,treeindex will be stored in
  //          Registry fTempTags in the following manner:
  //          key         type/value
  //          ===         ==========
  //          "outstream" Registry/see below:
  //                      key     type/value
  //                      ===     ==========
  //                      "nout"  int/# times this record has been persisted
  //                       "0"    Registry/see below:
  //                       "1"    Registry/   "
  //                       ...    Registry/   "
  //                     "nout-1" Registry/   "
  //                              key      type/value
  //                              ===      ==========
  //                              "stream" const char*/output stream name
  //                              "file"   const char*/output file name
  //                              "tree"   const char*/output tree name
  //                              "index"  int        /output tree index
  //          

  Registry outStreamRegistry;
  int nout = 0;
  if ( fTempTags.Get("outstream",outStreamRegistry) ) {
    outStreamRegistry.Get("nout",nout); 
  }
  outStreamRegistry.UnLockValues();

  // New output stream registry
  Registry newOutStream;
  newOutStream.Set("stream",stream);
  newOutStream.Set("file",file);
  newOutStream.Set("tree",tree);
  newOutStream.Set("index",index);

  // Insert new output stream registry at key nout of "outstream" registry
  char cnoutkey[20];
  sprintf(cnoutkey,"%i",nout);
  outStreamRegistry.Set(cnoutkey,newOutStream);
  nout++;
  outStreamRegistry.Set("nout",nout); 
  outStreamRegistry.LockValues();
  
  // Store revised "outstream" registry
  fTempTags.UnLockValues();
  fTempTags.Set("outstream",outStreamRegistry);
  fTempTags.LockValues();

}

template<class T>
bool RecRecordImp<T>::IsPersistedToOutputStream(const char* stream,
                          const char* file,const char* tree,int index) const {
  //
  //  Purpose:  Check to see if record has been persisted to the output
  //            stream/file/tree/tree index of interest. 
  //
  //  Arguments: stream/tree/file/tree index of interest.  If a value is
  //             left at default ("" for stream/tree/file, or -1 for index),
  //             that argument will not be checked. 
  //
  //  Return:  true or false. Result will be true if all non-default arguments 
  //           match those of one of the output streams to which this record
  //           has been persisted.
  //
  //  Contact:   S. Kasahara
  // 

  std::string s(stream);
  std::string f(file);
  std::string t(tree);

  Registry outStreamRegistry;
  int nout = 0;
  if ( fTempTags.Get("outstream",outStreamRegistry) ) {
    outStreamRegistry.Get("nout",nout);
    for ( int iout = 0; iout < nout; iout++) {
      char cioutkey[20];
      sprintf(cioutkey,"%i",iout);
      Registry outStream;
      outStreamRegistry.Get(cioutkey,outStream);
      bool isMatch = true;
      if ( !s.empty() ) {
        const char* cstream = 0;
        outStream.Get("stream",cstream);
        if ( std::string(cstream) != s ) isMatch = false;
      }        
      if ( !f.empty() ) {
        const char* cfile = 0;
        outStream.Get("file",cfile);
        if ( std::string(cfile) != f ) isMatch = false;
      }

      if ( !t.empty() ) {
        const char* ctree = 0;
        outStream.Get("tree",ctree);
        if ( std::string(ctree) != t ) isMatch = false;
      }
      if ( index > -1 ) {
        int storedindex = -1;
        outStream.Get("index",storedindex);
        if ( storedindex != index ) isMatch = false;
      }
      if ( isMatch ) {
        return true;  // found match in registry
      }
    } 
  }

  return false; // failed to find match in registry

}

template<class T>
bool RecRecordImp<T>::IsPerOwned() const {
  //
  //  Purpose:  If IsPerOwned (def=false), record is owned by Persistency
  //            Mom should only Remove the record from its array of
  //            fragments, but not delete it.
  //
  //  Arguments: none.
  //
  //  Return:  true or false. 
  //
  //  Contact:   S. Kasahara
  // 

  int isPerOwned = 0;
  if ( !fTempTags.Get("isPerOwned",isPerOwned) ) return false;
  return ( isPerOwned ) ? true : false;

}

template<class T>
bool RecRecordImp<T>::IsTransient() const {
  //
  //  Purpose:  If IsTransient (def=true), record will exist in memory for one
  //            job cycle only. 
  //
  //  Arguments: none.
  //
  //  Return:  true or false. 
  //
  //  Contact:   S. Kasahara
  // 

  int isTransient = 1;
  if ( !fTempTags.Get("isTransient",isTransient) ) return true;
  return ( isTransient ) ? true : false;

}

template<class T>
void RecRecordImp<T>::SetTransient(bool isTransient) {
  //
  //  Purpose:  Set transient state of record.  If set true(def), record will
  //            exist in memory for one job cycle only.
  //
  //  Arguments: true or false.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  fTempTags.UnLockValues();
  if ( isTransient ) fTempTags.Set("isTransient",1);
  else fTempTags.Set("isTransient",0);
  fTempTags.LockValues();
  return;

}

template<class T>
void RecRecordImp<T>::SetPerOwned(bool isPerOwned) {
  //
  //  Purpose:  Set ownership status of record.  If set true(def), record is
  //            owned by Persistency and the user should not delete.
  //
  //  Arguments: true or false.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  fTempTags.UnLockValues();
  if ( isPerOwned ) fTempTags.Set("isPerOwned",1);
  else fTempTags.Set("isPerOwned",0);
  fTempTags.LockValues();
  return;

}

template<class T>
std::ostream& RecRecordImp<T>::Print(std::ostream& os) const {
  //
  //  Purpose:  Print status of record on ostream.
  //
  //  Arguments: os ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  // 

  os << "RecRecordImp::Print:\n" <<  fHeader << std::endl;
  fJobHistory.Print();
  
  return os;

}

template<class T>
void  RecRecordImp<T>::Print(Option_t* /* option */) const {
  //
  //  Purpose:  Print header in form supported by TObject::Print.
  //
  //  Arguments: option (not used)
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  // 

  Print(std::cout);

  return;

}

---