JaggedVecVectorFactory.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_JAGGEDVECVECTORFACTORY_H
#define ATHCONTAINERS_JAGGEDVECVECTORFACTORY_H
 
 
#include "AthContainers/tools/JaggedVecVector.h"
#include "AthContainers/tools/AuxTypeVectorFactory.h"
 
 
namespace SG {
 

template <class T, class ALLOC = AuxAllocator_t<JaggedVecElt<T> > >
class JaggedVecVectorFactory
  : public AuxTypeVectorFactoryImpl<JaggedVecElt<T>, ALLOC>
{
public:
  using Elt = JaggedVecElt<T>;
  using Shift = typename Elt::Shift;
  using index_type = typename Elt::index_type;
 
  using Base = AuxTypeVectorFactoryImpl<Elt, ALLOC>;
  using AuxTypeVector_t = JaggedVecVector<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;
 
 
private:
  void copyImpl (SG::auxid_t auxid,
                 AuxVectorData& dst,        size_t dst_index,
                 const AuxVectorData& src,  size_t src_index,
                 size_t n,                  bool for_output) const;
};
 
 

template <class T, class ALLOC>
class AuxTypeVectorFactory<JaggedVecElt<T>, ALLOC>
  : public JaggedVecVectorFactory<T, ALLOC>
{
  using Base = JaggedVecVectorFactory<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/JaggedVecVectorFactory.icc"
 
 
#endif // not ATHCONTAINERS_JAGGEDVECVECTORFACTORY_H