AuxTypeRegistry.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_AUXTYPEREGISTRY_H
#define ATHCONTAINERS_AUXTYPEREGISTRY_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "AthContainersInterfaces/IAuxTypeVectorFactory.h"
#include "AthContainers/tools/AuxTypeVector.h"
#include "AthContainers/tools/AuxTypeVectorFactory.h"
#include "AthContainers/tools/threading.h"
#include "CxxUtils/ConcurrentStrMap.h"
#include "CxxUtils/SimpleUpdater.h"
#ifndef XAOD_STANDALONE
#include "AthenaKernel/IInputRename.h"
#include "AthenaKernel/IStringPool.h"
#endif
#include <cstddef>
#include <typeinfo>
#include <vector>
#include <unordered_map>
#include <functional>
 
 
namespace SG {
 
 
class AuxTypeRegistry
{
public:
  // Now in AuxTypes.h to avoid cyclic header dependencies.
  using Flags = SG::AuxVarFlags;
 
 
  static AuxTypeRegistry& instance();
 
 
  size_t numVariables() const;
 
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  SG::auxid_t getAuxID (const std::string& name,
                        const std::string& clsname = "",
                        const Flags flags = Flags::None);
 
 
  SG::auxid_t getAuxID (const std::type_info& ti,
                        const std::string& name,
                        const std::string& clsname = "",
                        const Flags flags = Flags::None);
 
 
  SG::auxid_t getAuxID (const std::type_info& ti_alloc,
                        const std::type_info& ti,
                        const std::string& name,
                        const std::string& clsname = "",
                        const Flags flags = Flags::None);
 
 
  SG::auxid_t getAuxID (const std::string& alloc_type,
                        const std::type_info& ti,
                        const std::string& name,
                        const std::string& clsname = "",
                        const Flags flags = Flags::None);
 
 
  SG::auxid_t findAuxID( const std::string& name,
                         const std::string& clsname = "") const;
 
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  void checkAuxID (const SG::auxid_t auxid,
                   const Flags flags = Flags::None);
 
 
  void checkAuxID (const SG::auxid_t auxid,
                   const std::type_info& ti,
                   const std::type_info& ti_alloc,
                   const Flags flags);
 
 
  std::unique_ptr<IAuxTypeVector> makeVector (SG::auxid_t auxid,
                                              size_t size,
                                              size_t capacity) const;
 
 
  std::unique_ptr<IAuxTypeVector> makeVectorFromData (SG::auxid_t auxid,
                                                      void* data,
                                                      bool isPacked,
                                                      bool ownFlag) const;
 
 
  std::string getName (SG::auxid_t auxid) const;
 
 
  std::string getClassName (SG::auxid_t auxid) const;
 
 
  const std::type_info* getType (SG::auxid_t auxid) const;
 
 
  std::string getTypeName (SG::auxid_t auxid) const;
 
 
  const std::type_info* getVecType (SG::auxid_t auxid) const;
 
 
  std::string getVecTypeName (SG::auxid_t auxid) const;
 
 
  const std::type_info* getAllocType (SG::auxid_t auxid) const;
 
 
  size_t getEltSize (SG::auxid_t auxid) const;
 
 
  Flags getFlags (SG::auxid_t auxid) const;
 
 
  void copy (SG::auxid_t auxid,
             AuxVectorData& dst,       size_t dst_index,
             const AuxVectorData& src, size_t src_index,
             size_t n) const;
 
 
  void copy (SG::auxid_t auxid,
             AuxVectorData&& dst,      size_t dst_index,
             const AuxVectorData& src, size_t src_index,
             size_t n) const;
 
 
  void copyForOutput (SG::auxid_t auxid,
                      AuxVectorData& dst,       size_t dst_index,
                      const AuxVectorData& src, size_t src_index,
                      size_t n) const;
 
 
  void swap (SG::auxid_t auxid,
             AuxVectorData& a, size_t aindex,
             AuxVectorData& b, size_t bindex,
             size_t n) const;
 
 
  void clear (SG::auxid_t auxid,
              AuxVectorData& dst, size_t dst_index,
              size_t n) const;
 
 
  const IAuxTypeVectorFactory* getFactory (const std::type_info& ti,
                                           const std::type_info& ti_alloc);
 
 
  const IAuxTypeVectorFactory* getFactory (const std::type_info& ti,
                                           const std::string& alloc_name);
 
 
  const IAuxTypeVectorFactory* getFactory (SG::auxid_t auxid) const;
 
 
  const IAuxTypeVectorFactory*
  addFactory (const std::type_info& ti,
              const std::type_info& ti_alloc,
              std::unique_ptr<const IAuxTypeVectorFactory> factory);
  
 
  const IAuxTypeVectorFactory*
  addFactory (const std::type_info& ti,
              const std::string& ti_alloc_name,
              std::unique_ptr<const IAuxTypeVectorFactory> factory);
 
 
#ifndef XAOD_STANDALONE
 
