AuxVectorData.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-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef ATHCONTAINERS_AUXVECTORDATA_H
#define ATHCONTAINERS_AUXVECTORDATA_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainersInterfaces/AuxDataOption.h"
#include "AthContainersInterfaces/AuxDataSpan.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthLinks/DataLink.h"
#include "SGCore/ILockable.h"
 
#include <vector>
#include <utility>
#include <cstdlib>
 
#include "AthContainers/tools/likely.h"
#include "AthContainers/tools/assume.h"
#include "AthContainers/tools/threading.h"
#include "CxxUtils/checker_macros.h"
 
 
namespace SG {
 
 
class AuxElement;
class IAuxStore;
class AuxDataOption;
 

class AuxVectorData : public ILockable
{
public:
  AuxVectorData();
 

  AuxVectorData (AuxVectorData&& rhs);
 

  AuxVectorData& operator= (AuxVectorData&& rhs);
 

  virtual ~AuxVectorData();
 

  virtual size_t size_v() const = 0;
 

  virtual size_t capacity_v() const = 0;
 
 
  //========================================================================
 

  const SG::IConstAuxStore* getConstStore() const;
 

  const DataLink<SG::IConstAuxStore> getConstStoreLink() const;
 

  SG::IAuxStore* getStore();
 

  const SG::IAuxStore* getStore() const;
 

  bool hasStore() const;
 

  bool hasNonConstStore() const;
 

  bool setOption (auxid_t id, const AuxDataOption& option);
 

  bool setOption (const std::string& name,
                  const AuxDataOption& option);
 

  bool setOption (const std::string& name,
                  const std::string& clsname,
                  const AuxDataOption& option);
 

  template <class T>
  bool setOption (auxid_t id, const std::string& optname, T arg);
 

  bool setOption (const std::string& name,
                  const std::string& optname,
                  int arg);
  bool setOption (const std::string& name,
                  const std::string& optname,
                  float arg);
  bool setOption (const std::string& name,
                  const std::string& optname,
                  double arg);
 

  template <class T>
  bool setOption (const std::string& name,
                  const std::string& clsname,
                  const std::string& optname,
                  T arg);
 
 
 
protected:
  // These are protected.  They shouldn't be called directly but
  // instead from @c setStore methods in derived classes, which do
  // extra consistency checking.
 

  void setStore (SG::IAuxStore* store);
 

  void setStore (const SG::IConstAuxStore* store);
 

  void setStore (const DataLink< SG::IConstAuxStore >& store);
 

  void setNonConstStore (SG::IAuxStore* store);
 

  //========================================================================
public:
 

  const SG::auxid_set_t& getAuxIDs() const;
 

  const SG::auxid_set_t& getDecorIDs() const;
 

  const SG::auxid_set_t& getWritableAuxIDs() const;
 

  bool isAvailable (auxid_t id) const;
 

  bool isAvailableWritable (auxid_t id);
 

  bool isAvailableWritableAsDecoration (auxid_t id) const;
 
 
  // Versions of isAvailable* that take a name rather than an ID are
  // in the derived class AuxVectorBase.
 

  template <class T>
  typename AuxDataTraits<T>::reference_type
  getData (SG::auxid_t auxid, size_t ndx);
 

  template <class T>
  typename AuxDataTraits<T>::const_reference_type
  getData (SG::auxid_t auxid, size_t ndx) const;
 

  template <class T>
  typename AuxDataTraits<T>::reference_type
  getDecoration (SG::auxid_t auxid, size_t ndx) const;
 

  const void* getDataArray (SG::auxid_t auxid) const;
 

  const void* getDataArrayAllowMissing (SG::auxid_t auxid) const;
 

  void* getDecorationArray (SG::auxid_t auxid) const;
 

  void* getDataArray (SG::auxid_t auxid);
 

