TStore.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TSTORE_H
#define XAODROOTACCESS_TSTORE_H
 
// System include(s):
#include <string>
#include <map>
#include <memory>
#include <unordered_map>
#include <vector>
 
// ROOT include(s):
#include <Rtypes.h>
 
// EDM include(s):
#include "AthContainers/ConstDataVector.h"
#include "SGCore/sgkey_t.h"
 
// Local include(s):
#include "AsgMessaging/StatusCode.h"
 
namespace xAOD {
 
   // Forward declaration(s):
   class THolder;
   class TEvent;
   class Event;

   class TStore {

      friend class TEvent;
      friend class Event;
 
   public:
      TStore();
      TStore( const TStore& ) = delete;
      virtual ~TStore();

      TStore& operator=( const TStore& ) = delete;

      void setActive();


      template< typename T >
      ::Bool_t contains( const std::string& key ) const;

      template< typename T >
      ::Bool_t isConst( const std::string& key ) const;

      template< typename T >
      StatusCode retrieve( const T*& obj, const std::string& key ) const;
      template< typename T >
      StatusCode retrieve( T*& obj, const std::string& key ) const;

      template< typename T >
      StatusCode record( T* obj, const std::string& key );
      template< typename T >
      StatusCode record( std::unique_ptr< T > obj, const std::string& key );

      template< typename T >
      StatusCode record( const T* obj, const std::string& key );
      template< typename T >
      StatusCode record( std::unique_ptr< const T > obj, const std::string& key );

      template< typename T >
      void keys( std::vector< std::string >& vkeys ) const;

      const THolder* holder( const std::string& key ) const;

      StatusCode remove( const std::string& key );
      StatusCode remove( void* ptr );

      void clear();


      void print() const;
 
   protected:
      ::Bool_t contains( const std::string& key,
                         const std::type_info& ti ) const;
      ::Bool_t isConst( const std::string& key,
                        const std::type_info& ti ) const;
      void* getObject( const std::string& key, const std::type_info& ti ) const;
      const void* getConstObject( const std::string& key,
                                  const std::type_info& ti ) const;
      StatusCode record( void* obj, const std::string& key,
                         const std::string& classname,
                         ::Bool_t isOwner, ::Bool_t isConst );
      StatusCode record( void* obj, const std::string& key,
                         const std::type_info& ti,
                         ::Bool_t isOwner, ::Bool_t isConst );

      template< class T >
      StatusCode record( ConstDataVector< T >* obj, const std::string& key,
                         const std::type_info& ti,
                         ::Bool_t isOwner, ::Bool_t isConst );
      StatusCode record( THolder* hldr, const std::string& key );


      ::Bool_t contains( SG::sgkey_t hash ) const;
      ::Bool_t contains( const void* ptr ) const;
      const std::string& getName( SG::sgkey_t hash ) const;
      const std::string& getName( const void* ptr ) const;
      void getNames(const std::string& targetClassName,
                    std::vector<std::string>& vkeys ) const;


      typedef std::unordered_map< std::string, THolder* > Objects_t;
      typedef SG::SGKeyMap< std::string > HashedKeys_t;

      Objects_t m_objects;
      HashedKeys_t m_keys;
      std::unordered_map< const void*, const std::string* > m_names;
 
   private:
      template< typename T >
      StatusCode record_impl( T* obj, const std::string& key,
                              ::Bool_t isOwner, ::Bool_t isConst );
 
   }; // class TStore
 
} // namespace xAOD
 
// Include the template implementation.
#include "TStore.icc"
 
#endif // XAODROOTACCESS_TSTORE_H