TuplePut.h

Go to the documentation of this file.

#ifndef GAUDIALG_TUPLEPUT_H
#define GAUDIALG_TUPLEPUT_H 1
// =============================================================================
// Include files
// =============================================================================
#include <memory>
// =============================================================================
// GaudiKernel
// =============================================================================
#include "GaudiKernel/System.h"
// =============================================================================
// GaudiAlg
// =============================================================================
#include "GaudiAlg/TupleObj.h"
// ============================================================================
// ROOT TClass
// ============================================================================
#include "TClass.h"
// =============================================================================
// =============================================================================
namespace Tuples
{
  template <class VALUE>
  class ItemStore final
  {
    friend class TupleObj;

  private:
    typedef GaudiUtils::HashMap<std::string, std::unique_ptr<NTuple::Item<VALUE>>> Store;

  public:
    ItemStore() = default;

  private:
    inline NTuple::Item<VALUE>* getItem( const std::string& key, Tuples::TupleObj* tuple )
    {
      // find the item by name
      auto ifound = m_map.find( key );
      // existing item?
      if ( m_map.end() != ifound ) {
        return ifound->second.get();
      } // RETURN
      // check the tuple for booking:
      if ( !tuple ) {
        return nullptr;
      }
      // check the existence of the name
      if ( !tuple->goodItem( key ) ) {
        tuple->Error( "ItemStore::getItem('" + key + "') item name is not unique" ).ignore();
        return nullptr; // RETURN
      }
      // get the underlying object
      NTuple::Tuple* tup = tuple->tuple();
      if ( !tup ) {
        tuple->Error( "ItemStore::getItem('" + key + "') invalid NTuple::Tuple*" ).ignore();
        return nullptr; // RETURN
      }
      // create new item:
      // add the newly created item into the store:
      auto stored = m_map.emplace( key, std::unique_ptr<NTuple::Item<VALUE>>{new NTuple::Item<VALUE>()} );
      if ( !stored.second ) {
        tuple->Warning( "ItemStore::getItem('" + key + "') item already exists, new one not inserted!" ).ignore();
        return nullptr;
      }
      auto& item = stored.first->second;
      // add it into N-tuple
      StatusCode sc = tup->addItem( key, *item ); // ATTENTION!
      if ( sc.isFailure() ) {
        tuple->Error( "ItemStore::getItem('" + key + "') cannot addItem", sc ).ignore();
        m_map.erase( stored.first );
        return nullptr; // RETURN
      }
      // check the name again
      if ( !tuple->addItem( key, System::typeinfoName( typeid( VALUE ) ) ) ) {
        tuple->Warning( "ItemStore::getItem('" + key + "') the item not unique " ).ignore();
        m_map.erase( stored.first );
        return nullptr;
      }
      //
      return item.get(); // RETURN
    }

  private:
    // delete copy constructor and assignment
    ItemStore( const ItemStore& ) = delete;
    ItemStore& operator=( const ItemStore& ) = delete;

  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 type description & the flag
  static bool s_fail    = false;   // STATIC
  static TClass* s_type = nullptr; // STATIC
  // check the status
  if ( s_fail ) {
    return InvalidItem;
  } // RETURN
  else if ( !s_type ) {
    s_type = TClass::GetClass( typeid( TYPE ) );
    if ( !s_type ) {
      s_fail = true;
      return Error( " put('" + name + "'," + System::typeinfoName( typeid( TYPE ) ) + ") :Invalid ROOT Type",
                    InvalidItem ); // RETURN
    }
  }
  // the local storage of items
  static Tuples::ItemStore<TYPE*> s_map;
  // get the variable by name:
  auto item = s_map.getItem( name, this );
  if ( !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
// ============================================================================