  const AuxDataSpanBase* getDataSpan (SG::auxid_t auxid) const;
 
 
protected:
  static size_t s_minCacheLen ATLAS_THREAD_SAFE;
 

  //========================================================================
public:
 

  void swap (AuxVectorData& other);
 

  void clearCache();
 

  void clearCache (SG::auxid_t auxid);
 

  void clearDecorCache (SG::auxid_t auxid);
 

#ifndef XAOD_STANDALONE
  virtual
#endif // not XAOD_STANDALONE
          void lock()
#ifndef XAOD_STANDALONE
                      override
#endif // not XAOD_STANDALONE
     ;
 

  bool clearDecorations() const;
 

  void lockDecoration (SG::auxid_t auxid);
 

  const SG::IConstAuxStore* getConstStoreOol() const;
 
 
protected:
  void setCache (SG::auxid_t auxid, void* ptr);
 

  void setCache (SG::auxid_t auxid, const void* ptr);
 

 
 
 
public:
  class Cache
  {
  public:
    Cache();
 

    Cache (Cache&& rhs);
 

    Cache& operator= (Cache&& rhs);
 

    ~Cache();
 

    void* cachePtr (SG::auxid_t auxid);
 

    void* getDataArray (SG::auxid_t auxid, AuxVectorData& parent);
 

    const void* getDataArray (SG::auxid_t auxid, const AuxVectorData& parent);
 

    const void* getDataArrayAllowMissing (SG::auxid_t auxid,
                                          const AuxVectorData& parent);
 

    void* getDecorationArray (SG::auxid_t auxid, const AuxVectorData& parent);
 

    const AuxDataSpanBase* getDataSpan (SG::auxid_t auxid,
                                        const AuxVectorData& parent);
 

    void swap (Cache& other);
 

    void clear();
 

    void clear (SG::auxid_t auxid);
 

    void store (SG::auxid_t auxid, void* ptr);
 

    void** m_cache[2];

    size_t m_cache_len;

    // See the thread-safety discussion in the file header above.
    // Could be a vector of unique_ptr, but we want to avoid
    // relying on c++11 for now.
    std::vector<void**> m_allcache;
 
 
  private:
    Cache (const Cache&);
    Cache& operator= (const Cache&);
  };
 
  friend class Cache;
 
 
private:
  AuxVectorData (const AuxVectorData&);
  AuxVectorData& operator= (const AuxVectorData&);
 
  // Needed for access to getDataArray
  friend class SG::AuxElement;
 

  bool isAvailableOol (auxid_t id) const;
 

  bool isAvailableWritableOol (auxid_t id);
 

  bool isAvailableWritableAsDecorationOol (auxid_t id) const;
 

  void* getDataOol (SG::auxid_t auxid, bool allowMissing);
 

  const void* getDataOol (SG::auxid_t auxid, bool allowMissing) const;
 

  void* getDecorationOol (SG::auxid_t auxid) const;
 

  const AuxDataSpanBase* getDataSpanOol (SG::auxid_t
                                         auxid, bool allowMissing) const /*__attribute__((const))*/;
 

  mutable Cache m_cache ATLAS_THREAD_SAFE;

  mutable Cache m_constCache ATLAS_THREAD_SAFE;

  mutable Cache m_decorCache ATLAS_THREAD_SAFE;

  mutable Cache m_spanCache ATLAS_THREAD_SAFE;
 

  SG::IAuxStore* m_store;
 

  const SG::IConstAuxStore* m_constStore;
 

  DataLink< SG::IConstAuxStore > m_constStoreLink;
 

  typedef AthContainers_detail::mutex mutex_t;
  typedef AthContainers_detail::lock_guard<mutex_t> guard_t;
  mutable mutex_t m_mutex;

  static const SG::auxid_set_t s_emptySet;
};
 
 
} // namespace SG
 
 
#include "AthContainers/AuxVectorData.icc"
 
 
#endif // not ATHCONTAINERS_AUXVECTORDATA_H