  void setInputRenameMap (const Athena::IInputRename::InputRenameMap_t* map,
                          const IStringPool& pool);
#endif
 
 
  const std::string& inputRename (const std::string& key,
                                  const std::string& name) const;
 
 
private:
  typedef AthContainers_detail::mutex mutex_t;
  typedef AthContainers_detail::lock_guard<mutex_t> lock_t;
 
  AuxTypeRegistry();
 
 
  ~AuxTypeRegistry();
 
 
  AuxTypeRegistry (const AuxTypeRegistry&);
  AuxTypeRegistry& operator= (const AuxTypeRegistry&);
 
 
  SG::auxid_t
  findAuxID (const std::string& name,
             const std::string& clsname,
             const Flags flags,
             const std::type_info& ti,
             const std::type_info* ti_alloc,
             const std::string* alloc_name,
             std::unique_ptr<IAuxTypeVectorFactory> (AuxTypeRegistry::*makeFactory) () const);
 
 
  const IAuxTypeVectorFactory*
  addFactory (lock_t& lock,
              const std::type_info& ti,
              const std::type_info& ti_alloc,
              const IAuxTypeVectorFactory* factory);
 
 
  const IAuxTypeVectorFactory*
  addFactory (lock_t& /*lock*/,
              const std::type_info& ti,
              const std::string& ti_alloc_name,
              std::unique_ptr<const IAuxTypeVectorFactory> factory);
 
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  std::unique_ptr<IAuxTypeVectorFactory> makeFactory() const;
 
 
  std::unique_ptr<IAuxTypeVectorFactory> makeFactoryNull() const;
 
 
  static std::string makeKey (const std::string& name,
                              const std::string& clsname);
 
 
  static bool checkName (const std::string& s);
 
 
  const IAuxTypeVectorFactory*  getFactory (lock_t& lock,
                                            const std::type_info& ti,
                                            const std::type_info& ti_alloc);
 
 
  struct typeinfo_t
  {
    AthContainers_detail::atomic<const IAuxTypeVectorFactory*> m_factory;
 
    const std::type_info* m_ti;
 
    const std::type_info* m_ti_alloc;
 
    std::string m_alloc_name;
 
    std::string m_name;
 
    std::string m_clsname;
 
    Flags m_flags;
 
    bool checkAlloc (const std::type_info* ti_alloc,
                     const std::string* alloc_name) const;
  };
 
 
  // A concurrent vector, so we don't need to take a lock to read it.
  AthContainers_detail::concurrent_vector<typeinfo_t> m_types;
 
 
  using id_map_t = CxxUtils::ConcurrentStrMap<SG::auxid_t, CxxUtils::SimpleUpdater>;
  id_map_t m_auxids;
 
  using ti_map_t = CxxUtils::ConcurrentStrMap<const IAuxTypeVectorFactory*, CxxUtils::SimpleUpdater>;
  ti_map_t m_factories;
 
  std::vector<const IAuxTypeVectorFactory*> m_oldFactories;
 
  typedef std::unordered_map<std::string, std::string> renameMap_t;
  renameMap_t m_renameMap;
 
  // We originally used an upgrading mutex here.
  // But that's relatively slow, and most of the locked sections are short,
  // so it's not really a win.
  // This guards write access to all members, and read access to all members
  // except for m_types.
  mutable mutex_t m_mutex;
 
  // Map from the TI name for T to the TI for AuxAllocator_t<T>.
  // Filled in by addFactory().  Used in findAuxID() if the allocator
  // type is not specified.
  using allocMap_t = CxxUtils::ConcurrentStrMap<const std::type_info*, CxxUtils::SimpleUpdater>;
  allocMap_t m_allocMap;
};
 
 
} // namespace SG
 
 
#include "AthContainers/AuxTypeRegistry.icc"
 
 
#endif // not ATHCONTAINERS_AUXTYPEREGISTRY_H