IAthMetaDataSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_IATHMETADATASVC_H
#define ATHENAKERNEL_IATHMETADATASVC_H

 
#include "GaudiKernel/INamedInterface.h"
#include "AthenaKernel/MetaCont.h"
#include "StoreGate/StoreGateSvc.h"
 
#include <string>
#include <set>
#include <mutex>
#include <typeinfo>

class IAthMetaDataSvc : virtual public ::INamedInterface {
 
public: // Non-static members
   DeclareInterfaceID(IAthMetaDataSvc, 1, 0);
 
   
   virtual StatusCode shmProxy(const std::string& filename) = 0;

   virtual std::set<std::string> getPerStreamKeysFor(const std::string& key ) const;
 
   // =======  Methods for handling metadata objects stored in MetaContainers (EventService)
   template <typename T, class TKEY>
   T* tryRetrieve (const TKEY& key) const;
 
   template <typename T, class TKEY>
   const T* tryConstRetrieve(const TKEY& key) const;

   template <typename T, typename TKEY> 
   StatusCode record(T* p2BRegistered, const TKEY& key);

   template <typename T, typename TKEY> 
   StatusCode record(std::unique_ptr<T> pUnique, const TKEY& key);

   template <typename T, typename TKEY> 
   StatusCode remove(const TKEY& key, bool ignoreIfAbsent=false);

   template <typename T, typename TKEY>
   bool contains(const TKEY& key) const;

   virtual const std::string currentRangeID() const = 0;
 
protected:
   virtual void recordHook(const std::type_info&) {}

   virtual void removeHook(const std::type_info&) {}

   virtual StoreGateSvc* outputDataStore() const = 0;
 
private: // Data
   std::mutex    m_mutex;
};
 
 
inline std::set<std::string>
IAthMetaDataSvc::getPerStreamKeysFor(const std::string& key ) const {
   return std::set<std::string>( {key} );
}

template <typename T, class TKEY>
T* IAthMetaDataSvc::tryRetrieve (const TKEY& key) const
{
   const MetaCont<T>* container = outputDataStore()->tryRetrieve< MetaCont<T> >(key);
   if( container ) {
      return container->get( currentRangeID() );
   }
   return nullptr;
}
 
template <typename T, class TKEY>
const T* IAthMetaDataSvc::tryConstRetrieve (const TKEY& key) const
{
   const MetaCont<T>* container = outputDataStore()->tryRetrieve< MetaCont<T> >(key);
   if( container ) {
      return container->get( currentRangeID() );
   }
   return nullptr;
}
 
template <typename T, typename TKEY> 
StatusCode IAthMetaDataSvc::record(T* pObject, const TKEY& key)
{
   std::lock_guard lock(m_mutex);
   MetaCont<T>* container = outputDataStore()->tryRetrieve< MetaCont<T> >(key);
   StatusCode sc = StatusCode::FAILURE;
   if( !container ) {
      auto cont_uptr = std::make_unique< MetaCont<T> >();
      if( cont_uptr->insert( currentRangeID() , pObject) )
         sc = outputDataStore()->record( std::move(cont_uptr), key );
   } else {
      if (container->insert(currentRangeID(), pObject)) sc = StatusCode::SUCCESS;
   }
   if (sc.isSuccess()) recordHook(typeid(T));
   return sc;
}
 
 
template <typename T, typename TKEY> 
StatusCode IAthMetaDataSvc::record(std::unique_ptr<T> pUnique, const TKEY& key)
{
   if( this->record( pUnique.release(), key ).isSuccess() ) {
      return StatusCode::SUCCESS;
   }
   return StatusCode::FAILURE;
}
 
 
template <typename T, class TKEY>
StatusCode IAthMetaDataSvc::remove(const TKEY& key, bool ignoreIfAbsent)
{
   std::lock_guard lock(m_mutex);
   // change erase to setting nullptr?
   MetaCont<T>* container = outputDataStore()->tryRetrieve< MetaCont<T> >(key);
   if (container && container->erase(currentRangeID())) {
     if (container->entries() == 0u) removeHook(typeid(T));
     return StatusCode::SUCCESS;
   }
   return ignoreIfAbsent? StatusCode::SUCCESS : StatusCode::FAILURE;
}
 
template <typename T, typename TKEY>
bool IAthMetaDataSvc::contains(const TKEY& key) const {
  if (!outputDataStore()->contains< MetaCont<T> >(key))
    return false;
  const MetaCont<T>* container =
      outputDataStore()->tryConstRetrieve< MetaCont<T> >(key);
  return container && container->valid(currentRangeID());
}
 
#endif