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

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: DataList.h 616510 2014-09-12 15:31:07Z ssnyder $

#ifndef ATHCONTAINERS_DATALIST_H
#define ATHCONTAINERS_DATALIST_H

// Make sure that this header is not used outside of Athena:
#ifdef XAOD_STANDALONE
#error "DataList is not supported outside of Athena!"
#endif // XAOD_STANDALONE


// For feature tests.
#define HAVE_CONSTDATAVECTOR


// STL includes
#include <list>
#include <typeinfo>
#include <functional>
#include <iostream>
#include <algorithm> // for std::swap, find, find_if
#include <iterator>

// Boost includes
#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/iterator/iterator_adaptor.hpp>

// Kernel and StoreGate includes
#include "SGTools/BaseInfo.h"
#include "SGTools/DataBucketTraitFwd.h"
#include "SGTools/ClassName.h"

#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/DVLNoBase.h"
#include "AthContainers/tools/DVLInfo.h"
#include "AthContainers/tools/DVLDataBucket.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"


ENTER_ROOT_SELECTION_NS
template <class T, class BASE> class DataList;
EXIT_ROOT_SELECTION_NS


namespace DataList_detail {


// These are the intermediate classes from which @c DataList 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 PtrList
//     - @c BaseContainer
//     - @c size_type
//     - @c difference_type
//     - @c allocator_type
//   - @c has_virtual is defined as @c true.
//   - An override of @c dl_typeid is defined, to prevent ambiguities.
template <class B1,
          class B2=DataModel_detail::NoBase,
      class B3=DataModel_detail::NoBase> struct VirtBases;

} // end namespace DataList_detail

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

#define DATALIST_BASE(T, BASE)          \
template <> struct DataListBase<T>      \
{ typedef DataList<BASE> Base; };       \
SG_BASE(DataList<T>, DataList<BASE>); \
template struct DataList_detail::DVLEltBaseInit<T>


#define DATALIST_VIRTBASES1(T, B1)                  \
template <> struct DataListBase<T>                  \
{ typedef DataList_detail::VirtBases<B1> Base; };   \
SG_BASES1(DataList<T>, SG_VIRTUAL(DataList<B1>)); \
template struct DataList_detail::DVLEltBaseInit<T>



#define DATALIST_VIRTBASES2(T, B1, B2)                \
template <> struct DataListBase<T>                    \
{ typedef DataList_detail::VirtBases<B1, B2> Base; }; \
SG_BASES2(DataList<T>, SG_VIRTUAL(DataList<B1>),      \
                       SG_VIRTUAL(DataList<B2>)); \
template struct DataList_detail::DVLEltBaseInit<T>


#define DATALIST_VIRTBASES3(T, B1, B2, B3)            \
template <> struct DataListBase<T>                    \
{ typedef DataList_detail::VirtBases<B1, B2, B3> Base; }; \
SG_BASES3(DataList<T>, SG_VIRTUAL(DataList<B1>),          \
               SG_VIRTUAL(DataList<B2>),          \
               SG_VIRTUAL(DataList<B3>)); \
template struct DataList_detail::DVLEltBaseInit<T>


template <class DL> class ConstDataList;
template <class DL> void test2_assignelement1();


template <class T, class BASE = typename DataListBase<T>::Base>
class DataList : public BASE
{
public:
  typedef BASE DataList_BASE;
  typedef BASE DVL_BASE;

  static const bool has_virtual = BASE::has_virtual;

  typedef typename BASE::PtrList PtrList;
  typedef typename BASE::PtrList 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<DataList> ElementProxy;


  typedef typename DataModel_detail::const_iterator<DataList>
    const_iterator;

  typedef typename DataModel_detail::iterator<DataList> iterator;


  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;


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


  explicit DataList( SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS );


  explicit DataList( size_type n, /* value_type pElem = 0,*/
             SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS );


  // 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.


  template <class InputIterator>
  DataList( InputIterator first, InputIterator last,
            SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS );


  DataList& operator=( const DataList& rhs );


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


  // Destructor is inherited.


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


  // This is inherited from the base class.


  // This is inherited from the base class.


  // This is inherited from the base class.
  

  // This is inherited from the base class.


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

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


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


  void push_front( value_type pElem );


  void push_back( value_type pElem );


  iterator insert( iterator position, value_type pElem );


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


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


  iterator erase(iterator position);


  iterator erase(iterator first, iterator last);


  // This is inherited from the base class.


  // This is inherited from the base class.


  // This is inherited from the base class.


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


  void swap( DataList& rhs );


  static void iter_swap (iterator a, iterator b);


  void sort();


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


  void splice( iterator position, DataList& l );

  void splice( iterator position, DataList& l, iterator i );


  void splice( iterator position, DataList& l,
               iterator first,
               iterator last );


  void remove( const value_type& value );


  template<typename PREDICATE>
  void remove_if( PREDICATE p );


  void unique();


  template<typename BINARY_PREDICATE>
  void unique( BINARY_PREDICATE p );


  void merge( DataList& l );


  template<typename COMPARE>
  void merge( DataList& l, COMPARE predicate );


  void reverse();


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


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

  // This is inherited from the base class.


  // This is inherited from the base class.


  // This is inherited from the base class.


  static const DataModel_detail::DVLInfoBase& dvlinfo();


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


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


