iterator.hpp
Go to the documentation of this file.
/*
CLAW - a C++ Library Absolutely Wonderful
CLAW is a free library without any particular aim but being useful to
anyone.
Copyright (C) 2005-2011 Julien Jorge
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
contact: julien.jorge@gamned.org
*/
#ifndef __CLAW_ITERATOR_HPP__
#define __CLAW_ITERATOR_HPP__
#include <iterator>
namespace claw
{
/*-------------------------------------------------------------------------*/
template< typename Category, typename Value, typename Iterator,
typename Function >
class wrapped_iterator_by_category
{
}; // class wrapped_iterator_by_category
/*-------------------------------------------------------------------------*/
template<typename Value, typename Iterator, typename Function>
class wrapped_iterator_by_category
<std::forward_iterator_tag, Value, Iterator, Function>
{
public:
typedef typename std::iterator_traits<Iterator>::difference_type
difference_type;
typedef Value value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef typename std::iterator_traits<Iterator>::iterator_category
iterator_category;
typedef
wrapped_iterator_by_category
<std::forward_iterator_tag, Value, Iterator, Function>
self_type;
public:
wrapped_iterator_by_category() {}
wrapped_iterator_by_category( const Iterator& it )
: m_it(it)
{ }
wrapped_iterator_by_category( const Iterator& it, const Function& f )
: m_it(it), m_fun(f)
{ }
template<typename C, typename V, typename I, typename F>
wrapped_iterator_by_category
( const wrapped_iterator_by_category<C, V, I, F>& that )
: m_it(that.get_iterator()), m_fun(that.get_function())
{ }
const Iterator& get_iterator() const { return m_it; }
const Function& get_function() const { return m_fun; }
self_type& operator++()
{
++m_it;
return *this;
}
self_type operator++(int)
{
self_type tmp(*this);
++m_it;
return tmp;
}
reference operator*() const { return m_fun(*m_it); }
pointer operator->() const { return &m_fun(*m_it); }
bool operator==( const self_type& that ) const { return m_it == that.m_it; }
bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
bool operator==( const Iterator& it ) const { return m_it == it; }
bool operator!=( const Iterator& it ) const { return m_it != it; }
private:
Iterator m_it;
Function m_fun;
}; // class wrapped_iterator_by_category [forward_iterator_tag]
/*-------------------------------------------------------------------------*/
template<typename Value, typename Iterator, typename Function>
class wrapped_iterator_by_category
<std::bidirectional_iterator_tag, Value, Iterator, Function>
{
public:
typedef typename std::iterator_traits<Iterator>::difference_type
difference_type;
typedef Value value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef typename std::iterator_traits<Iterator>::iterator_category
iterator_category;
typedef
wrapped_iterator_by_category
<std::bidirectional_iterator_tag, Value, Iterator, Function> self_type;
public:
wrapped_iterator_by_category() {}
wrapped_iterator_by_category( const Iterator& it )
: m_it(it)
{ }
wrapped_iterator_by_category( const Iterator& it, const Function& f )
: m_it(it), m_fun(f)
{ }
template<typename C, typename V, typename I, typename F>
wrapped_iterator_by_category
( const wrapped_iterator_by_category<C, V, I, F>& that )
: m_it(that.get_iterator()), m_fun(that.get_function())
{ }
const Iterator& get_iterator() const { return m_it; }
const Function& get_function() const { return m_fun; }
self_type& operator++()
{
++m_it;
return *this;
}
self_type operator++(int)
{
self_type tmp(*this);
++m_it;
return tmp;
}
self_type& operator--()
{
--m_it;
return *this;
}
self_type operator--(int)
{
self_type tmp(*this);
--m_it;
return tmp;
}
reference operator*() const { return m_fun(*m_it); }
pointer operator->() const { return &m_fun(*m_it); }
bool operator==( const self_type& that ) const { return m_it == that.m_it; }
bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
bool operator==( const Iterator& it ) const { return m_it == it; }
bool operator!=( const Iterator& it ) const { return m_it != it; }
private:
Iterator m_it;
Function m_fun;
}; // class wrapped_iterator_by_category [bidirectional_iterator_tag]
/*-------------------------------------------------------------------------*/
template<typename Value, typename Iterator, typename Function>
class wrapped_iterator_by_category
<std::random_access_iterator_tag, Value, Iterator, Function>
{
public:
typedef typename std::iterator_traits<Iterator>::difference_type
difference_type;
typedef Value value_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef typename std::iterator_traits<Iterator>::iterator_category
iterator_category;
typedef
wrapped_iterator_by_category
<std::random_access_iterator_tag, Value, Iterator, Function>
self_type;
public:
wrapped_iterator_by_category() {}
wrapped_iterator_by_category( const Iterator& it )
: m_it(it)
{ }
wrapped_iterator_by_category( const Iterator& it, const Function& f )
: m_it(it), m_fun(f)
{ }
template<typename V, typename I>
wrapped_iterator_by_category
( const wrapped_iterator_by_category
<std::random_access_iterator_tag, V, I, Function>& that )
: m_it(that.m_it), m_fun(that.m_fun)
{ }
template<typename C, typename V, typename I, typename F>
wrapped_iterator_by_category
( const wrapped_iterator_by_category<C, V, I, F>& that )
: m_it(that.get_iterator()), m_fun(that.get_function())
{ }
const Iterator& get_iterator() const { return m_it; }
const Function& get_function() const { return m_fun; }
self_type& operator++()
{
++m_it;
return *this;
}
self_type operator++(int)
{
self_type tmp(*this);
++m_it;
return tmp;
}
self_type& operator--()
{
--m_it;
return *this;
}
self_type operator--(int)
{
self_type tmp(*this);
--m_it;
return tmp;
}
reference operator*() const { return m_fun(*m_it); }
pointer operator->() const { return &m_fun(*m_it); }
bool operator==( const self_type& that ) const { return m_it == that.m_it; }
bool operator!=( const self_type& that ) const { return m_it != that.m_it; }
bool operator==( const Iterator& it ) const { return m_it == it; }
bool operator!=( const Iterator& it ) const { return m_it != it; }
bool operator<( const self_type& that ) const { return m_it < that.m_it; }
bool operator<=( const self_type& that ) const { return m_it <= that.m_it; }
bool operator>( const self_type& that ) const { return m_it > that.m_it; }
bool operator>=( const self_type& that ) const { return m_it >= that.m_it; }
difference_type operator-( const self_type& that ) const
{
return m_it - that.m_it;
}
self_type& operator+=(int n)
{
m_it += n;
return *this;
}
self_type operator+(int n) const
{
self_type result(*this);
result += n;
return result;
}
self_type& operator-=(int n) { return *this += -n; }
self_type operator-(int n) const
{
self_type result(*this);
result -= n;
return result;
}
reference operator[](int n) { return m_fun(m_it[n]); }
private:
Iterator m_it;
Function m_fun;
}; // class wrapped_iterator_by_category [random_access_iterator_tag]
template<typename Value, typename Iterator, typename Function>
wrapped_iterator_by_category
<std::random_access_iterator_tag, Value, Iterator, Function>
operator+
( int n,
const wrapped_iterator_by_category
< std::random_access_iterator_tag, Value, Iterator, Function >& it )
{
return it + n;
}
template<typename Value, typename Iterator, typename Function>
wrapped_iterator_by_category
<std::random_access_iterator_tag, Value, Iterator, Function>
operator-
( int n,
const wrapped_iterator_by_category
< std::random_access_iterator_tag, Value, Iterator, Function >& it )
{
return it - n;
}
/*-------------------------------------------------------------------------*/
template <typename Value, typename Iterator, typename Function>
class wrapped_iterator
{
public:
typedef wrapped_iterator_by_category
< typename std::iterator_traits<Iterator>::iterator_category,
Value, Iterator, Function >
iterator_type;
}; // class wrapped_iterator
} // namespace claw
#endif // __CLAW_ITERATOR_HPP__
claw::wrapped_iterator_by_category< std::forward_iterator_tag, Value, Iterator, Function >
Base class for wrapped iterators, specialized for forward iterators.
Definition: iterator.hpp:56
std
Definition: gif.hpp:461
claw::wrapped_iterator_by_category< std::random_access_iterator_tag, Value, Iterator, Function >
Base class for wrapped iterators, specialized for random iterators.
Definition: iterator.hpp:209
claw::wrapped_iterator::iterator_type
wrapped_iterator_by_category< typename std::iterator_traits< Iterator >::iterator_category, Value, Iterator, Function > iterator_type
This is the type of the iterator that you want.
Definition: iterator.hpp:368
claw::wrapped_iterator
This class defines an iterator resulting of the appliance of a function to an effective iterator...
Definition: iterator.hpp:361
claw::wrapped_iterator_by_category
Base class for wrapped iterators.
Definition: iterator.hpp:45
claw
This is the main namespace.
Definition: algorithm.hpp:33
claw::wrapped_iterator_by_category< std::bidirectional_iterator_tag, Value, Iterator, Function >
Base class for wrapped iterators, specialized for bidirectional iterators.
Definition: iterator.hpp:127
operator+
claw::graphic::image::base_iterator< ImageT, PixelT >::self_type operator+(int n, const typename claw::graphic::image::base_iterator< ImageT, PixelT >::self_type &self)
Get an iterator at a specific distance of the current iterator.
Definition: image.ipp:261