AuxTypeVector.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_AUXTYPEVECTOR_H
#define ATHCONTAINERS_AUXTYPEVECTOR_H
 
 
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "AthContainersInterfaces/IAuxSetOption.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/PackedContainer.h"
#include <typeinfo>
#include <vector>
#include <algorithm>
#include <utility>
#include <stdint.h>
#include <type_traits>
 
 
namespace SG {
 
 
class AuxDataOption;
 
 
template <class T, class CONT>
class AuxTypeVectorHolder
  : public IAuxTypeVector
{
public:
  typedef CONT vector_type;
 
  typedef typename AuxDataTraits<T>::element_type element_type;
 
  typedef typename vector_type::value_type vector_value_type;
 
  
protected:
  static const int SCALE = sizeof(element_type) / sizeof(vector_value_type);
 
 
public:
  AuxTypeVectorHolder (auxid_t auxid, vector_type* vecPtr, bool ownFlag,
                       bool isLinked);
 
 
  ~AuxTypeVectorHolder();
 
 
  AuxTypeVectorHolder (const AuxTypeVectorHolder& other);
    
 
  AuxTypeVectorHolder (AuxTypeVectorHolder&& other);
 
 
  AuxTypeVectorHolder& operator= (const AuxTypeVectorHolder& other);
    
 
  AuxTypeVectorHolder& operator= (AuxTypeVectorHolder&& other);
    
 
  vector_type& vec();
 
 
  virtual std::unique_ptr<IAuxTypeVector> clone() const override;
 
 
  virtual void* toPtr() override;
 
 
  virtual const void* toPtr() const override;
 
 
  virtual void* toVector() override;
 
 
  virtual const std::type_info* objType() const override;
 
 
  virtual size_t size() const override;
 
 
  virtual bool resize (size_t sz) override;
 
 
  virtual void reserve (size_t sz) override;
 
 
  virtual bool setOption (const AuxDataOption& option) override;
 
 
  virtual bool shift (size_t pos, ptrdiff_t offs) override;
 
  
  virtual bool insertMove (size_t pos, void* beg, void* end,
                           IAuxStore& srcStore) override;
 
 
  virtual std::unique_ptr<IAuxTypeVector> toPacked() override;
 
 
private:
  void insertMove1 (typename CONT::iterator pos,
                    element_type* beg,
                    element_type* end,
                    std::true_type);
 
 
  void insertMove1 (typename CONT::iterator pos,
                    element_type* beg,
                    element_type* end,
                    std::false_type);
 
  vector_type* m_vecPtr;
 
  bool m_ownFlag;
};
 
 
//**********************************************************************
 
 
template <class HOLDER>
class AuxTypeVectorT
  : 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;
 
 
  AuxTypeVectorT (auxid_t auxid, size_t size, size_t capacity,
                  bool isLinked);
 
 
 
  AuxTypeVectorT (const AuxTypeVectorT& other);
 
 
  AuxTypeVectorT (AuxTypeVectorT&& other);
 
 
  AuxTypeVectorT& operator= (const AuxTypeVectorT& other);
 
 
  AuxTypeVectorT& operator= (AuxTypeVectorT&& other);
 
 
  virtual std::unique_ptr<IAuxTypeVector> clone() const override;
 
  
private:
  vector_type m_vec;
};
 
 
template <class T,
          class ALLOC = AuxAllocator_t<T>,
          class CONT = typename AuxDataTraits<T, ALLOC>::vector_type>
using AuxTypeVector = AuxTypeVectorT<AuxTypeVectorHolder<T, CONT> >;
 
 
 
} // namespace SG
 
 
#include "AthContainers/tools/AuxTypeVector.icc"
 
 
#endif // not ATHCONTAINERS_AUXTYPEVECTOR_H