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

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id$
#ifndef ATHCONTAINERS_TOOLS_DVLITERATOR_H
#define ATHCONTAINERS_TOOLS_DVLITERATOR_H


#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/tools/DVLCast.h"
#include "AthContainers/tools/ElementProxy.h"
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/version.hpp>
#include <iterator>
#include <cstdlib>


#if BOOST_VERSION < 105000
namespace boost { namespace detail {


template <class T, class U>
struct operator_arrow_result<T*,
                             DataModel_detail::ElementProxy<U>,
                             T**>
{
public:
  typedef T* ValueType;
  typedef DataModel_detail::ElementProxy<U> Reference;
  typedef T** Pointer;
  typedef Pointer type;
  static type make (Reference /*x*/) { std::abort(); return 0; }
};


}}
#endif


namespace DataModel_detail {


template <class DVL>
class const_iterator
{
public:
  typedef typename DVL::const_value_type value_type;
  typedef value_type reference;
  typedef value_type* pointer;
  typedef typename DVL::BaseContainer::const_iterator::difference_type difference_type;
  typedef typename DVL::BaseContainer::const_iterator::iterator_category iterator_category;

  typedef DVL Container;
  typedef typename DVL::BaseContainer BaseContainer;


  const_iterator() {}


   const_iterator (typename BaseContainer::const_iterator it)
    : m_it (it)
  {}


  reference operator*() const { return dereference(); }
  reference operator[] (difference_type n) const
  { const_iterator tmp = *this + n; return *tmp; }


  const_iterator& operator++() { ++m_it; return *this; }
  const_iterator operator++(int)
  { const_iterator tmp = *this; ++m_it; return tmp; }
  const_iterator& operator--() { --m_it; return *this; }
  const_iterator operator--(int)
  { const_iterator tmp = *this; --m_it; return tmp; }


  const_iterator& operator+= (difference_type n) { m_it += n; return *this; }
  const_iterator& operator-= (difference_type n) { m_it -= n; return *this; }
  const_iterator operator+ (difference_type n) const { const_iterator tmp = *this; tmp += n; return tmp; }
  const_iterator operator- (difference_type n) const { const_iterator tmp = *this; tmp -= n; return tmp; }
  difference_type operator- (const_iterator other) const { return m_it - other.m_it; }


  bool operator== (const const_iterator& other) const { return m_it == other.m_it; }
  bool operator!= (const const_iterator& other) const { return m_it != other.m_it; }
  bool operator< (const const_iterator& other) const { return m_it < other.m_it; }
  bool operator> (const const_iterator& other) const { return m_it > other.m_it; }
  bool operator<= (const const_iterator& other) const { return m_it <= other.m_it; }
  bool operator>= (const const_iterator& other) const { return m_it >= other.m_it; }


private:
  typename BaseContainer::const_iterator m_it;

