| /*-----------------------------------------------------------------------------+ |
| Copyright (c) 2009-2009: Joachim Faulhaber |
| +------------------------------------------------------------------------------+ |
| Distributed under the Boost Software License, Version 1.0. |
| (See accompanying file LICENCE.txt or copy at |
| http://www.boost.org/LICENSE_1_0.txt) |
| +-----------------------------------------------------------------------------*/ |
| #ifndef BOOST_ICL_DETAIL_ELEMENT_ITERATOR_HPP_JOFA_091104 |
| #define BOOST_ICL_DETAIL_ELEMENT_ITERATOR_HPP_JOFA_091104 |
| |
| #include <boost/mpl/if.hpp> |
| #include <boost/iterator/iterator_facade.hpp> |
| #include <boost/config/warning_disable.hpp> |
| #include <boost/icl/type_traits/succ_pred.hpp> |
| #include <boost/icl/detail/mapped_reference.hpp> |
| |
| namespace boost{namespace icl |
| { |
| |
| //------------------------------------------------------------------------------ |
| template<class Type> |
| struct is_std_pair |
| { |
| typedef is_std_pair<Type> type; |
| BOOST_STATIC_CONSTANT(bool, value = false); |
| }; |
| |
| template<class FirstT, class SecondT> |
| struct is_std_pair<std::pair<FirstT, SecondT> > |
| { |
| typedef is_std_pair<std::pair<FirstT, SecondT> > type; |
| BOOST_STATIC_CONSTANT(bool, value = true); |
| }; |
| |
| |
| //------------------------------------------------------------------------------ |
| template<class Type> |
| struct first_element |
| { |
| typedef Type type; |
| }; |
| |
| template<class FirstT, class SecondT> |
| struct first_element<std::pair<FirstT, SecondT> > |
| { |
| typedef FirstT type; |
| }; |
| |
| //------------------------------------------------------------------------------ |
| template <class SegmentIteratorT> class element_iterator; |
| |
| template<class IteratorT> |
| struct is_reverse |
| { |
| typedef is_reverse type; |
| BOOST_STATIC_CONSTANT(bool, value = false); |
| }; |
| |
| template<class BaseIteratorT> |
| struct is_reverse<std::reverse_iterator<BaseIteratorT> > |
| { |
| typedef is_reverse<std::reverse_iterator<BaseIteratorT> > type; |
| BOOST_STATIC_CONSTANT(bool, value = true); |
| }; |
| |
| template<class BaseIteratorT> |
| struct is_reverse<icl::element_iterator<BaseIteratorT> > |
| { |
| typedef is_reverse<icl::element_iterator<BaseIteratorT> > type; |
| BOOST_STATIC_CONSTANT(bool, value = is_reverse<BaseIteratorT>::value); |
| }; |
| |
| //------------------------------------------------------------------------------ |
| template<class SegmentT> |
| struct elemental; |
| |
| #ifdef ICL_USE_INTERVAL_TEMPLATE_TEMPLATE |
| |
| template<class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval> |
| struct elemental<ICL_INTERVAL_TYPE(Interval,DomainT,Compare) > |
| { |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type; |
| typedef segment_type interval_type; |
| typedef DomainT type; |
| typedef DomainT domain_type; |
| typedef DomainT codomain_type; |
| typedef DomainT transit_type; |
| }; |
| |
| template< class DomainT, class CodomainT, |
| ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval > |
| struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> > |
| { |
| typedef std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type; |
| typedef std::pair<DomainT, CodomainT> type; |
| typedef DomainT domain_type; |
| typedef CodomainT codomain_type; |
| typedef mapped_reference<DomainT, CodomainT> transit_type; |
| }; |
| |
| #else //ICL_USE_INTERVAL_TEMPLATE_TYPE |
| |
| template<ICL_INTERVAL(ICL_COMPARE) Interval> |
| struct elemental |
| { |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type; |
| typedef segment_type interval_type; |
| typedef typename interval_traits<interval_type>::domain_type domain_type; |
| typedef domain_type type; |
| typedef domain_type codomain_type; |
| typedef domain_type transit_type; |
| }; |
| |
| template< class CodomainT, ICL_INTERVAL(ICL_COMPARE) Interval > |
| struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> > |
| { |
| typedef std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type; |
| typedef typename interval_traits<interval_type>::domain_type domain_type; |
| typedef CodomainT codomain_type; |
| typedef std::pair<domain_type, codomain_type> type; |
| typedef mapped_reference<domain_type, codomain_type> transit_type; |
| }; |
| |
| #endif //ICL_USE_INTERVAL_TEMPLATE_TEMPLATE |
| |
| |
| //------------------------------------------------------------------------------ |
| //- struct segment_adapter |
| //------------------------------------------------------------------------------ |
| template<class SegmentIteratorT, class SegmentT> |
| struct segment_adapter; |
| |
| #ifdef ICL_USE_INTERVAL_TEMPLATE_TEMPLATE |
| |
| template<class SegmentIteratorT, class DomainT, ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval> |
| struct segment_adapter<SegmentIteratorT, ICL_INTERVAL_TYPE(Interval,DomainT,Compare) > |
| { |
| typedef segment_adapter type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type; |
| typedef segment_type interval_type; |
| typedef typename interval_type::difference_type domain_difference_type; |
| typedef DomainT domain_type; |
| typedef DomainT codomain_type; |
| typedef domain_type element_type; |
| typedef domain_type& transit_type; |
| |
| static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); } |
| static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); } |
| static domain_difference_type length(const SegmentIteratorT& leaper){ return leaper->length();} |
| |
| static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper, |
| const domain_difference_type& sneaker) |
| { |
| inter_pos = is_reverse<SegmentIteratorT>::value ? leaper->last() - sneaker |
| : leaper->first() + sneaker; |
| return inter_pos; |
| } |
| }; |
| |
| template < class SegmentIteratorT, class DomainT, class CodomainT, |
| ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval > |
| struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> > |
| { |
| typedef segment_adapter type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type; |
| typedef DomainT domain_type; |
| typedef std::pair<DomainT, CodomainT> element_type; |
| typedef CodomainT codomain_type; |
| typedef mapped_reference<DomainT, CodomainT> transit_type; |
| typedef typename difference_type_of<interval_traits<interval_type> >::type |
| domain_difference_type; |
| |
| static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); } |
| static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); } |
| static domain_difference_type length(const SegmentIteratorT& leaper){ return leaper->first.length();} |
| |
| static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper, |
| const domain_difference_type& sneaker) |
| { |
| inter_pos = is_reverse<SegmentIteratorT>::value ? leaper->first.last() - sneaker |
| : leaper->first.first() + sneaker; |
| return transit_type(inter_pos, leaper->second); |
| } |
| }; |
| |
| #else // ICL_USE_INTERVAL_TEMPLATE_TYPE |
| |
| template<class SegmentIteratorT, ICL_INTERVAL(ICL_COMPARE) Interval> |
| struct segment_adapter |
| { |
| typedef segment_adapter type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type; |
| typedef segment_type interval_type; |
| typedef typename interval_traits<interval_type>::domain_type domain_type; |
| typedef domain_type codomain_type; |
| typedef domain_type element_type; |
| typedef domain_type& transit_type; |
| typedef typename difference_type_of<interval_traits<interval_type> >::type |
| domain_difference_type; |
| |
| static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); } |
| static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); } |
| static domain_difference_type length(const SegmentIteratorT& leaper){ return icl::length(*leaper);} |
| |
| static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper, |
| const domain_difference_type& sneaker) |
| { |
| inter_pos = is_reverse<SegmentIteratorT>::value ? icl::last(*leaper) - sneaker |
| : icl::first(*leaper) + sneaker; |
| return inter_pos; |
| } |
| }; |
| |
| template < class SegmentIteratorT, class CodomainT, ICL_INTERVAL(ICL_COMPARE) Interval > |
| struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> > |
| { |
| typedef segment_adapter type; |
| typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type; |
| typedef typename interval_traits<interval_type>::domain_type domain_type; |
| typedef CodomainT codomain_type; |
| typedef std::pair<domain_type, codomain_type> element_type; |
| typedef mapped_reference<domain_type, CodomainT> transit_type; |
| typedef typename difference_type_of<interval_traits<interval_type> >::type |
| domain_difference_type; |
| |
| static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); } |
| static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); } |
| static domain_difference_type length(const SegmentIteratorT& leaper){ return icl::length(leaper->first);} |
| |
| static transit_type transient_element(domain_type& inter_pos, const SegmentIteratorT& leaper, |
| const domain_difference_type& sneaker) |
| { |
| inter_pos = is_reverse<SegmentIteratorT>::value ? icl::last(leaper->first) - sneaker |
| : icl::first(leaper->first) + sneaker; |
| return transit_type(inter_pos, leaper->second); |
| } |
| }; |
| |
| #endif // ICL_USE_INTERVAL_TEMPLATE_TEMPLATE |
| |
| template <class SegmentIteratorT> |
| class element_iterator |
| : public boost::iterator_facade< |
| element_iterator<SegmentIteratorT> |
| , typename elemental<typename SegmentIteratorT::value_type>::transit_type |
| , boost::bidirectional_traversal_tag |
| , typename elemental<typename SegmentIteratorT::value_type>::transit_type |
| > |
| { |
| public: |
| typedef element_iterator type; |
| typedef SegmentIteratorT segment_iterator; |
| typedef typename SegmentIteratorT::value_type segment_type; |
| typedef typename first_element<segment_type>::type interval_type; |
| typedef typename elemental<segment_type>::type element_type; |
| typedef typename elemental<segment_type>::domain_type domain_type; |
| typedef typename elemental<segment_type>::codomain_type codomain_type; |
| typedef typename elemental<segment_type>::transit_type transit_type; |
| typedef transit_type value_type; |
| typedef typename difference_type_of<interval_traits<interval_type> >::type |
| domain_difference_type; |
| |
| private: |
| typedef typename segment_adapter<segment_iterator,segment_type>::type adapt; |
| |
| struct enabler{}; |
| |
| public: |
| element_iterator() |
| : _saltator(identity_element<segment_iterator>::value()) |
| , _reptator(identity_element<domain_difference_type>::value()){} |
| |
| explicit element_iterator(segment_iterator jumper) |
| : _saltator(jumper), _reptator(identity_element<domain_difference_type>::value()) {} |
| |
| template <class SaltatorT> |
| element_iterator |
| ( element_iterator<SaltatorT> const& other |
| , typename enable_if<boost::is_convertible<SaltatorT*,SegmentIteratorT*>, enabler>::type = enabler()) |
| : _saltator(other._saltator), _reptator(other._reptator) {} |
| |
| private: |
| friend class boost::iterator_core_access; |
| template <class> friend class element_iterator; |
| |
| template <class SaltatorT> |
| bool equal(element_iterator<SaltatorT> const& other) const |
| { |
| return this->_saltator == other._saltator |
| && this->_reptator == other._reptator; |
| } |
| |
| void increment() |
| { |
| if(_reptator < icl::pred(adapt::length(_saltator))) |
| ++_reptator; |
| else |
| { |
| ++_saltator; |
| _reptator = identity_element<domain_difference_type>::value(); |
| } |
| } |
| |
| void decrement() |
| { |
| if(identity_element<domain_difference_type>::value() < _reptator) |
| --_reptator; |
| else |
| { |
| --_saltator; |
| _reptator = adapt::length(_saltator); |
| --_reptator; |
| } |
| } |
| |
| value_type dereference()const |
| { |
| return adapt::transient_element(_inter_pos, _saltator, _reptator); |
| } |
| |
| private: |
| segment_iterator _saltator; // satltare: to jump : the fast moving iterator |
| mutable domain_difference_type _reptator; // reptare: to sneak : the slow moving iterator 0 based |
| mutable domain_type _inter_pos; // inter position : Position within the current segment |
| // _saltator->first.first() <= _inter_pos <= _saltator->first.last() |
| }; |
| |
| }} // namespace icl boost |
| |
| #endif // BOOST_ICL_DETAIL_ELEMENT_ITERATOR_HPP_JOFA_091104 |
| |
| |
| |