PackedLinkVectorFactory.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_PACKEDLINKVECTORFACTORY_H
#define ATHCONTAINERS_PACKEDLINKVECTORFACTORY_H
 
 
#include "AthContainers/tools/PackedLinkVector.h"
#include "AthContainers/tools/AuxTypeVectorFactory.h"
#include "AthLinks/DataLink.h"
 
 
namespace SG {
 

template <class CONT, class ALLOC = AuxAllocator_t<PackedLink<CONT> > >
class PackedLinkVectorFactory
  : public AuxTypeVectorFactoryImpl<PackedLink<CONT>, ALLOC>
{
public:
  using Base = AuxTypeVectorFactoryImpl<PackedLink<CONT>, ALLOC>;
  using AuxTypeVector_t = PackedLinkVector<CONT, ALLOC>;
  using Helper = detail::PackedLinkVectorHelper<CONT>;
  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;
};
 

template <class CONT, class ALLOC>
class AuxTypeVectorFactory<PackedLink<CONT>, ALLOC>
  : public PackedLinkVectorFactory<CONT, ALLOC>
{
  using Base = PackedLinkVectorFactory<CONT, ALLOC>;
  using AuxTypeVector_t = typename Base::AuxTypeVector_t;
  using vector_value_type = typename Base::vector_value_type;
  using Base::Base;
};
 
 
//**************************************************************************
 

template <class CONT,
          class VALLOC = AuxAllocator_t<PackedLink<CONT> >,
          class VELT = typename AuxDataTraits<PackedLink<CONT>, VALLOC >::vector_type,
          class ALLOC = AuxAllocator_t<VELT> >
class PackedLinkVVectorFactory
  : public AuxTypeVectorFactoryImpl<VELT, ALLOC>
{
public:
  using Base = AuxTypeVectorFactoryImpl<VELT, ALLOC>;
  using AuxTypeVector_t = PackedLinkVVector<CONT, VALLOC, VELT, ALLOC>;
  using Helper = detail::PackedLinkVectorHelper<CONT>;
  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;
};
 

template <class CONT, class VALLOC, class ALLOC>
class AuxTypeVectorFactory<std::vector<PackedLink<CONT>, VALLOC>, ALLOC>
  : public PackedLinkVVectorFactory<CONT, VALLOC, std::vector<PackedLink<CONT>, VALLOC>, ALLOC>
{
  using Base = PackedLinkVVectorFactory<CONT, VALLOC, std::vector<PackedLink<CONT>, VALLOC>, 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/PackedLinkVectorFactory.icc"
 
 
#endif // not ATHCONTAINERS_PACKEDLINKVECTORFACTORY_H