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-2026 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;
 

  virtual void toTransient (const EventContext& ctx) 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;
 

  void toTransient (const EventContext& ctx, RootAuxVector& vec) const;
 
 
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,
         DATA_LINK,    DATA_LINK_VECTOR,
  } m_isEL;
};
 
 
} // namespace SG
 
 
#endif // not ATHCONTAINERSROOT_ROOTAUXVECTORFACTORY_H