/home/raskolnikov/dev/psynth/trunk/src/psynth/base/iterator.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2007 Juan Pedro Bolívar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Psychosynth is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef PSYNTH_BASE_ITERATOR_HPP_
#define PSYNTH_BASE_ITERATOR_HPP_

#include <map>
#include <iterator>

#include <psynth/base/type_traits.hpp>
#include <psynth/base/pointer.hpp>

namespace psynth
{
namespace base
{

template <typename Iterator>
class ptr_iterator : public Iterator
{
public:
    typedef std::iterator_traits<Iterator> base_traits;
    
    typedef typename std::iterator_traits<Iterator>::value_type ptr_value_type;
    typedef typename pointee<ptr_value_type>::type value_type;
    
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::difference_type difference_type;
    typedef value_type* pointer;
    typedef value_type& reference;

    ptr_iterator () = default;
    ptr_iterator (const ptr_iterator& it) = default;

    ptr_iterator (ptr_iterator&& it)
        : Iterator (std::move (it))
    {}

    ptr_iterator (const Iterator& it)
        : Iterator (it)
    {}

    ptr_iterator (Iterator&& it)
        : Iterator (std::move (it))
    {}
    
    template<class OtherIterator>
    ptr_iterator (const OtherIterator& it)
        : Iterator (it)
    {}

    template<class OtherIterator>
    ptr_iterator (OtherIterator&& it)
        : Iterator (std::move (it))
    {}
    
    value_type& operator*() const
    {
        return *Iterator::operator* ();
    }

    value_type* operator->() const
    {
        return &*Iterator::operator* ();
    }
};

template <typename Iterator>
class ptr_const_iterator : public Iterator
{
public:
    typedef typename std::iterator_traits<Iterator>::value_type ptr_value_type;
    typedef typename pointee<ptr_value_type>::type value_type;
    
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::difference_type difference_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    
    ptr_const_iterator () {}

    ptr_const_iterator (const Iterator& it)
        : Iterator (it)
    {}

    template<class OtherIterator>
    ptr_const_iterator (const OtherIterator& it)
        : Iterator (it)
    {}
    
    ptr_const_iterator (const ptr_const_iterator& it)
        : Iterator (it)
    {}

    const value_type& operator*() const
    {
        return *Iterator::operator* ();
    }

    const value_type* operator->() const
    {
        return &*Iterator::operator* ();
    }
};
  
template <typename Key, typename Data>
class map_iterator : public std::map<Key, Data>::iterator
{
public:
    typedef typename std::map<Key, Data>::iterator base_type;
    
    typedef typename base_type::iterator_category iterator_category;
    typedef Data value_type;
    typedef typename base_type::difference_type difference_type;
    typedef Data* pointer;
    typedef Data& reference;
    
    map_iterator ()
    {}

    map_iterator (const base_type& i)
        : base_type (i) {}

    map_iterator (const map_iterator& i)
        : base_type (
            static_cast<const base_type&>(i)
            )
    {}

    map_iterator (base_type&& i)
        : base_type (std::move (i)) {}

    map_iterator (map_iterator&& i)
        : base_type (
            std::move (
                static_cast<const base_type&>(i)
            ))
    {}

    Data& operator*()
    {
        return std::map<Key, Data>::iterator::operator*().second;
    }

    Data* operator->()
    {
        return &std::map<Key, Data>::iterator::operator*().second;
    }

    const Data& operator*() const
    {
        return std::map<Key, Data>::iterator::operator*().second;
    }

    const Data* operator->() const
    {
        return &std::map<Key, Data>::iterator::operator*().second;
    }

    map_iterator<Key, Data> operator++ ()
    {
        return std::map<Key, Data>::iterator::operator++();
    }

    map_iterator<Key, Data> operator++ (int)
    {
        return std::map<Key, Data>::iterator::operator++(0);
    }
};

template <typename Key, typename Data>
class map_const_iterator : public std::map<Key, Data>::const_iterator
{
public:
    typedef typename std::map<Key, Data>::const_iterator::iterator_category iterator_category;
    typedef Data value_type;
    typedef typename std::map<Key, Data>::const_iterator::difference_type difference_type;
    typedef Data* pointer;
    typedef Data& reference;

    map_const_iterator (const typename std::map<Key, Data>::const_iterator& i)
        : std::map<Key, Data>::const_iterator(i) {}

    map_const_iterator (const map_const_iterator<Key, Data>& i)
        : std::map<Key, Data>::const_iterator (
            static_cast<const typename std::map<Key, Data>::const_iterator>(i))
    {}

    const Data& operator* ()
    {
        return std::map<Key, Data>::const_iterator::operator*().second;
    }

    const Data& operator* () const
    {
        return std::map<Key, Data>::const_iterator::operator*().second;
    }
};

template <typename Key, typename Data, class Iter>
class map_iterator_base : public std::map<Key, Data>::iterator
{
public:
    typedef typename std::map<Key, Data>::iterator::iterator_category
    iterator_category;
    typedef Data value_type;
    typedef typename std::map<Key, Data>::iterator::difference_type
    difference_type;
    typedef Data* pointer;
    typedef Data& reference;

    map_iterator_base ()
    {}

    map_iterator_base (const typename std::map<Key, Data>::iterator& i)
        : std::map<Key, Data>::iterator (i)
    {}

    map_iterator_base (const map_iterator_base<Key, Data, Iter>& i)
        : std::map<Key, Data>::iterator (
            static_cast<const typename std::map<Key, Data>::iterator> (i))
    {}
    
    Iter operator++ ()
    {
        return std::map<Key, Data>::iterator::operator++();
    }

    Iter operator++ (int)
    {
        return std::map<Key, Data>::iterator::operator++(0);
    }
};

template <typename Key, typename Data, class Iter>
class map_const_iterator_base : public std::map<Key, Data>::const_iterator
{
public:
    typedef typename std::map<Key, Data>::const_iterator::iterator_category
    iterator_category;
    typedef Data value_type;
    typedef typename std::map<Key, Data>::const_iterator::difference_type
    difference_type;
    typedef Data* pointer;
    typedef Data& reference;

    map_const_iterator_base ()
    {}

    map_const_iterator_base (const typename std::map<Key, Data>::const_iterator& i)
        : std::map<Key, Data>::const_iterator (i)
    {}

    map_const_iterator_base (const map_const_iterator_base<Key, Data, Iter>& i)
        : std::map<Key, Data>::const_iterator (
            static_cast<const typename std::map<Key, Data>::const_iterator> (i))
    {}
    
    Iter operator++ ()
    {
        return std::map<Key, Data>::const_iterator::operator++ ();
    }

    Iter operator++ (int)
    {
        return std::map<Key, Data>::const_iterator::operator++ (0);
    }
};

template <typename Key, typename Data>
class map_key_iterator :
    public map_iterator_base<Key, Data, map_key_iterator<Key, Data> >
{
public:
    map_key_iterator () {}

    template <class T>
    map_key_iterator (const T& val)
        : map_iterator_base<Key, Data, map_key_iterator> (val)
    {}
    
    const Key& operator*() const
    {
        return std::map<Key, Data>::iterator::operator*().first;
    }

    const Key* operator->() const
    {
        return &std::map<Key, Data>::iterator::operator*().first;
    }
};


} /* namespace base */
} /* namespace psynth */

#endif /* PSYNTH_BASE_ITERATOR_HPP_ */