/usr/include/boost/multi_index/detail
Edit: /usr/include/boost/multi_index/detail/iter_adaptor.hpp (7591B)
/* Copyright 2003-2013 Joaquin M Lopez Munoz.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* See http://www.boost.org/libs/multi_index for library home page.
*/
#ifndef BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
#define BOOST_MULTI_INDEX_DETAIL_ITER_ADAPTOR_HPP
#if defined(_MSC_VER)
#pragma once
#endif
#include
/* keep it first to prevent nasty warns in MSVC */
#include
#include
namespace boost{
namespace multi_index{
namespace detail{
/* Poor man's version of boost::iterator_adaptor. Used instead of the
* original as compile times for the latter are significantly higher.
* The interface is not replicated exactly, only to the extent necessary
* for internal consumption.
*/
/* NB. The purpose of the (non-inclass) global operators ==, < and - defined
* above is to partially alleviate a problem of MSVC++ 6.0 by * which
* friend-injected operators on T are not visible if T is instantiated only
* in template code where T is a dependent type.
*/
class iter_adaptor_access
{
public:
template
static typename Class::reference dereference(const Class& x)
{
return x.dereference();
}
template
static bool equal(const Class& x,const Class& y)
{
return x.equal(y);
}
template
static void increment(Class& x)
{
x.increment();
}
template
static void decrement(Class& x)
{
x.decrement();
}
template
static void advance(Class& x,typename Class::difference_type n)
{
x.advance(n);
}
template
static typename Class::difference_type distance_to(
const Class& x,const Class& y)
{
return x.distance_to(y);
}
};
template
struct iter_adaptor_selector;
template
class forward_iter_adaptor_base:
public forward_iterator_helper<
Derived,
typename Base::value_type,
typename Base::difference_type,
typename Base::pointer,
typename Base::reference>
{
public:
typedef typename Base::reference reference;
reference operator*()const
{
return iter_adaptor_access::dereference(final());
}
friend bool operator==(const Derived& x,const Derived& y)
{
return iter_adaptor_access::equal(x,y);
}
Derived& operator++()
{
iter_adaptor_access::increment(final());
return final();
}
private:
Derived& final(){return *static_cast(this);}
const Derived& final()const{return *static_cast(this);}
};
template
bool operator==(
const forward_iter_adaptor_base& x,
const forward_iter_adaptor_base& y)
{
return iter_adaptor_access::equal(
static_cast(x),static_cast(y));
}
template<>
struct iter_adaptor_selector
{
template
struct apply
{
typedef forward_iter_adaptor_base type;
};
};
template
class bidirectional_iter_adaptor_base:
public bidirectional_iterator_helper<
Derived,
typename Base::value_type,
typename Base::difference_type,
typename Base::pointer,
typename Base::reference>
{
public:
typedef typename Base::reference reference;
reference operator*()const
{
return iter_adaptor_access::dereference(final());
}
friend bool operator==(const Derived& x,const Derived& y)
{
return iter_adaptor_access::equal(x,y);
}
Derived& operator++()
{
iter_adaptor_access::increment(final());
return final();
}
Derived& operator--()
{
iter_adaptor_access::decrement(final());
return final();
}
private:
Derived& final(){return *static_cast(this);}
const Derived& final()const{return *static_cast(this);}
};
template
bool operator==(
const bidirectional_iter_adaptor_base& x,
const bidirectional_iter_adaptor_base& y)
{
return iter_adaptor_access::equal(
static_cast(x),static_cast(y));
}
template<>
struct iter_adaptor_selector
{
template
struct apply
{
typedef bidirectional_iter_adaptor_base type;
};
};
template
class random_access_iter_adaptor_base:
public random_access_iterator_helper<
Derived,
typename Base::value_type,
typename Base::difference_type,
typename Base::pointer,
typename Base::reference>
{
public:
typedef typename Base::reference reference;
typedef typename Base::difference_type difference_type;
reference operator*()const
{
return iter_adaptor_access::dereference(final());
}
friend bool operator==(const Derived& x,const Derived& y)
{
return iter_adaptor_access::equal(x,y);
}
friend bool operator<(const Derived& x,const Derived& y)
{
return iter_adaptor_access::distance_to(x,y)>0;
}
Derived& operator++()
{
iter_adaptor_access::increment(final());
return final();
}
Derived& operator--()
{
iter_adaptor_access::decrement(final());
return final();
}
Derived& operator+=(difference_type n)
{
iter_adaptor_access::advance(final(),n);
return final();
}
Derived& operator-=(difference_type n)
{
iter_adaptor_access::advance(final(),-n);
return final();
}
friend difference_type operator-(const Derived& x,const Derived& y)
{
return iter_adaptor_access::distance_to(y,x);
}
private:
Derived& final(){return *static_cast(this);}
const Derived& final()const{return *static_cast(this);}
};
template
bool operator==(
const random_access_iter_adaptor_base& x,
const random_access_iter_adaptor_base& y)
{
return iter_adaptor_access::equal(
static_cast(x),static_cast(y));
}
template
bool operator<(
const random_access_iter_adaptor_base& x,
const random_access_iter_adaptor_base& y)
{
return iter_adaptor_access::distance_to(
static_cast(x),static_cast(y))>0;
}
template
typename random_access_iter_adaptor_base::difference_type
operator-(
const random_access_iter_adaptor_base& x,
const random_access_iter_adaptor_base& y)
{
return iter_adaptor_access::distance_to(
static_cast(y),static_cast(x));
}
template<>
struct iter_adaptor_selector
{
template
struct apply
{
typedef random_access_iter_adaptor_base type;
};
};
template
struct iter_adaptor_base
{
typedef iter_adaptor_selector<
typename Base::iterator_category> selector;
typedef typename mpl::apply2<
selector,Derived,Base>::type type;
};
template
class iter_adaptor:public iter_adaptor_base::type
{
protected:
iter_adaptor(){}
explicit iter_adaptor(const Base& b_):b(b_){}
const Base& base_reference()const{return b;}
Base& base_reference(){return b;}
private:
Base b;
};
} /* namespace multi_index::detail */
} /* namespace multi_index */
} /* namespace boost */
#endif