/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthContainers/AthContainers/tools/DVLInfo.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: DVLInfo.h,v 1.2 2008-06-17 00:44:17 ssnyder Exp $

#ifndef ATHCONTAINERS_TOOLS_DVLINFO_H
#define ATHCONTAINERS_TOOLS_DVLINFO_H


#include "AthContainers/tools/ClassID.h"
#include "AthContainers/AuxVectorBase.h"
#include <typeinfo>
#include <cstddef>


#if __cplusplus > 201100
# include <type_traits>
namespace SG_STD_OR_BOOST = std;
#else
# include "boost/type_traits/remove_const.hpp"
# include "boost/type_traits/is_pointer.hpp"
# include "boost/type_traits/is_base_of.hpp"
namespace SG_STD_OR_BOOST = boost;
#endif



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;
};


/*
 * @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
    SG_STD_OR_BOOST::remove_const<typename Container::base_value_type>::type
    Elt;


  DVLInfo();


  virtual void* make (size_t nreserve) const;


  virtual void push (void* cont_p, void* elt_p) const;


  virtual size_t size (void* cont_p) const;


  virtual void clear (void* cont_p) const;


  virtual void del (void* cont_p) const;


  virtual void* clone (void* cont_p) const;


  virtual DVLIteratorBase* iterator (const void* cont_p) const;


  virtual SG::AuxVectorBase* base (void* cont_p) const;


  static const std::type_info* initHelper();
};


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();


private:
  typename T::const_iterator m_it;
  typename T::const_iterator m_end;
};


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

---