Tuples::ItemStore< VALUE > Class Template Reference

#include <GaudiAlg/TuplePut.h>

Collaboration diagram for Tuples::ItemStore< VALUE >:

Public Member Functions
	ItemStore ()=default
	constructor : create empty map More...

Private Member Functions
NTuple::Item< VALUE > *	getItem (std::string_view key, Tuples::TupleObj *tuple)
	the only one method: More...
	ItemStore (const ItemStore &)=delete
ItemStore &	operator= (const ItemStore &)=delete

Private Attributes
std::unordered_map< std::string_view, std::pair< NTuple::Item< VALUE >, std::string > >	m_map
	the underlying map More...

Friends
class	TupleObj

Detailed Description

template<class VALUE>
class Tuples::ItemStore< VALUE >

Simple class, which represents the local storage of N-tuple items of the given type. Essentially it is a restricted std::unordered_map with ownership of the newly created entries

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2007-04-08

Definition at line 35 of file TuplePut.h.

Constructor & Destructor Documentation

ItemStore() [1/2]

template<class VALUE >

Tuples::ItemStore< VALUE >::ItemStore ( )

default

constructor : create empty map

ItemStore() [2/2]

template<class VALUE >

Tuples::ItemStore< VALUE >::ItemStore ( const ItemStore< VALUE > &  )

privatedelete

Member Function Documentation

getItem()

template<class VALUE >

NTuple::Item<VALUE>* Tuples::ItemStore< VALUE >::getItem ( std::string_view  key, Tuples::TupleObj *  tuple  )

inlineprivate

the only one method:

Definition at line 44 of file TuplePut.h.

                                                                            {
      // find the item by name
      auto ifound = m_map.find( key );
      // existing item?
      if ( m_map.end() != ifound ) return &ifound->second.first; // RETURN
 
      // check the tuple for booking:
      if ( !tuple ) return nullptr;
      // check the existence of the name
      if ( !tuple->goodItem( key ) ) {
        tuple->Error( fmt::format( "ItemStore::getItem('{}') item name is not unique", key ) ).ignore();
        return nullptr; // RETURN
      }
      // get the underlying object
      NTuple::Tuple* tup = tuple->tuple();
      if ( !tup ) {
        tuple->Error( fmt::format( "ItemStore::getItem('{}') invalid NTuple::Tuple*", key ) ).ignore();
        return nullptr; // RETURN
      }
      // create new item:
      // add the newly created item into the store -- and point the key view into the mapped value...
      auto [iter, ok] = m_map.try_emplace( key, NTuple::Item<VALUE>{}, std::string{key} );
      if ( ok ) {
        auto nh  = m_map.extract( iter );
        nh.key() = nh.mapped().second; // "re-point" key to the string contained value_type
        // std::tie( iter,ok,std::ignore)  = m_map.insert( std::move( nh ) );
        auto r = m_map.insert( std::move( nh ) );
        iter   = r.position;
        ok     = r.inserted;
      }
      if ( !ok ) {
        tuple->Warning( fmt::format( "ItemStore::getItem('{}') item already exists, new one not inserted!", key ) )
            .ignore();
        return nullptr;
      }
      auto& item = iter->second.first;
      // add it into N-tuple
      StatusCode sc = tup->addItem( iter->second.second, item ); // ATTENTION!
      if ( sc.isFailure() ) {
        tuple->Error( fmt::format( "ItemStore::getItem('{}') cannot addItem", key ), sc ).ignore();
        m_map.erase( iter );
        return nullptr; // RETURN
      }
      // check the name again
      if ( !tuple->addItem( iter->second.second, System::typeinfoName( typeid( VALUE ) ) ) ) {
        tuple->Warning( fmt::format( "ItemStore::getItem('{}') the item not unique ", key ) ).ignore();
        m_map.erase( iter );
        return nullptr;
      }
      //
      return &item; // RETURN
    }

operator=()

template<class VALUE >

ItemStore& Tuples::ItemStore< VALUE >::operator= ( const ItemStore< VALUE > &  )

privatedelete

Friends And Related Function Documentation

TupleObj

template<class VALUE >

friend class TupleObj

friend

Definition at line 36 of file TuplePut.h.

Member Data Documentation

m_map

template<class VALUE >

std::unordered_map<std::string_view, std::pair<NTuple::Item<VALUE>, std::string> > Tuples::ItemStore< VALUE >::m_map

private

the underlying map

Definition at line 102 of file TuplePut.h.

---

The documentation for this class was generated from the following file:

• GaudiAlg/include/GaudiAlg/TuplePut.h