source: ThirdParty/CodePatterns/src/CodePatterns/IteratorAdaptors.hpp

/*
 * IteratorAdaptors.hpp
 *
 *  This is all copy&pasted from
 *  http://stackoverflow.com/questions/4908317/iterate-through-stl-sequence-and-associative-containers-using-same-code
 *
 *  Kudos go to Emile Cormier for writing this adapter code.
 *
 *  I just adapted it to sequence through either value or key and changed the name.
 *
 *  Created on: Feb 21, 2011
 *      Author: heber
 */

#ifndef ITERATORADAPTORS_HPP_
#define ITERATORADAPTORS_HPP_

#include <iostream>
#include <map>
#include <vector>
#include <boost/iterator/iterator_adaptor.hpp>

/** This class wraps an iterator and implements a dereferencer (operator*) that
 *  always returns the value
 */
template <class BaseIterator>
class MapValueIterator :
    public boost::iterator_adaptor<
    MapValueIterator<BaseIterator>,
        BaseIterator,
        typename BaseIterator::value_type::second_type >
{
public:
    typedef typename BaseIterator::value_type::second_type& reference;

    MapValueIterator() {}

    explicit MapValueIterator(BaseIterator base)
    :   MapValueIterator::iterator_adaptor_(base) {}

 private:
    friend class boost::iterator_core_access;
    reference dereference() const
        {return this->base_reference()->second;}
};

/** This class wraps an iterator and implements a dereferencer (operator*) that
 *  always returns the value
 */
template <class BaseIterator>
class MapValueConstIterator :
    public boost::iterator_adaptor<
    MapValueConstIterator<BaseIterator>,
        BaseIterator,
        const typename BaseIterator::value_type::second_type >
{
public:
    typedef const typename BaseIterator::value_type::second_type& const_reference;

    MapValueConstIterator() {}

    explicit MapValueConstIterator(BaseIterator base)
    :   MapValueConstIterator::iterator_adaptor_(base) {}

 private:
    friend class boost::iterator_core_access;
    const_reference dereference() const
        {return this->base_reference()->second;}
};

/** This class wraps an iterator and implements a dereferencer (operator*) that
 *  always returns the key
 */
template <class BaseIterator>
class MapKeyIterator :
    public boost::iterator_adaptor<
    MapKeyIterator<BaseIterator>,
        BaseIterator,
        typename BaseIterator::value_type::first_type >
{
public:
    typedef typename BaseIterator::value_type::first_type& reference;

    MapKeyIterator() {}

    explicit MapKeyIterator(BaseIterator base)
    :   MapKeyIterator::iterator_adaptor_(base) {}

 private:
    friend class boost::iterator_core_access;
    reference dereference() const
        {return this->base_reference()->first;}
};

/** This class wraps an iterator and implements a dereferencer (operator*) that
 *  always returns the key
 */
template <class BaseIterator>
class MapKeyConstIterator :
    public boost::iterator_adaptor<
    MapKeyConstIterator<BaseIterator>,
        BaseIterator,
        const typename BaseIterator::value_type::first_type >
{
public:
    typedef const typename BaseIterator::value_type::first_type& const_reference;

    MapKeyConstIterator() {}

    explicit MapKeyConstIterator(BaseIterator base)
    :   MapKeyConstIterator::iterator_adaptor_(base) {}

 private:
    friend class boost::iterator_core_access;
    const_reference dereference() const
        {return this->base_reference()->first;}
};

#endif /* ITERATORADAPTORS_HPP_ */