  // Doxygen trick.  We want DataList<T> to show the complete interface,
  // including inherited methods.  Normally, doxygen would do this.
  // But it's not smart 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 size() const;
  size_type max_size() const;
  void resize(size_type sz);
  bool empty() const;
  void pop_back();
  void pop_front();
  void clear();
  const PtrList& stdcont() const;
  SG::OwnershipPolicy ownPolicy() const;
  void clear (SG::OwnershipPolicy ownPolicy);
#endif // not __cplusplus




public:
  void resortAux (iterator beg, iterator end);


  void testInsert (const char* op);


  void testInsertOol (const char* op);


protected:
  void clearMostDerived();


  virtual void setMostDerived();


private:
  friend class DataModel_detail::ElementProxy<DataList>;
  friend class ConstDataList<DataList>;
  friend void test2_assignelement1<DataList>();


  virtual const std::type_info& dl_typeid() const;


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


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


  static
  const T* do_cast (const typename PtrList::value_type p);


  SG::IsMostDerivedFlag m_isMostDerived;


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


  typedef typename
    ROOT_SELECTION_NS::DataList<T, DataList_BASE>::self self;
};


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


template <class T>
class DataList<T, DataModel_detail::NoBase>
{
public:
  typedef DataModel_detail::NoBase DataList_BASE;
  typedef DataModel_detail::NoBase DVL_BASE;

  typedef boost::true_type isSequence;

  typedef std::list<T*> PtrList;
  typedef std::list<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 PtrList::size_type size_type;
  typedef typename PtrList::difference_type difference_type;
  typedef T* value_type;
  typedef typename PtrList::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<DataList> ElementProxy;


  typedef typename PtrList::const_iterator const_iterator;

  typedef typename DataModel_detail::iterator<DataList> iterator;

  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;


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


  explicit DataList( SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS );


  explicit DataList( size_type n, /* value_type pElem = 0,*/
             SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS );


  DataList( const DataList& rhs );


  template <class InputIterator>
  DataList( InputIterator first, InputIterator last,
        SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS );


  DataList& operator=( const DataList& rhs );


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


  virtual ~DataList();


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


  size_type size() const;


  size_type max_size() const;


  void resize( size_type sz );


  bool empty() const;


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


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

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


  void push_front( value_type pElem );


  void push_back( value_type pElem );


  iterator insert( iterator position, value_type pElem );


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


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


  iterator erase( iterator position );


  iterator erase( iterator first, iterator last );


  void pop_front();


  void pop_back();


  void clear();


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


  void swap( DataList& rhs );


  static void iter_swap (iterator a, iterator b);


  void sort();


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


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


  void splice( iterator position, DataList& l );

  void splice( iterator position, DataList& l, iterator i );


  void splice( iterator position, DataList& l,
               iterator first,
               iterator last );


  void remove( const value_type& value );


  template<typename PREDICATE>
  void remove_if( PREDICATE p );

  void unique();

  template<typename BinaryPredicate>
  void unique( BinaryPredicate pred );

  void merge( DataList& l );

  template<typename COMPARE>
  void merge( DataList& l, COMPARE predicate );

  void reverse();



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


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


  const PtrList& stdcont() const;


  SG::OwnershipPolicy ownPolicy() const;


  void clear (SG::OwnershipPolicy ownPolicy);


  static const DataModel_detail::DVLInfoBase& dvlinfo();


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


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


public:
  void resortAux (iterator beg, iterator end);


  void testInsert (const char* op);


  void testInsertOol (const char* op);


private:
  friend class DataModel_detail::ElementProxy<DataList>;
  friend class ConstDataList<DataList>;
  friend void test2_assignelement1<DataList>();


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


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


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


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


protected:
  SG::OwnershipPolicy m_ownPolicy;

  PtrList m_pCont;


  void clearMostDerived();


  virtual void setMostDerived();


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


  SG::IsMostDerivedFlag m_isMostDerived;


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


  typedef typename
    ROOT_SELECTION_NS::DataList<T, DataList_BASE>::self self;
};

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


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


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


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


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


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


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


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


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


ENTER_ROOT_SELECTION_NS

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

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

  ROOT_SELECTION_NS::TEMPLATE_DEFAULTS<
   ROOT_SELECTION_NS::NODEFAULT,
    typename ::DataList<T>::DataList_BASE> dum1;
  ROOT_SELECTION_NS::NO_SELF_AUTOSELECT dum2;
  ROOT_SELECTION_NS::TRANSIENT m_isMostDerived;
};

#else

template< class T, class BASE >
class DataList : KeepFirstTemplateArguments< 1 >, SelectNoInstance {

public:
   typedef DataList< T, BASE > self;

   ROOT_SELECTION_NS::MemberAttributes< kTransient > m_isMostDerived;

};

#endif // ROOT_VERSION

EXIT_ROOT_SELECTION_NS


namespace SG {


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


} // namespace SG
#include "AthContainers/DataList.icc"


#if 0
//===================================================================
// Code to try to make the DATALIST_BASES definitions automatically
// based on SG_BASES.  Still have to use one macro, DATALIST_BASES_FROM_SG.
// Currently missing the part that would declare the DataList 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,
                  DataList_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 DATALIST_BASES_FROM_SG(T) \
template <> struct DataListBase<T>                    \
{ typedef bases_from_sg<T>::type Base; };
//===================================================================
#endif



#endif // ATHCONTAINERS_DATALIST_H

---