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

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: DataVector.h 676636 2015-06-19 12:07:12Z ssnyder $

#ifndef ATHCONTAINERS_DATAVECTOR_H
#define ATHCONTAINERS_DATAVECTOR_H


// For feature tests.
#define HAVE_CONSTDATAVECTOR


#include "AthContainers/exceptions.h"
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/IndexTrackingPolicy.h"
#include "AthContainers/AuxVectorBase.h"
#include "AthContainers/tools/DVLNoBase.h"
#include "AthContainers/tools/DVLInfo.h"
#include "AthContainers/tools/DVLCast.h"
#include "AthContainers/tools/DVLIterator.h"
#include "AthContainers/tools/DVL_iter_swap.h"
#include "AthContainers/tools/DVL_algorithms.h"
#include "AthContainers/tools/ElementProxy.h"
#include "AthContainers/tools/IsMostDerivedFlag.h"
#include "AthLinks/tools/selection_ns.h"
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <vector>
#include <typeinfo>
#include <functional>
#include <iostream>
#include <algorithm>
#include <stdexcept>
#include <iterator>
#if __cplusplus > 201100
#include <initializer_list>
#endif



#ifdef XAOD_STANDALONE
# ifndef SG_BASE
#  define SG_BASE(A, B) class ATHCONTAINERS_DUMMY
# endif // not SG_BASE
# ifndef SG_BASES1
#  define SG_BASES1(A, B) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES1
# ifndef SG_BASES2
#  define SG_BASES2(A, B, C) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES2
# ifndef SG_BASES3
#  define SG_BASES3(A, B, C, D) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES3
# ifndef SG_VIRTUAL
#  define SG_VIRTUAL(X) X
# endif // not SG_VIRTUAL
#else
# include "SGTools/BaseInfo.h"
#endif


// Forward declarations.
ENTER_ROOT_SELECTION_NS
template <class T, class BASE> class DataVector;
EXIT_ROOT_SELECTION_NS


namespace DataVector_detail {


// These are the intermediate classes from which @c DataVector derives
// in the case of multiple or virtual derivation.  The actual
// definitions are in the @c icc file.  They have the following
// properties:
//   - They derive from those of @c B1, @c B2, and @c B3 that are not
//     @c NoBase.
//   - They perform (static) checking to ensure that there's a unique
//     base class in the hierarchy.
//   - They make the following types available from the base classes:
//     - @c PtrVector
//     - @c BaseContainer
//     - @c size_type
//     - @c difference_type
//     - @c allocator_type
//   - @c has_virtual is defined as @c true.
//   - An override of @c dvlinfo_v is defined, to prevent ambiguities.
template <class B1,
          class B2=DataModel_detail::NoBase,
          class B3=DataModel_detail::NoBase> struct VirtBases;


} // namespace DataVector_detail



template <class T>
struct DataVectorBase
{
  typedef DataModel_detail::NoBase Base;
};


#define DATAVECTOR_BASE(T, BASE)          \
DATAVECTOR_BASE_FWD(T, BASE);             \
template struct DataVector_detail::DVLEltBaseInit<T>


#define DATAVECTOR_BASE_FWD(T, BASE)      \
template <> struct DataVectorBase<T>      \
{ typedef DataVector<BASE> Base; };       \
SG_BASE(DataVector<T>, DataVector<BASE>)


#define DATAVECTOR_VIRTBASES1(T, B1)                  \
DATAVECTOR_VIRTBASES1_FWD(T, B1);                     \
template struct DataVector_detail::DVLEltBaseInit<T>



#define DATAVECTOR_VIRTBASES1_FWD(T, B1)              \
template <> struct DataVectorBase<T>                  \
{ typedef DataVector_detail::VirtBases<B1> Base; };   \
SG_BASES1(DataVector<T>, SG_VIRTUAL(DataVector<B1>))



