MomNavigator.cxx

Go to the documentation of this file.

// $Id: MomNavigator.cxx,v 1.18 2010/01/13 23:13:07 rhatcher Exp $
//
// MomNavigator.cxx
//
// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br> 
//
// MomNavigator is the top level object for managing
// related records (eg. raw records, candidate trees, truth info)
//
// Author:  R. Hatcher 2000.05.18
//
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and 
// <a href="../MinosObjectMap.html"> MinosObjectMap Classes</a>(part of
// <a href="../index.html">The MINOS Class User Guide</a>)End_Html
#include <cassert>

#include "TClass.h"
#include "TString.h"

#include "MinosObjectMap/MomNavigator.h"
#include "MessageService/MsgService.h"
#include "Record/RecMinos.h"
#include "Record/RecMinosHdr.h"
#include "Record/RecRecord.h"

CVSID("$Id: MomNavigator.cxx,v 1.18 2010/01/13 23:13:07 rhatcher Exp $");

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

ClassImp(MomNavigator)

//______________________________________________________________________
MomNavigator::MomNavigator()
   : fFragmentArray(0)
{
   // Default constructor
   MSG("Mom",Msg::kDebug) << "MomNavigator ctor " << this << endl;
  
   fFragmentArray = new TObjArray;
}

//______________________________________________________________________
MomNavigator::~MomNavigator()
{
   // delete all the owned sub-objects
   MSG("Mom",Msg::kDebug) << "MomNavigator dtor " << this << "\n" 
                          << *this << endl;
   if (fFragmentArray) fFragmentArray->Delete();//delete owned Fragments
   delete fFragmentArray;
}

//______________________________________________________________________
void MomNavigator::AdoptFragment(TObject *Fragment)
{
   // adopt (to own) a Fragment

   fFragmentArray->Add(Fragment);
}

//______________________________________________________________________
TObject* MomNavigator::At(Int_t idx) const
{
   // return pointer to the i-th Fragment 
   
   return fFragmentArray->At(idx);
}

//______________________________________________________________________
TIter MomNavigator::FragmentIter() const
{
   // return an iter over the Fragments
   
   return TIter(fFragmentArray);
}

//______________________________________________________________________
Int_t MomNavigator::IndexOf(TObject *Fragment) 
{
   // return the index of this object (if contained in the list)
   
   return fFragmentArray->IndexOf(Fragment);
}

//______________________________________________________________________
TObject* MomNavigator::GetFragment(const char *classname,
                                   const char *username,
                                   const char *streamname) const {
// Returns the first selected fragment.  If classname is a null ptr or
// blank string, no class selection is done.  Any classname selection
// is done by testing on the InheritsFrom() boolean, rather than
// requiring agreement with the final derived class name.  The username
// is optional, but, if filled, will further qualify the selection by
// requiring agreement with the GetName() method of the fragment.  Note
// that TNamed and TCollection objects both have SetName() methods to
// allow the user to set a customized name.  General TObjects do not
// have the SetName() method and default to the GetName() name returned
// by the associated TClass object, i.e., the final derived class name.
// If the fragment is a Record then the name of the input stream it
// came from can be tested; non-Record objects will skip this test
// (i.e. treated as always matched).

   TString classtr("");
   if (classname)
     classtr.Append(TString(classname).Strip(TString::kBoth));
   TString userstr("");
   if (username)
     userstr.Append(TString(username).Strip(TString::kBoth));
   TString streamstr("");
   if (streamname)
     streamstr.Append(TString(streamname).Strip(TString::kBoth));

   TIter fiter(fFragmentArray);
   TObject* fragment = 0;
   while ((fragment = fiter())) {

// First check whether Fragment InheritsFrom "classname"
     if (classtr.IsNull() || fragment->IsA()->InheritsFrom(classtr)) {

// Then check whether Fragment name equals "username"
       if (userstr.IsNull() || (userstr == fragment->GetName())) {

         // early out if no request of stream name match
         if (streamstr.IsNull()) return fragment;

// Finally test the stream name (if it exists, and can be determined)
         Registry* iotags = 0;
         if ( RecMinos* record = dynamic_cast<RecMinos*>(fragment) ) {
           iotags = &(record->GetTempTags());
         }
         else if ( RecRecord* record = dynamic_cast<RecRecord*>(fragment) ) {
           iotags = &(record->GetTempTags());
         }
         if ( iotags ) {
           const char* tagstream = 0;
           if (iotags -> Get("stream",tagstream) 
               && strcmp(streamname,tagstream) == 0 ) return fragment;
         }
       }  // match username
     }  // match classname
   }  // loop over fragments
   return 0;
}

