In This Package:

TuplePut.h

Go to the documentation of this file.

// $Id: TuplePut.h,v 1.2 2007/05/24 14:22:58 hmd Exp $
// =============================================================================
// CVS tag $Name: GAUDI_v20r4-pre $, verison $Revison:$
// =============================================================================
#ifndef GAUDIALG_TUPLEPUT_H 
#define GAUDIALG_TUPLEPUT_H 1
// =============================================================================
// Include files
// =============================================================================
// GaudiKernel
// =============================================================================
#include "GaudiKernel/System.h"
// =============================================================================
// GaudiAlg
// =============================================================================
#include "GaudiAlg/TupleObj.h"
// ============================================================================
// Reflex
// ============================================================================
#include "Reflex/Reflex.h"
// =============================================================================
// =============================================================================
namespace Tuples 
{ 
  template <class VALUE> 
  class ItemStore 
  {
    friend class TupleObj ;
  private:
    typedef GaudiUtils::HashMap<std::string,NTuple::Item<VALUE>*>  Store;
  public:
    ItemStore() : m_map() {}
    ~ItemStore() 
    {
      for ( typename Store::iterator ientry  = m_map.begin() ; 
            m_map.end() != ientry ; ++ientry ) 
      { if ( 0 != ientry->second ) { delete ientry->second ; } } 
    } ;
  protected:
    inline NTuple::Item<VALUE>* getItem 
    ( const std::string& key , Tuples::TupleObj* tuple )
    {
      // find the item by name 
      typename Store::iterator ifound = m_map.find( key ) ;
      // existing item?
      if ( m_map.end() != ifound ) { return ifound->second ; }        // RETURN
      // check the tuple for booking:
      if ( 0 == tuple ) { return 0 ; }
      // check the existrence of the name 
      if ( !tuple->goodItem ( key ) ) 
      {
        tuple -> Error ( "ItemStore::getItem('" + key 
                         + "') item name is not unique").ignore() ;
        return 0 ;                                                    // RETURN 
      }
      // get the underlying object      
      NTuple::Tuple* tup = tuple->tuple() ;
      if ( 0 == tup ) 
      {
        tuple -> Error ( "ItemStore::getItem('" + key 
                         + "') invalid NTuple::Tuple*" ).ignore() ;
        return 0 ;                                                   // RETURN
      }  
      // create new item:
      NTuple::Item<VALUE>* item = new NTuple::Item<VALUE>() ;
      // add it into N-tuple 
      StatusCode sc = tup->addItem( key , *item ) ;                 // ATTENTION!
      if ( sc.isFailure() ) 
      {
        tuple -> Error   ( "ItemStore::getItem('" + key 
                           + "') cannot addItem" , sc ).ignore() ;
        return 0 ;                                                  // RETURN 
      }
      // check the name again 
      if ( !tuple->addItem( key , System::typeinfoName ( typeid ( VALUE ) ) ) ) 
      {
        tuple -> Warning ( "ItemStore::getItem('" + key 
                           + "') the item not unique " ).ignore() ;
      }    
      // add the newly created item into the store:
      if ( !m_map.insert ( std::make_pair ( key , item ) ).second ) 
      {
        tuple -> Warning ( "ItemStore::getItem('" + key 
                           + "') item is not inserted!" ).ignore() ;        
      }
      //
      return item ;                                                  // RETURN 
    }
  private:
    // copy constructor is disabled 
    ItemStore           ( const ItemStore& ) ; 
    // assignement is disabled 
    ItemStore& operator=( const ItemStore& ) ; 
  private:
    Store m_map ; 
  } ;
} // end of namespace Tuples 
// =============================================================================
// =============================================================================
template <class TYPE>
inline StatusCode Tuples::TupleObj::put 
( const std::string& name , const TYPE* obj ) 
{
  if (  invalid    () ) { return InvalidTuple     ; }   // RETURN
  if ( !evtColType () ) { return InvalidOperation ; }   // RETURN 
  
  // static block: The Reflex type description & the flag 
  static bool               s_fail = false ;                // STATIC 
  static ROOT::Reflex::Type s_type         ;                // STATIC 
  // check the status 
  if      (  s_fail  ) { return InvalidItem ; }                           // RETURN 
  else if ( !s_type  ) 
  { 
    const std::string class_name = System::typeinfoName ( typeid ( TYPE ) ) ;
    s_type = ROOT::Reflex::Type::ByName( class_name  ) ;
    if ( !s_type ) 
    {
      s_fail = true ; 
      return Error ( " put('"+name+"'," + class_name + 
                     ") :Invalid ROOT::Reflex::Type", InvalidItem ) ;    // RETURN 
    }
  }
  // the local storage of items 
  static Tuples::ItemStore<TYPE*> s_map ;
  // get the variable by name:
  NTuple::Item<TYPE*>* item = s_map.getItem ( name , this ) ;
  if ( 0 == item )
  { return Error ( " put('" + name + "'): invalid item detected", InvalidItem ) ; }
  // assign the item!
  (*item) = const_cast<TYPE*> ( obj ) ;                    // THATS ALL!!
  //
  return StatusCode::SUCCESS ;                             // RETURN
}
// ============================================================================

// ============================================================================
// The END 
// ============================================================================
#endif // GAUDIALG_TUPLEPUT_H
// ============================================================================

---