DVLInfo.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-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_TOOLS_DVLINFO_H
#define ATHCONTAINERS_TOOLS_DVLINFO_H
 
 
#include "AthContainers/tools/ClassID.h"
#include "AthContainers/AuxVectorBase.h"
#include <typeinfo>
#include <cstddef>
#include <type_traits>
 
 
 
namespace DataModel_detail {
 
 
class DVLIteratorBase
{
public:
  virtual ~DVLIteratorBase() {}
 
 
  virtual const void* next() = 0;
};
 
 
/*
 * @brief Holder to implement conversion copies for @c DataVector/@c DataList.
 *
 * In some cases, we want to convert @c DataVector<A> to @c DataVector<B>,
 * where the two @c DataVector classes are not related by inheritance,
 * but where @c A and @c B are.  In such a case, we can make a new view
 * container for @c DataVector<B> and fill it with the pointers
 * from @c DataVector<A> (suitably converted).  In order for this
 * to work with the conversion machinery in SGTools, we must be able
 * to do this given only the @c type_info for @c DataVector<B>.
 * Thus, we build a registry of @c DVLInfo objects, indexed
 * by the @c type_info; the @c DVLInfo objects have virtual methods
 * to build the new container and to fill it.  (Everything said here
 * for @c DataVector also applies to @c DataList.)
 *
 * Note: these objects should only be allocated statically.
 */
class DVLInfoBase
{
public:
  DVLInfoBase (const std::type_info& tinfo,
               const std::type_info& elt_tinfo);
 
 
  virtual ~DVLInfoBase() {}
 
 
  const std::type_info& tinfo() const;
 
 
  CLID clid() const;
 
 
  const std::type_info& elt_tinfo() const;
 
 
  virtual void* make (size_t nreserve) const = 0;
 
 
  virtual void push (void* cont_p, void* elt_p) const = 0;
 
 
  virtual size_t size (void* cont_p) const = 0;
 
 
  virtual void clear (void* cont_p) const = 0;
 
 
  virtual void del (void* cont_p) const = 0;
 
 
  virtual void* clone (void* cont_p) const = 0;
 
 
  virtual DVLIteratorBase* iterator (const void* cont_p) const = 0;
 
 
  virtual SG::AuxVectorBase* base (void* cont_p) const = 0;
 
 
  static DVLInfoBase* find (const std::type_info& tinfo);
 
 
  static DVLInfoBase* find (CLID clid);
 
 
private:
  const std::type_info& m_tinfo;
 
  const std::type_info& m_elt_tinfo;
};
 
 
template <class T>
class DVLIterator
  : public DVLIteratorBase
{
public:
  typedef typename T::const_iterator base_iterator;
 
 
  DVLIterator (const base_iterator& beg, const base_iterator& end);
 
 
   virtual const void* next() override;
 
 
private:
  typename T::const_iterator m_it;
  typename T::const_iterator m_end;
};
 
 
/*
 * @brief Per-container @c DVLInfo.
 *
 * One instance of this class is instantiated for each
 * @c DataVector/@c DataList class.
 */
template <class T>
class DVLInfo
  : public DVLInfoBase
{
public:
  typedef T Container;
 
  typedef typename std::remove_const<typename Container::base_value_type>::type Elt;
 
 
  DVLInfo();
 
 
  virtual void* make (size_t nreserve) const override;
 
 
  virtual void push (void* cont_p, void* elt_p) const override;
 
 
  virtual size_t size (void* cont_p) const override;
 
 
  virtual void clear (void* cont_p) const override;
 
 
  virtual void del (void* cont_p) const override;
 
 
  virtual void* clone (void* cont_p) const override;
 
 
  virtual DVLIteratorBase* iterator (const void* cont_p) const override;
 
 
  virtual SG::AuxVectorBase* base (void* cont_p) const override;
 
 
  static const std::type_info* initHelper();
};
 
 
template <class T>
void* dvl_convert (const T& src,
                   const DVLInfoBase& targ_info);
 
 
template <class T>
void* dvl_convert (const T& src,
                   const std::type_info& targ_tinfo,
                   DVLInfoBase*& targ_info);
 
 
template <class T>
void* dvl_convert (const T& src,
                   CLID clid,
                   DVLInfoBase*& targ_info);
 
 
template <class T>
void dvl_update (const T& src,
                 void* target,
                 const DVLInfoBase* targ_info);
 
 
 
} // namespace DataModel_detail
 
 
#include "AthContainers/tools/DVLInfo.icc"
 
 
#endif // not ATHCONTAINERS_TOOLS_DVLINFO_H