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-2024 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"
#ifndef XAOD_STANDALONE
#   include "AthenaKernel/ILockable.h"
#endif // not XAOD_STANDALONE
#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
#ifndef XAOD_STANDALONE
  : public ILockable
#endif // not XAOD_STANDALONE
{
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);
 
 
 
 
 
private:
  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;
  
 
  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