RecArrayAllocator.cxx

Go to the documentation of this file.

//
// RecArrayAllocator
//
// Package: Rec (Record).
//
// S. Kasahara 09/02
//
// Purpose: Singleton class used to manage the allocation of TClonesArrays
//

#include <string>
#include <iostream>
using std::endl;

#include "TClonesArray.h"
#include "TClass.h"

#include "Record/RecArrayAllocator.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"

std::ostream& operator << (std::ostream& os, const RecArrayAllocator& raa) 
                                                 { return raa.Print(os); }
//   Definition of static data members
//   *********************************

CVSID("$Id: RecArrayAllocator.cxx,v 1.10 2006/05/11 18:47:14 schubert Exp $");

ClassImp(RecArrayAllocator)

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

RecArrayAllocator* RecArrayAllocator::fgInstance = 0;

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


TClonesArray* const RecArrayAllocator::GetArray(const char* className) {
  //  Purpose:  Return TClonesArray of requested type, creating it if
  //            necessary.
  //
  //  Arguments: none.
  //
  //  Return:  const ptr to non-const TClonesArray.
  //
  //  Contact:   S. Kasahara
  //

  for ( ArrayMapItr itr = fArrayMap.begin(); itr != fArrayMap.end(); itr++ ) {
    if ( itr->second ) {
      // Array is free, check type
      TClonesArray* array = itr->first;
      if ( !strcmp(array->GetClass()->GetName(),className) ) {
        itr->second = false;
        MSG("Rec",Msg::kVerbose) 
        << "GetArray retrieved existing TClonesArray of type " << className
        << endl;
        return array;
      }
    }
  } 

  // No existing TClonesArray is available for use, create one here
  TClonesArray* array = new TClonesArray(className);
  fArrayMap.insert(std::make_pair(array,false));
  MSG("Rec",Msg::kVerbose) 
    << "GetArray created new TClonesArray to support type " << className
    << endl;
  return array;
   
}

RecArrayAllocator& RecArrayAllocator::Instance() {
  //  Purpose:  Return unique instance of RecArrayAllocator, creating it
  //            if necessary.
  //
  //  Arguments: none.
  //
  //  Return:  reference to RecArrayAllocator.
  //
  //  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 RecArrayAllocator();
    MSG("Rec",Msg::kDebug) << "Constructed RecArrayAllocator instance "
                           << fgInstance << endl;
  }
  return *fgInstance;

}

void RecArrayAllocator::ReleaseArray(TClonesArray* array) {
  //  Purpose:  Dereference use of TClonesArray, freeing it for reuse.
  //
  //  Arguments: ptr to TClonesArray to be dereferenced.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //

  // clears array.  The user has the responsibility of i)calling 
  // TClonesArray::Delete() before releasing array if the stored objects 
  // allocate memory, or ii)alternatively implementing a Clear method for these
  // objects that frees up any allocated memory. This method will be called
  // by the array->Clear("C") call below.
  if ( array ) { 
    ArrayMapItr itr = fArrayMap.find(array);
    if ( itr != fArrayMap.end() ) {
      MSG("Rec",Msg::kVerbose) << "ReleaseArray of type " 
                               << array->GetClass()->GetName() << endl; 
      array -> Clear("C");
      itr->second = true;
    }
    else {
      MSG("Rec",Msg::kWarning) << "Release array request for type " 
                               << array->GetClass()->GetName() << " ptr "
                               << array << " is not in array map! Ignored." 
                               << endl;
    } 
  }
}

std::ostream& RecArrayAllocator::Print(std::ostream& os) const {
  //  Purpose:  Print current map of arrays maintained by array allocator on
  //            ostream.
  //
  //  Arguments: ms ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  //

  int size = fArrayMap.size();
  if ( size <= 0 ) {
    os << "RecArrayAllocator is currently not managing any arrays." << endl;
    return os;
  }

  os << "RecArrayAllocator is currently managing " << size 
     << " array" << ((size > 1) ? "s:" : ":") << endl;
  
  int i=0; 
  for( ArrayMapConstItr itr = fArrayMap.begin();itr != fArrayMap.end();itr++) {
    os << " " << i << ")Serves class " << itr->first->GetClass()->GetName() 
       << ((itr->second) ? " and is available." : 
       " and is in use.") << endl;
    i++;   
  }
  return os;

}

RecArrayAllocator::RecArrayAllocator()  {
  // Purpose: Default constructor.
  //
  // Arguments: none.
  //
  // Return: n/a.
  //
  // Contact:  S. Kasahara
  //
  // Notes: Not called directly, use RecArrayAllocator::Instance() instead.

}

RecArrayAllocator::~RecArrayAllocator() {
  //  Purpose:  Destructor.
  //
  //  Arguments: none.
  //
  //  Return:  none.
  //
  //  Contact:   S. Kasahara
  //
  
  // Close all managed arrays and retrieve allocated memory
  MSG("Rec",Msg::kDebug) << "RecArrayAllocator destructor for addr " 
                         << this << endl;
  
  for( ArrayMapItr itr = fArrayMap.begin(); itr != fArrayMap.end(); itr++ ) {
    TClonesArray* array = itr -> first;
    if ( array ) {
      if ( !(itr->second) ) {
        MSG("Rec",Msg::kWarning) << "RecArrayAllocator dtor deleting array "
                                 << array->GetClass()->GetName() 
                                 << " which has not been released!" << endl;
      }
      else {
        MSG("Rec",Msg::kDebug) << "Clearing and Deleting array of type " 
                               << array->GetClass()->GetName() << endl;
      }
      array -> Clear("C");
      delete array; array = 0;
    }
    fArrayMap.erase(itr);
  }
  
}

---