/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthContainers/AthContainers/AuxVectorData.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: AuxVectorData.h 676542 2015-06-19 02:49:50Z ssnyder $
#ifndef ATHCONTAINERS_AUXVECTORDATA_H
#define ATHCONTAINERS_AUXVECTORDATA_H


#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainersInterfaces/AuxDataOption.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthLinks/DataLink.h"
#ifndef XAOD_STANDALONE
#   include "AthenaKernel/ILockable.h"
#   include "AthenaKernel/IThinningSvc.h"
#endif // not XAOD_STANDALONE
#include "CxxUtils/override.h"
#include <vector>
#include <utility>
#include <cstdlib>

#include "AthContainers/tools/likely.h"
#include "AthContainers/tools/assume.h"
#include "AthContainers/tools/threading.h"


namespace SG {


class AuxElement;
class IAuxStore;
class AuxDataOption;


class AuxVectorData
#ifndef XAOD_STANDALONE
  : public ILockable
#endif // not XAOD_STANDALONE
{
public:
  AuxVectorData();


#if __cplusplus > 201100

  AuxVectorData (AuxVectorData&& rhs);


  AuxVectorData& operator= (AuxVectorData&& rhs);
#endif


  virtual ~AuxVectorData();


  virtual size_t size_v() const = 0;


  virtual size_t capacity_v() const = 0;


  //========================================================================


  const SG::IConstAuxStore* getConstStore() 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 (const SG::IConstAuxStore* store);


  void setStore (SG::IAuxStore* store);


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


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


  const SG::auxid_set_t& getAuxIDs() const;


  const SG::auxid_set_t& getWritableAuxIDs() const;


  bool isAvailable (auxid_t id) const;


  template <class T>
  bool isAvailable (const std::string& name,
                    const std::string& clsname = "") const;


  bool isAvailableWritable (auxid_t id) const;


  template <class T>
  bool isAvailableWritable (const std::string& name,
                            const std::string& clsname = "") const;


  bool isAvailableWritableAsDecoration (auxid_t id) const;


  template <class T>
  bool isAvailableWritableAsDecoration (const std::string& name,
                                        const std::string& clsname = "") const;


  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;


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


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


  static size_t s_minCacheLen;


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


  void swap (AuxVectorData& other);


  void clearCache();


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


  void clearDecorations() const;





private:
  class Cache
  {
  public:
    Cache();


#if __cplusplus > 201100

    Cache (Cache&& rhs);


    Cache& operator= (Cache&& rhs);
#endif


    ~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);


    void swap (Cache& other);


    void clear();


    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) const;


  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;


  mutable Cache m_cache;

  mutable Cache m_constCache;

  mutable Cache m_decorCache;


  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 SG::auxid_set_t s_emptySet;
};


} // namespace SG


#ifndef XAOD_STANDALONE


StatusCode thinningHook (const SG::AuxVectorData* in,
                         IThinningSvc* svc,
                         const IThinningSvc::Filter_t& filter,
                         const IThinningSvc::Operator::Type op );
                         

#endif


#include "AthContainers/AuxVectorData.icc"


#endif // not ATHCONTAINERS_AUXVECTORDATA_H

---