#define DATAVECTOR_VIRTBASES2(T, B1, B2)                \
DATAVECTOR_VIRTBASES2_FWD(T, B1, B2);                   \
template struct DataVector_detail::DVLEltBaseInit<T>


#define DATAVECTOR_VIRTBASES2_FWD(T, B1, B2)            \
template <> struct DataVectorBase<T>                    \
{ typedef DataVector_detail::VirtBases<B1, B2> Base; }; \
SG_BASES2(DataVector<T>, SG_VIRTUAL(DataVector<B1>),    \
                         SG_VIRTUAL(DataVector<B2>))


#define DATAVECTOR_VIRTBASES3(T, B1, B2, B3)            \
DATAVECTOR_VIRTBASES3_FWD(T, B1, B2, B3);               \
template struct DataVector_detail::DVLEltBaseInit<T>


#define DATAVECTOR_VIRTBASES3_FWD(T, B1, B2, B3)            \
template <> struct DataVectorBase<T>                        \
{ typedef DataVector_detail::VirtBases<B1, B2, B3> Base; }; \
SG_BASES3(DataVector<T>, SG_VIRTUAL(DataVector<B1>),        \
                         SG_VIRTUAL(DataVector<B2>),        \
                         SG_VIRTUAL(DataVector<B3>))


template <class DV> class ConstDataVector;
template <class DV> void test2_assignelement1();
template <class DV> void test2_assignelement2();


template <class T, class BASE = typename DataVectorBase<T>::Base>
class DataVector : public BASE
{
public:
  typedef BASE DataVector_BASE;
  typedef BASE DVL_BASE;

  static const bool has_virtual = BASE::has_virtual;

  typedef typename BASE::PtrVector PtrVector;
  typedef typename BASE::PtrVector BaseContainer;


public:
  // Standard types required for the container interface.
  typedef T*& reference;
  typedef T* const & const_reference;
  typedef typename BASE::size_type size_type;
  typedef typename BASE::difference_type difference_type;
  typedef T* value_type;
  typedef typename BASE::allocator_type allocator_type;
  typedef T** pointer;
  typedef T* const * const_pointer;

  typedef const T* const_value_type;

  typedef T base_value_type;

  typedef DataModel_detail::ElementProxy<DataVector> ElementProxy;


  typedef typename DataModel_detail::const_iterator<DataVector>
    const_iterator;

  typedef typename DataModel_detail::iterator<DataVector> iterator;


  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;


  //========================================================================


  explicit DataVector(SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);


  explicit DataVector(size_type n, /* value_type pElem = 0,*/
              SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);


  // The copy constructor for derived classes is deliberately omitted,
  // as otherwise we get warnings about not calling the copy constructors
  // for base classes, which are problematic when we have virtual
  // inheritance.  Most of what needs doing is done in the base class anyway,
  // except for setting @c m_isMostDerived.  We arrange for these flags
  // to all get set to false; they'll get set correctly when
  // @c testInsert is called.
#if __cplusplus > 201100
  // Need this to get the default copy ctor defined when a move
  // ctor is also present.
  DataVector (const DataVector&) = default;
#endif


#if __cplusplus > 201100

  DataVector (DataVector&& rhs);
#endif


  template <class InputIterator>
  DataVector(InputIterator first,
             InputIterator last,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);


#if __cplusplus > 201100

  DataVector(std::initializer_list<value_type> l,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
#endif


  DataVector& operator= (const DataVector& rhs);


#if __cplusplus > 201100

  DataVector& operator= (DataVector&& rhs);


  DataVector& operator= (std::initializer_list<value_type> l);
#endif


  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);


#if __cplusplus > 201100

  void assign(std::initializer_list<value_type> l);
#endif


  // Destructor is inherited.


  //========================================================================


  size_type size() const;


  // This is inherited from the base class.


  void resize(size_type sz);
  

  // This is inherited from the base class.


  // This is inherited from the base class.


  void reserve (size_type n);


  // This is inherited from the base class.


  //========================================================================


  const T* operator[] (size_type n) const;