//______________________________________________________________________
std::vector<TObject*> MomNavigator::GetFragmentList(const char* classname,
                                                    const char *username,
                                                    const char *streamname) const {
// Returns the list of selected fragments satisfying the argument list.
// If classname is a null ptr or
// blank string, no class selection is done.  Any classname selection
// is done by testing on the InheritsFrom() boolean, rather than
// requiring agreement with the final derived class name.  The username
// is optional, but, if filled, will further qualify the selection by
// requiring agreement with the GetName() method of the fragment.  Note
// that TNamed and TCollection objects both have SetName() methods to
// allow the user to set a customized name.  General TObjects do not
// have the SetName() method and default to the GetName() name returned
// by the associated TClass object, i.e., the final derived class name.
// If the fragment is a Record then the name of the input stream it
// came from is tested and compared to the specified streamname (optional).
//

   std::vector<TObject*> fragmentList;
  
   TString classtr("");
   if (classname)
     classtr.Append(TString(classname).Strip(TString::kBoth));
   TString userstr("");
   if (username)
     userstr.Append(TString(username).Strip(TString::kBoth));
   TString streamstr("");
   if (streamname)
     streamstr.Append(TString(streamname).Strip(TString::kBoth));

   TIter fiter(fFragmentArray);
   TObject* fragment = 0;
   while ((fragment = fiter())) {

// First check whether Fragment InheritsFrom "classname"
     if (classtr.IsNull() || fragment->IsA()->InheritsFrom(classtr)) {
       // meets classname criteria
       if (userstr.IsNull() || (userstr == fragment->GetName())) {
         // meets username criteria
         if ( streamstr.IsNull() ) {
           // No request of stream name match
           fragmentList.push_back(fragment);
         }
         else {
           // Test the stream name (if it exists, and can be determined)
           Registry* iotags = 0;
           if ( RecMinos* record = dynamic_cast<RecMinos*>(fragment) ) {
             iotags = &(record->GetTempTags());
           }
           else if ( RecRecord* record = dynamic_cast<RecRecord*>(fragment) ) {
             iotags = &(record->GetTempTags());
           }
           if ( iotags ) {
             const char* tagstream = 0;
             if (iotags -> Get("stream",tagstream) 
                 && strcmp(streamname,tagstream) == 0 ) {
               fragmentList.push_back(fragment);
             }
           }
         }
       }  // match username
     }  // match classname
   }  // loop over fragments
   return fragmentList;
}
                                
  
//______________________________________________________________________
TObject* MomNavigator::GetFragmentByInputTag(const char *streamname,
      const char *treename, int treeindex, const char* filename) const {
// Returns the selected fragment matching the specified input tags.  Null
// is returned if none found.

   TIter fiter(fFragmentArray);
   TObject* fragment;
   while ((fragment = fiter())) {
     Registry* iotags = 0;
     if ( RecMinos* record = dynamic_cast<RecMinos*>(fragment) ) {
       iotags = &(record->GetTempTags());
     }
     else if ( RecRecord* record = dynamic_cast<RecRecord*>(fragment) ) {
       iotags = &(record->GetTempTags());
     }
     if ( iotags ) {
       const char* tagstream = 0;
       if(iotags->Get("stream",tagstream) && strcmp(streamname,tagstream)==0) {
         const char* tagtree = 0;
         if (iotags -> Get("tree",tagtree) && strcmp(treename,tagtree)==0 ) {
           int tagindex = -1;
           if (iotags -> Get("index",tagindex) && tagindex == treeindex ) {
             const char* tagfile = 0;
             if (iotags -> Get("file",tagfile) && strcmp(filename,tagfile)==0){
               return fragment;
             }
           }
         }
       }
     }
   }  // loop over fragments

   return 0; // no matching fragment found
}


