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/AuxTypeVectorFactory.h"
#ifndef XAOD_STANDALONE
#include "AthenaKernel/InputRenameMap.h"
#include "AthenaKernel/IStringPool.h"
#endif
#include <cstddef>
#include <typeinfo>
#include <vector>
#include <unordered_map>
#include <functional>
 
 
namespace SG {
 
 
class AuxTypeRegistryImpl;
 

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,
                        const SG::auxid_t linkedVariable = SG::null_auxid);
 

  SG::auxid_t getAuxID (const std::type_info& ti,
                        const std::string& name,
                        const std::string& clsname = "",
                        const Flags flags = Flags::None,
                        const SG::auxid_t linkedVariable = SG::null_auxid);
 

  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,
                        const SG::auxid_t linkedVariable = SG::null_auxid,
                        std::unique_ptr<IAuxTypeVectorFactory> (AuxTypeRegistry::*makeFactory) () const = &AuxTypeRegistry::makeFactoryNull);
 

  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,
                        const SG::auxid_t linkedVariable = SG::null_auxid);
 

  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,
                                                      IAuxTypeVector* linkedVector,
                                                      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;
 

  bool isLinked (SG::auxid_t auxid) const;
 

  SG::auxid_t linkedVariable (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::InputRenameMap_t* map,
                          const IStringPool& pool);
#endif
 

  const std::string& inputRename (const std::string& key,
                                  const std::string& name) const;
 

  static bool isLinkedName (const std::string& name);
 

  static std::string linkedName (const std::string& name);
 

  static bool classNameHasLink (const std::string& className);
 
 
private:
  friend class AuxTypeRegistryImpl;
 
  typedef AthContainers_detail::mutex mutex_t;
  typedef AthContainers_detail::lock_guard<mutex_t> lock_t;

  AuxTypeRegistry();
 

  ~AuxTypeRegistry();
 

  AuxTypeRegistry (const AuxTypeRegistry&);
  AuxTypeRegistry& operator= (const AuxTypeRegistry&);
 

  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);
};
 
 
} // namespace SG
 
 
#include "AthContainers/AuxTypeRegistry.icc"
 
 
#endif // not ATHCONTAINERS_AUXTYPEREGISTRY_H