  const T* get (size_type n) const;


  ElementProxy operator[] (size_type n);


  const T* at (size_type n) const;


  ElementProxy at (size_type n);


  const T* front() const;


  const T* back() const;


  ElementProxy front ();


  ElementProxy back ();


  //========================================================================


  const_iterator begin() const;


  const_iterator end() const;


  iterator begin();


  iterator end();


  const_reverse_iterator rbegin() const;


  const_reverse_iterator rend() const;


  reverse_iterator rbegin();


  reverse_iterator rend();


  const_iterator cbegin() const;


  const_iterator cend() const;


  const_reverse_iterator crbegin() const;


  const_reverse_iterator crend() const;


  //========================================================================


  void push_back(value_type pElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void push_back(std::unique_ptr<base_value_type> pElem);
#endif
#endif


  void emplace_back(value_type pElem);


  iterator insert(iterator position, value_type pElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  iterator insert(iterator position, std::unique_ptr<base_value_type> pElem);
#endif
#endif


  iterator emplace(iterator position, value_type pElem);


  template <class InputIterator>
  void insert(iterator position, InputIterator first, InputIterator last);


#if __cplusplus > 201100

  void insert(iterator position, std::initializer_list<value_type> l);
#endif


  //========================================================================


  iterator erase(iterator position);


  iterator erase(iterator first, iterator last);


  void pop_back();


  void clear();


  //========================================================================


  void swap(DataVector& rhs);


  static void iter_swap (iterator a, iterator b);


  void sort();


  template <class COMPARE>
  void sort(COMPARE comp);



  //========================================================================
  

  void swapElement(size_type index, value_type newElem, reference oldElem);


  void swapElement(iterator pos, value_type newElem, reference oldElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void swapElement(size_type index,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);


  void swapElement(iterator pos,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
#endif
#endif


public:
  // This is inherited from the base class.


  // This is inherited from the base class.


  void clear (SG::OwnershipPolicy ownPolicy);


  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);


  static const DataModel_detail::DVLInfoBase& dvlinfo();


  virtual const DataModel_detail::DVLInfoBase& dvlinfo_v() const;


  static
  int baseOffset (const std::type_info& ti);


  const SG::AuxVectorBase& auxbase() const;


  //========================================================================


  // Doxygen trick.  We want DataVector<T> to show the complete interface,
  // including inherited methods.  Normally, doxygen would do this.
  // But it's not smart enough to figure out our inheritance relationships.
  // We can add a function with `fn', but doxygen won't actually
  // generate the documentation unless it also sees the declaration.
  // So here are declarations which should be visible to doxygen
  // but not to C++.
#ifndef __cplusplus
  size_type max_size() const;
  void resize(size_type sz);
  size_type capacity() const;
  bool empty() const;
  void shrink_to_fit();
  void pop_back();
  void clear();
  const PtrVector& stdcont() const;
  SG::OwnershipPolicy ownPolicy() const;
  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);
#endif // not __cplusplus




  static
  int baseOffset1 (const char* p, const DataVector& dv,
                   const std::type_info& ti);


  void resortAux (iterator beg, iterator end);


  void testInsert (const char* op);


  void testInsertOol (const char* op);


private:
  friend class DataModel_detail::ElementProxy<DataVector>;
  friend class ConstDataVector<DataVector>;
  friend void test2_assignelement1<DataVector>();
  friend void test2_assignelement2<DataVector>();


  void assignElement (typename BaseContainer::iterator pos, value_type newElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void assignElement (typename BaseContainer::iterator pos,
                      std::unique_ptr<base_value_type> newElem);
#endif
#endif


  void assignBaseElement (typename BaseContainer::iterator pos,
                          typename BaseContainer::value_type newElem);


  void shift (size_t pos, ptrdiff_t offs);


public:
  // Make this public so we can call it from DVCollectionProxy.
  static
  const T* do_cast (const typename PtrVector::value_type p);


private:
  virtual const std::type_info& dv_typeid() const;


protected:
  void clearMostDerived();


  virtual void setMostDerived();


private:


  SG::IsMostDerivedFlag m_isMostDerived;


  static DataModel_detail::DVLInfo<DataVector<T> > s_info;


  typedef typename
    ROOT_SELECTION_NS::DataVector<T, DataVector_BASE>::self self;
};


template <class T, class BASE>
const bool DataVector<T, BASE>::has_virtual;

template <class T>
class DataVector<T, DataModel_detail::NoBase>
  : public SG::AuxVectorBase
{
public:
  typedef DataModel_detail::NoBase DataVector_BASE;
  typedef DataModel_detail::NoBase DVL_BASE;

  typedef boost::true_type isSequence;

  typedef std::vector<T*> PtrVector;
  typedef std::vector<T*> BaseContainer;

  static const bool has_virtual = false;

  // Standard types required for the container interface.
  typedef T*& reference;
  typedef T* const & const_reference;
  typedef typename PtrVector::size_type size_type;
  typedef typename PtrVector::difference_type difference_type;
  typedef T* value_type;
  typedef typename PtrVector::allocator_type allocator_type;
  typedef T** pointer;
  typedef T* const * const_pointer;

  typedef const T* const_value_type;

  typedef T base_value_type;

  typedef DataModel_detail::ElementProxy<DataVector> ElementProxy;


  // Here, we can just use the @c std::vector iterator.
  typedef typename PtrVector::const_iterator const_iterator;

  typedef typename DataModel_detail::iterator<DataVector> iterator;

  // Note: we can't just use the underlying PtrVector::const_reverse_iterator
  // here; otherwise, const_reverse_iterator won't be convertable to
  // reverse_iterator.
  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;


  //========================================================================


  explicit DataVector(SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);


  explicit DataVector
    (size_type n, /* value_type pElem = 0,*/
     SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
     SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);


  DataVector(const DataVector& rhs);


#if __cplusplus > 201100

  DataVector(DataVector&& rhs);
#endif


  template <class InputIterator>
  DataVector(InputIterator first, InputIterator last,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);


#if __cplusplus > 201100

  DataVector(std::initializer_list<value_type> l,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
#endif


  DataVector& operator= (const DataVector& rhs);


#if __cplusplus > 201100

  DataVector& operator= (DataVector&& rhs);


  DataVector& operator= (std::initializer_list<value_type> l);
#endif


  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);


#if __cplusplus > 201100

  void assign(std::initializer_list<value_type> l);
#endif


  virtual ~DataVector();


  //========================================================================


  size_type size() const;


  virtual size_type size_v() const;


  size_type max_size() const;


  void resize(size_type sz);


  size_type capacity() const;


  virtual size_type capacity_v() const;


  bool empty() const;


  void reserve (size_type n);


#if __cplusplus > 201100

  void shrink_to_fit();
#endif


  //========================================================================


  const T* operator[] (size_type n) const;


  const T* get (size_type n) const;


  ElementProxy operator[] (size_type n);


  const T* at (size_type n) const;


  ElementProxy at (size_type n);


  const T* front() const;


  const T* back() const;


  ElementProxy front ();


  ElementProxy back ();


  //========================================================================


  const_iterator begin() const;


  const_iterator end() const;


  iterator begin();


  iterator end();


  const_reverse_iterator rbegin() const;


  const_reverse_iterator rend() const;


  reverse_iterator rbegin();


  reverse_iterator rend();

  const_iterator cbegin() const;


  const_iterator cend() const;


  const_reverse_iterator crbegin() const;


  const_reverse_iterator crend() const;


  //========================================================================


  void push_back(value_type pElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void push_back(std::unique_ptr<base_value_type> pElem);
#endif
#endif


  void emplace_back(value_type pElem);


  iterator insert(iterator position, value_type pElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  iterator insert(iterator position, std::unique_ptr<base_value_type> pElem);
#endif
#endif


  iterator emplace(iterator position, value_type pElem);


  template <class InputIterator>
  void insert(iterator position, InputIterator first, InputIterator last);


#if __cplusplus > 201100

  void insert(iterator position, std::initializer_list<value_type> l);
#endif


  //========================================================================


  iterator erase(iterator position);


  iterator erase(iterator first, iterator last);


  void pop_back();


  void clear();


  //========================================================================


  void swap(DataVector& rhs);


  static void iter_swap (iterator a, iterator b);


  void sort();


  template <class COMPARE>
  void sort(COMPARE comp);


  //========================================================================


  void swapElement(size_type index, value_type newElem, reference oldElem);


  void swapElement(iterator pos, value_type newElem, reference oldElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void swapElement(size_type index,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);


  void swapElement(iterator pos,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
#endif
#endif


public:
  const PtrVector& stdcont() const;


  SG::OwnershipPolicy ownPolicy() const;


  void clear (SG::OwnershipPolicy ownPolicy);


  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);


  static const DataModel_detail::DVLInfoBase& dvlinfo();


  virtual const DataModel_detail::DVLInfoBase& dvlinfo_v() const;


  static
  int baseOffset (const std::type_info& ti);


  const SG::AuxVectorBase& auxbase() const;


  //========================================================================


  static
  int baseOffset1 (const char* p, const DataVector& dv,
                   const std::type_info& ti);


  void resortAux (iterator beg, iterator end);


  void testInsert (const char* op);


  void testInsertOol (const char* op);


private:
  friend class DataModel_detail::ElementProxy<DataVector>;
  friend class ConstDataVector<DataVector>;
  friend void test2_assignelement1<DataVector>();
  friend void test2_assignelement2<DataVector>();


  void assignElement (typename BaseContainer::iterator pos, value_type newElem);


#if __cplusplus > 201100
#ifndef __REFLEX__

  void assignElement (typename BaseContainer::iterator pos,
                      std::unique_ptr<base_value_type> newElem);
#endif
#endif


  void assignBaseElement (typename BaseContainer::iterator pos,
                          typename BaseContainer::value_type newElem);


  void shift (size_t pos, ptrdiff_t offs);


public:
  // Make this public so we can call it from DVCollectionProxy.
  static
  const T* do_cast (const typename PtrVector::value_type p);


private:
  virtual const std::type_info& dv_typeid() const;


protected:
  typename PtrVector::iterator
  erase_base(typename PtrVector::iterator position);


  typename PtrVector::iterator
  erase_base(typename PtrVector::iterator first,
             typename PtrVector::iterator last);


protected:
  SG::OwnershipPolicy m_ownPolicy;

  PtrVector m_pCont;


  void clearMostDerived();


  virtual void setMostDerived();


private:


  SG::IsMostDerivedFlag m_isMostDerived;


  static DataModel_detail::DVLInfo<DataVector<T> > s_info;


  typedef typename
    ROOT_SELECTION_NS::DataVector<T, DataVector_BASE>::self self;
};

template <class T>
const bool DataVector<T, DataModel_detail::NoBase>::has_virtual;


template <class T>
bool operator== (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
bool operator!= (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
bool operator< (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
bool operator> (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
bool operator<= (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
bool operator>= (const DataVector<T>& a, const DataVector<T>& b);


template <class T>
void swap (DataVector<T>& a, DataVector<T>& b);


ENTER_ROOT_SELECTION_NS

#if ROOT_VERSION_CODE < ROOT_VERSION( 5, 99, 0 )

template <class T>
struct SelectVirtBases
{
  typedef int type;
};

template <class B1, class B2, class B3>
struct SelectVirtBases<DataVector_detail::VirtBases<B1, B2, B3> >
{
  typedef ROOT_SELECTION_NS::AUTOSELECT type;
};

template <class T, class BASE>
class DataVector
{
public:
  typedef DataVector<T, BASE> self;

  ROOT_SELECTION_NS::TEMPLATE_DEFAULTS<
   ROOT_SELECTION_NS::NODEFAULT,
    typename ::DataVector<T>::DataVector_BASE> dum1;
  ROOT_SELECTION_NS::NO_SELF_AUTOSELECT dum2;
  ROOT_SELECTION_NS::AUTOSELECT m_pCont;
  ROOT_SELECTION_NS::TRANSIENT m_isMostDerived;
  typename SelectVirtBases<BASE>::type __base1;
};

#else

template< class T, class BASE >
class DataVector : KeepFirstTemplateArguments< 1 >
// The SelectNoInstance type was added after 6.00/02...
#if ROOT_VERSION_CODE > ROOT_VERSION( 6, 0, 2 )
   , SelectNoInstance
#endif // > v6.00/02
{

public:
   typedef DataVector< T, BASE > self;
#ifndef XAOD_STANDALONE
    //MN: this causes massive dictionary duplication.  Disabling for now.
   // ROOT_SELECTION_NS::MemberAttributes< kAutoSelected > m_pCont;
#endif  
   ROOT_SELECTION_NS::MemberAttributes< kTransient > m_isMostDerived;

};

#endif // ROOT_VERSION

EXIT_ROOT_SELECTION_NS


#include "AthContainers/ClassName.h"


template <class T>
class ClassName<DataVector<T> >
{
public:
  static std::string name();
};


#ifndef XAOD_STANDALONE


#include "AthContainers/tools/DVLDataBucket.h"
#include "SGTools/DataBucketTraitFwd.h"


namespace SG {


template <class T, class U>
struct DataBucketTrait<DataVector<T>, U>
{
  typedef SG::DVLDataBucket<U> type;
  static void init() { DataVector<T>::dvlinfo(); }
};


} // namespace SG


#endif


#include "AthContainers/DataVector.icc"


#if 0
//===================================================================
// Code to try to make the DATAVECTOR_BASES definitions automatically
// based on SG_BASES.  Still have to use one macro, DATAVECTOR_BASES_FROM_SG.
// Currently missing the part that would declare the DataVector relations
// to SG.  Not sure how useful this will be; don't bother trying to
// finish it now.
#include "boost/mpl/if.hpp"
#include "boost/mpl/and.hpp"
#include "boost/mpl/equal_to.hpp"
#define if_  boost::mpl::if_
#define and_ boost::mpl::and_
#define equal_to boost::mpl::equal_to
#define true_  boost::mpl::true_
#define false_ boost::mpl::false_
template <class U> struct not_virtual { typedef true_ type; };
template <class U> struct not_virtual<SG::Virtual<U> > { typedef false_ type; };
template <class U> struct clean_type { typedef U type; };
template <> struct clean_type<SG::NoBase>
{ typedef DataModel_detail::NoBase type; };
template <class U> struct clean_type<SG::Virtual<U> >
{ typedef typename clean_type<U>::type type; };
template <class T>
struct bases_from_sg
{
  typedef typename
          if_<equal_to<typename SG::Bases<T>::Base1, SG::NoBase>,
              DataModel_detail::NoBase,
              if_<and_<equal_to<typename SG::Bases<T>::Base1, SG::NoBase>,
                       not_virtual<typename SG::Bases<T>::Base2> >,
                  typename SG::Bases<T>::Base1,
                  DataVector_detail::VirtBases
                    <clean_type<typename SG::Bases<T>::Base1>,
                     clean_type<typename SG::Bases<T>::Base2>,
                     clean_type<typename SG::Bases<T>::Base3> >
                 > >::type type;
};
#undef if_
#undef and_
#undef equal_to
#undef true_
#undef false_

#define DATAVECTOR_BASES_FROM_SG(T) \
template <> struct DataVectorBase<T>                    \
{ typedef bases_from_sg<T>::type Base; };
//===================================================================
#endif


#endif // not ATHCONTAINERS_DATAVECTOR_H

---