//______________________________________________________________________
void MomNavigator::Clear(Option_t * opt )
{
   // Clear out all transient records 
   //
   // Since, *currently*, MomNavigator _owns_ the things in it's list
   // then it should be responsible for deleting the heap based objects
   // eventually when it is just a means of associating the objects
   // then that responsibility might change

  if ( !fFragmentArray ) return;
  MSG("Mom",Msg::kVerbose) << "MomNavigator::Clear. Mom contents at entry:\n" 
                           << *this << endl;
  
  // "optstr" is the string we'll match against.
  // Check if special additional flag is present, if it is remove it
  // and set the flag.
  TString optstr(opt);
  bool forceTransient = false;
  const TString fstring("?forceTransient");
  Ssiz_t ipos = optstr.Index(fstring);
  if ( ipos >= 0 ) {
    forceTransient = true;
    optstr.Remove(ipos,fstring.Length());
  }

  for ( int idx = fFragmentArray->GetEntriesFast()-1; idx >= 0; idx-- ) {
     TObject* fragment = fFragmentArray->At(idx);
     if ( !fragment ) continue;

     RecMinos* recminos = dynamic_cast<RecMinos*>(fragment);
     RecRecord* recrecord = dynamic_cast<RecRecord*>(fragment);

     // RWH 2010-01-13
     // If given a non-blank opt value, only drop fragments that match
     // that criteria based on stream, treename, 
     if ( optstr != "" ) {
       int ismatch = 0;
       TString fragClassName(fragment->ClassName());
       TString fragUserName(fragment->GetName());

       const Registry* reg = 0;
       if      (recminos)  reg = &(recminos->GetTempTags());
       else if (recrecord) reg = &(recrecord->GetTempTags());
       TString fragStream;
       const char* tmp = 0;
       if ( reg->Get("stream",tmp)) fragStream = tmp;

       if ( optstr == fragClassName ) ismatch = 0x01;
       if ( optstr == fragUserName  ) ismatch = 0x02;
       if ( optstr == fragStream    ) ismatch = 0x04;
       MSG("Mom",Msg::kDebug) << "MomNavigator::Clear(\"" << optstr << "\") "
                              << " class=\"" << fragClassName << "\""
                              << " user=\"" << fragUserName << "\""
                              << " stream=\"" << fragStream << "\""
                              << " ismatch=" << ismatch
                              << endl;
       if ( ismatch == 0 ) continue;  // not a match, don't drop fragment
       MSG("Mom",Msg::kDebug) << "drop the fragment" << endl;
     }


     bool isTransient = true;
     bool isPerOwned = false;
     if ( recminos ) {
       isTransient = recminos->IsTransient();
     }
     else if ( recrecord ) {
       isTransient = recrecord->IsTransient();
       isPerOwned = recrecord->IsPerOwned();
     }
     if ( isTransient || forceTransient ) {
       fFragmentArray->RemoveAt(idx); // remove does not delete object
       // If fragment is owned by persistency, only remove it from list
       if ( fragment && !isPerOwned ) delete fragment; 
       fragment = 0;
     }
   }
   fFragmentArray->Compress();
  
   MSG("Mom",Msg::kVerbose) << "MomNavigator::Clear. Mom contents at exit:\n"
                            << *this << endl;

}

std::ostream& MomNavigator::Print(std::ostream& os) const {
  //
  //  Purpose:  Print brief listing of mom contents on ostream.
  //
  //  Arguments: os ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  // 

  assert(fFragmentArray);
  
  Int_t nent = fFragmentArray->GetEntriesFast();
  if ( nent <= 0 ) {
    os << "Mom has no entries." << endl;
    return os;
  }
  
  os << "Mom contents listed by array index:" << endl;
  for (int idx = 0; idx < nent; idx++) {
    TObject* fragment = fFragmentArray->At(idx);
    if ( !fragment ) {
      os << idx << ")No object.";
    }
    else {
      os << idx << ")" << fragment->ClassName();
      Registry* iotags = 0;
      bool isTransient = true;
      bool isPerOwned = false;
      if ( RecMinos* record = dynamic_cast<RecMinos*>(fragment) ) {
        iotags = &(record->GetTempTags());
        isTransient = record -> IsTransient();
        const VldContext& vldc = record -> GetHeader() -> GetVldContext();
        os << " " <<  vldc;
      }
      else if ( RecRecord* record = dynamic_cast<RecRecord*>(fragment) ) {
        iotags = &(record->GetTempTags());
        isTransient = record -> IsTransient();
        isPerOwned = record -> IsPerOwned();
        const VldContext& vldc = (record -> GetHeader()).GetVldContext();
        os << " " << vldc;
      }

      if ( strcmp(fragment->GetName(),"") ) {
        os << ", TNamed " << fragment->GetName();
      }
      if ( iotags ) {
        const char* tagstream = 0;
        if(iotags->Get("stream",tagstream)) {
          os << ", InputStream " << tagstream;
        }
      }
      os << (( isTransient ) ? ", isTransient " : ", isNotTransient ");
      os << (( isPerOwned ) ? ", isPerOwned " : ", isNotPerOwned ");
    }
    os << endl;
  }

  return os;

}

void MomNavigator::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;

}

---