  const typename DVL::value_type dereference() const
  {
    return DataModel_detail::DVLCast<DVL>::cast (*m_it);
  }
};


template <class DVL>
class iterator
  : public boost::iterator_adaptor<iterator<DVL>,
                                   typename DVL::BaseContainer::iterator,
                                   typename DVL::value_type, // Value
                                   // Note: Can't use boost::use_default here.
                                   // Otherwise, we get boost's new-fangled
                                   // iterator categories, which won't work
                                   // with libstdc++'s implementation
                                   // of sort().
                                   // CategoryOrTraversal
                                   typename DVL::BaseContainer::
                                            const_iterator::iterator_category,
                                   typename DVL::ElementProxy> // Reference
{
private:
  // Shorthand for the base class type.
  typedef boost::iterator_adaptor<iterator,
                                  typename DVL::BaseContainer::iterator,
                                  typename DVL::value_type, // Value
                                  // CategoryOrTraversal
                                  typename DVL::BaseContainer::
                                           const_iterator::iterator_category,
                                  typename DVL::ElementProxy> iterator_adaptor_;

  // Copy some other names 
  typedef typename DVL::ElementProxy ElementProxy;
  typedef typename DVL::const_iterator const_iterator;


public:
  typedef DVL Container;
  typedef typename DVL::BaseContainer BaseContainer;


  iterator() :
    m_container(0)
  {}


  iterator (typename BaseContainer::iterator it,
            DVL* container)
    : iterator_adaptor_ (it),
      m_container (container)
  {}


  ElementProxy operator[] (int n) const
  {
    return ElementProxy (this->base()+n, m_container);
  }


  operator const_iterator() const
  {
    return const_iterator (this->base());
  }


  DVL* container() const
  {
    return m_container;
  }


  SG::OwnershipPolicy ownPolicy() const
  {
    return m_container->ownPolicy();
  }


  void testInsert (const char* op)
  {
    m_container->testInsert (op);
  }


  // These are needed for iterator/const_iterator comparisons to work.
  bool operator== (const iterator& i) const { return this->base() == i.base();}
  bool operator!= (const iterator& i) const { return this->base() != i.base();}
  bool operator<  (const iterator& i) const { return this->base() <  i.base();}
  bool operator>  (const iterator& i) const { return this->base() >  i.base();}
  bool operator<= (const iterator& i) const { return this->base() <= i.base();}
  bool operator>= (const iterator& i) const { return this->base() >= i.base();}

  // These are needed for iterator/const_iterator comparisons to work.
  bool operator== (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)==i; }
  bool operator!= (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)!=i; }
  bool operator<  (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)<i; }
  bool operator>  (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)>i; }
  bool operator<= (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)<=i; }
  bool operator>= (const const_iterator& i) const
  { return static_cast<const_iterator>(*this)>=i; }

  // These overloads are needed for iterator-const_iterator to work.
  typename iterator_adaptor_::difference_type
  operator- (const iterator& i) const
  { return this->base() - i.base(); }
  iterator operator- (typename iterator_adaptor_::difference_type i) const
  { return iterator (this->base() - i, m_container); }
  typename iterator_adaptor_::difference_type
  operator- (const const_iterator& i) const
  { return static_cast<const_iterator>(*this) - i; }


private:
  typename DVL::pointer operator-> ();

  // Required for iterator_adaptor to work.
  friend class boost::iterator_core_access;


  ElementProxy dereference() const
  {
    return ElementProxy (this->base(), m_container);
  }


  DVL* m_container;
};


} // namespace DataModel_detail


// We need to define these to allow comparisons of
// iterator and const_iterator.
template <class DVL>
inline
bool operator== (const typename DVL::const_iterator& i1,
                 const DataModel_detail::iterator<DVL>& i2)
{
  return i1 == typename DVL::const_iterator (i2);
}
template <class DVL>
inline
bool operator!= (typename DVL::const_iterator i1,
                 DataModel_detail::iterator<DVL> i2)
{
  return i1 != typename DVL::const_iterator (i2);
}
template <class DVL>
inline
bool operator< (typename DVL::const_iterator i1,
                DataModel_detail::iterator<DVL> i2)
{
  return i1 < typename DVL::const_iterator (i2);
}
template <class DVL>
inline
bool operator> (typename DVL::const_iterator i1,
                DataModel_detail::iterator<DVL> i2)
{
  return i1 > typename DVL::const_iterator (i2);
}
template <class DVL>
inline
bool operator<= (typename DVL::const_iterator i1,
                 DataModel_detail::iterator<DVL> i2)
{
  return i1 <= typename DVL::const_iterator (i2);
}
template <class DVL>
inline
bool operator>= (typename DVL::const_iterator i1,
                 DataModel_detail::iterator<DVL> i2)
{
  return i1 >= typename DVL::const_iterator (i2);
}

// This overloads is needed for const_iterator-iterator to work.
template <class DVL>
inline
typename DVL::const_iterator::difference_type
operator- (typename DVL::const_iterator i1,
           DataModel_detail::iterator<DVL> i2)
{
  return i1 - typename DVL::const_iterator (i2);
}


#endif // not ATHCONTAINERS_TOOLS_DVLITERATOR_H

---