JaggedVecVector.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_JAGGEDVECVECTOR_H
#define ATHCONTAINERS_JAGGEDVECVECTOR_H
 
 
#include "AthContainers/tools/AuxTypeVector.h"
#include "AthContainers/JaggedVecImpl.h"
#include "AthContainers/AuxVectorData.h"
 
 
namespace SG {
 
 
//**************************************************************************
 

template <class T, class ALLOC = AuxAllocator_t<JaggedVecElt<T> > >
class JaggedVecVectorHolder
  : public AuxTypeVectorHolder<JaggedVecElt<T>,
                               typename AuxDataTraits<JaggedVecElt<T>, ALLOC>::vector_type>
{
  using Elt = JaggedVecElt<T>;
  using Shift = typename Elt::Shift;
  using index_type = typename Elt::index_type;
  using Base = AuxTypeVectorHolder<Elt,
                                   typename AuxDataTraits<Elt, ALLOC>::vector_type>;
 
 
public:
  using Base::Base;
  using vector_type = typename Base::vector_type;
  using element_type = typename Base::element_type;
 

  JaggedVecVectorHolder (auxid_t auxid,
                         vector_type* vecPtr,
                         IAuxTypeVector* linkedVec,
                         bool ownFlag);
 

  virtual bool resize (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,
                           IAuxStore& srcStore) override;
 
 
protected:
  IAuxTypeVector* m_linkedVec{};
};
 
 
//**************************************************************************
 

template <class HOLDER>
class JaggedVecVectorT
  : public HOLDER
{
public:
  using Base = HOLDER;
  using vector_type = typename Base::vector_type;
  using element_type = typename Base::element_type;
  using vector_value_type = typename Base::vector_value_type;
 

  JaggedVecVectorT (auxid_t auxid,
                     size_t size, size_t capacity,
                     std::unique_ptr<IAuxTypeVector> linkedVec);
 

  JaggedVecVectorT (const JaggedVecVectorT& other);
 

  JaggedVecVectorT (JaggedVecVectorT&& other);
 

  JaggedVecVectorT& operator= (const JaggedVecVectorT& other) = delete;
  JaggedVecVectorT& operator= (JaggedVecVectorT&& other) = delete;
 

  virtual std::unique_ptr<IAuxTypeVector> clone() const override;
 

  virtual std::unique_ptr<IAuxTypeVector> linkedVector() override;
 
  
private:
  vector_type m_vec;

  std::unique_ptr<IAuxTypeVector> m_linkedVecHolder;
};
 
 
//**************************************************************************
 
 
template <class T, class ALLOC = AuxAllocator_t<JaggedVecElt<T> > >
using JaggedVecVector = JaggedVecVectorT<JaggedVecVectorHolder<T, ALLOC> >;
 
 
} // namespace SG
 
 
#include "AthContainers/tools/JaggedVecVector.icc"
 
 
#endif // not ATHCONTAINERS_JAGGEDVECVECTOR_H