RootAuxVectorFactory.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 ATHCONTAINERSROOT_ROOTAUXVECTORFACTORY_H
#define ATHCONTAINERSROOT_ROOTAUXVECTORFACTORY_H
 
 
#include "AthContainersInterfaces/IAuxTypeVectorFactory.h"
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "RootUtils/Type.h"
#include "CxxUtils/checker_macros.h"
 
 
class TClass;
class TVirtualCollectionProxy;
 
 
namespace SG {
 
 
class RootAuxVectorFactory;
 
 
class RootAuxVector
  : public SG::IAuxTypeVector
{
public:
  RootAuxVector (const RootAuxVectorFactory* factory,
                 SG::auxid_t auxid,
                 size_t size,
                 size_t capacity,
                 bool isLinked);
 
 
  RootAuxVector (const RootAuxVectorFactory* factory,
                 SG::auxid_t auxid,
                 void* data,
                 bool isPacked,
                 bool ownFlag,
                 bool isLinked);
 
 
  RootAuxVector (const RootAuxVector& other);
 
 
  // Disallow assignment.
  RootAuxVector& operator= (const RootAuxVector&) = delete;
 
 
  virtual ~RootAuxVector() override;
 
 
  virtual std::unique_ptr<SG::IAuxTypeVector> clone() const override;
 
 
  virtual void* toPtr() override;
 
 
  virtual const void* toPtr() const override;
 
 
  virtual void* toVector() override;
 
 
 
  virtual size_t size() const override;
 
 
  virtual bool resize (size_t sz) override;
 
 
  virtual void reserve (size_t sz) override;
 
 
  virtual bool shift (size_t pos, ptrdiff_t offs) override;
 
 
  virtual bool insertMove (size_t pos,
                           void* src, size_t src_pos, size_t src_n,
                           SG::IAuxStore& srcStore) override;
 
 
  virtual const std::type_info* objType() const override;
 
 
protected:
  virtual AuxDataSpanBase getDataSpanImpl() const override final;
 
 
private:
  void storeDataSpan();
 
 
  const RootAuxVectorFactory* m_factory;
 
  std::unique_ptr<TVirtualCollectionProxy> m_proxy;
 
  void* m_obj;
 
  void* m_vec;
 
  bool m_ownFlag;
};
 
 
class RootAuxVectorFactory
  : public SG::IAuxTypeVectorFactory
{
public:
  RootAuxVectorFactory (TClass* objClass);
 
 
  virtual ~RootAuxVectorFactory() override;
 
 
  const RootUtils::Type& rootType() const { return m_type; }
 
 
  TClass* objClass ATLAS_NOT_CONST_THREAD_SAFE () const { return m_objClass; }
 
 
  TClass* vecClass ATLAS_NOT_CONST_THREAD_SAFE () const { return m_vecClass; }
 
 
  size_t offset() const { return m_offset; }
 
 
  virtual
  std::unique_ptr<SG::IAuxTypeVector> create (SG::auxid_t auxid,
                                              size_t size,
                                              size_t capacity,
                                              bool isLinked) const
    override;
 
 
  virtual std::unique_ptr<SG::IAuxTypeVector> createFromData (SG::auxid_t auxid,
                                                              void* data,
                                                              IAuxTypeVector* linkedVector,
                                                              bool isPacked,
                                                              bool ownFlag,
                                                              bool isLinked) const
    override;
 
 
  virtual void copy (SG::auxid_t auxid,
                     AuxVectorData& dst,        size_t dst_index,
                     const AuxVectorData& src,  size_t src_index,
                     size_t n) const override;
 
 
  virtual void copyForOutput (SG::auxid_t auxid,
                              AuxVectorData& dst,        size_t dst_index,
                              const AuxVectorData& src,  size_t src_index,
                              size_t n) const override;
 
 
  virtual void swap (SG::auxid_t auxid,
                     AuxVectorData& a, size_t aindex,
                     AuxVectorData& b, size_t bindex,
                     size_t n) const override;
 
 
  virtual void clear (SG::auxid_t auxid,
                      AuxVectorData& dst, size_t dst_index,
                      size_t n) const override;
 
 
  virtual size_t getEltSize() const override;
 
 
  virtual const std::type_info* tiVec() const override;
 
 
  virtual bool isDynamic() const override;
 
 
  virtual const std::type_info* tiAlloc() const override;
 
 
  virtual std::string tiAllocName() const override;
 
 
private:
  char* copyImpl (SG::auxid_t auxid,
                  AuxVectorData& dst,        size_t dst_index,
                  const AuxVectorData& src,  size_t src_index,
                  size_t n) const;
 
 
  TClass* m_objClass;
 
  TClass* m_vecClass;
 
  size_t m_offset;
 
  RootUtils::Type m_type;
 
  enum { NONE, ELEMENT_LINK, ELEMENT_LINK_VECTOR, ELEMENT_LINK_NONPOINTER} m_isEL;
};
 
 
} // namespace SG
 
 
#endif // not ATHCONTAINERSROOT_ROOTAUXVECTORFACTORY_H