AuxTypeVectorFactory.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
*/
#include "AthContainersInterfaces/IAuxTypeVectorFactory.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxTypeVector.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/normalizedTypeinfoName.h"
 
 
#ifndef ATHCONTAINERS_AUXTYPEVECTORFACTORY_H
#define ATHCONTAINERS_AUXTYPEVECTORFACTORY_H
 
 
namespace SG {
 
 
template <class T, class ALLOC = AuxAllocator_t<T> >
class AuxTypeVectorFactoryImpl
  : public IAuxTypeVectorFactory
{
public:
  using AuxTypeVector_t = AuxTypeVector<T, ALLOC>;
 
  using vector_value_type = typename AuxTypeVector_t::vector_value_type;
 
  virtual
  std::unique_ptr<IAuxTypeVector> create (SG::auxid_t auxid,
                                          size_t size,
                                          size_t capacity,
                                          bool isLinked) const override;
 
 
  virtual
  std::unique_ptr<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:
  vector_value_type* copyImpl (SG::auxid_t auxid,
                               AuxVectorData& dst,        size_t dst_index,
                               const AuxVectorData& src,  size_t src_index,
                               size_t n) const;
 
  std::unique_ptr<IAuxTypeVector>
  createFromData (auxid_t auxid, void* data, bool isPacked, bool ownFlag,
                  bool isLinked,
                  std::true_type) const;
 
  std::unique_ptr<IAuxTypeVector>
  createFromData (auxid_t auxid, void* data, bool isPacked, bool ownFlag,
                  bool isLinked,
                  std::false_type) const;
};
 
 
 
template <class T, class ALLOC = AuxAllocator_t<T> >
class AuxTypeVectorFactory
  : public AuxTypeVectorFactoryImpl<T, ALLOC>
{
  using Base = AuxTypeVectorFactoryImpl<T, ALLOC>;
  using AuxTypeVector_t = typename Base::AuxTypeVector_t;
  using vector_value_type = typename Base::vector_value_type;
  using Base::Base;
};
 
 
} // namespace SG
 
 
#include "AthContainers/tools/AuxTypeVectorFactory.icc"
 
 
#endif // not ATHCONTAINERS_AUXTYPEVECTORFACTORY_H