poolalloc/include/dsa/keyiterator.h

//===- keyiterator.h - Iterator over just the keys in a map -----*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Implement a map key iterator
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_KEYITERATOR_H
#define	LLVM_KEYITERATOR_H

#include <functional>

//From SGI's STL

// select1st and select2nd are extensions: they are not part of the standard.

template <class _Pair>
class _Select1st : public std::unary_function<_Pair, typename _Pair::first_type> {
public:

  const typename _Pair::first_type & operator()(const _Pair& __x) const {
    return __x.first;
  }
};

template <class _Pair>
class _Select2nd : public std::unary_function<_Pair, typename _Pair::second_type> {
public:

  const typename _Pair::second_type & operator()(const _Pair& __x) const {
    return __x.second;
  }
};

template <class _Pair> class select1st : public _Select1st<_Pair> {
};

template <class _Pair> class select2nd : public _Select2nd<_Pair> {
};


// ref_mapped_iterator - This is a simple iterator adapter that causes a
// function to be dereferenced whenever operator* is invoked on the iterator.
// It is assumed that the function returns a valid reference, which differs
// from llvm::mapped_iterator from which this was derived (copied)

template <class RootIt, class UnaryFunc>
class ref_mapped_iterator {
  RootIt current;
  UnaryFunc Fn;
public:
  typedef typename std::iterator_traits<RootIt>::iterator_category
  iterator_category;
  typedef typename std::iterator_traits<RootIt>::difference_type
  difference_type;
  typedef typename UnaryFunc::result_type value_type;

  typedef typename UnaryFunc::result_type *pointer;
  typedef typename UnaryFunc::result_type& reference;

  typedef RootIt iterator_type;
  typedef ref_mapped_iterator<RootIt, UnaryFunc> _Self;

  inline const RootIt &getCurrent() const {
    return current;
  }

  inline const UnaryFunc &getFunc() const {
    return Fn;
  }

  inline explicit ref_mapped_iterator(const RootIt &I, UnaryFunc F)
  : current(I), Fn(F) { }

  inline ref_mapped_iterator(const ref_mapped_iterator &It)
  : current(It.current), Fn(It.Fn) { }

  inline reference operator*() const { // All this work to do this
    return Fn(*current); // little change
  }

  _Self & operator++() {
    ++current;
    return *this;
  }

  _Self & operator--() {
    --current;
    return *this;
  }

  _Self operator++(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }

  _Self operator--(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }

  _Self operator+(difference_type n) const {
    return _Self(current + n, Fn);
  }

  _Self & operator+=(difference_type n) {
    current += n;
    return *this;
  }

  _Self operator-(difference_type n) const {
    return _Self(current - n, Fn);
  }

  _Self & operator-=(difference_type n) {
    current -= n;
    return *this;
  }

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

  inline bool operator!=(const _Self &X) const {
    return !operator==(X);
  }

  inline bool operator==(const _Self &X) const {
    return current == X.current;
  }

  inline bool operator<(const _Self &X) const {
    return current < X.current;
  }

  inline difference_type operator-(const _Self &X) const {
    return current - X.current;
  }
};

template <class Iter>
class KeyIterator
: public ref_mapped_iterator<Iter, select1st<typename Iter::value_type> > {
  typedef select1st<typename Iter::value_type> FunTy;
public:

  KeyIterator(const Iter I)
  : ref_mapped_iterator<Iter, select1st<typename Iter::value_type> >(I, FunTy()) { }
};

template <class Iter>
class ValueIterator
: public ref_mapped_iterator<Iter, select2nd<typename Iter::value_type> > {
  typedef select2nd<typename Iter::value_type> FunTy;
public:

  ValueIterator(const Iter I)
  : ref_mapped_iterator<Iter, select2nd<typename Iter::value_type> >(I, FunTy()) { }
};


#if 0

template<class Iter>
class KeyIterator {
  Iter I;

public:
  typedef typename Iter::difference_type difference_type;
  typedef typename Iter::value_type::first_type value_type;
  typedef typename Iter::value_type::first_type* pointer;
  typedef typename Iter::value_type::first_type& reference;
  typedef typename Iter::iterator_category iterator_category;

  KeyIterator(Iter i) : I(i) { }

  Iter base() const {
    return I;
  }

  reference operator*() const {
    return I->first;
  }

  KeyIterator operator+(difference_type n) const {
    return KeyIterator(I + n);
  }

  KeyIterator & operator++() {
    ++I;
    return *this;
  }

  KeyIterator operator++(int) {
    Iter OI = I;
    ++I;
    return KeyIterator(OI);
  }

  KeyIterator & operator+=(difference_type n) {
    I += n;
    return *this;
  }

  KeyIterator operator-(difference_type n) const {
    return KeyIterator(I - n);
  }

  KeyIterator & operator--() {
    --I;
    return *this;
  }

  KeyIterator operator--(int) {
    Iter OI = I;
    --I;
    return KeyIterator(OI);
  }

  KeyIterator & operator-=(difference_type n) {
    I -= n;
    return *this;
  }

  pointer operator->() const {
    return &I->first;
  }

  bool operator==(const KeyIterator& RHS) const {
    return I == RHS.I;
  }

  bool operator!=(const KeyIterator& RHS) const {
    return I != RHS.I;
  }
};
#endif


#endif	/* LLVM_KEYITERATOR_H */