/src/contrib/boost/token_iterator.hpp

  1// Boost token_iterator.hpp  -------------------------------------------------//
  2
  3// Copyright John R. Bandela 2001
  4// Distributed under the Boost Software License, Version 1.0. (See
  5// accompanying file LICENSE_1_0.txt or copy at
  6// http://www.boost.org/LICENSE_1_0.txt)
  7
  8// See http://www.boost.org/libs/tokenizer for documentation.
  9
 10// Revision History:
 11// 16 Jul 2003   John Bandela
 12//      Allowed conversions from convertible base iterators
 13// 03 Jul 2003   John Bandela
 14//      Converted to new iterator adapter
 15
 16
 17
 18#ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_
 19#define BOOST_TOKENIZER_POLICY_JRB070303_HPP_
 20
 21#include<boost/assert.hpp>
 22#include<boost/iterator/iterator_adaptor.hpp>
 23#include<boost/iterator/detail/minimum_category.hpp>
 24#include<boost/token_functions.hpp>
 25#include<utility>
 26
 27namespace boost
 28{
 29  template <class TokenizerFunc, class Iterator, class Type>
 30  class token_iterator
 31      : public iterator_facade<
 32            token_iterator<TokenizerFunc, Iterator, Type>
 33          , Type
 34          , typename detail::minimum_category<
 35                forward_traversal_tag
 36              , typename iterator_traversal<Iterator>::type
 37            >::type 
 38          , const Type&
 39        >
 40  {
 41
 42      friend class iterator_core_access;
 43
 44      TokenizerFunc f_;
 45      Iterator begin_;
 46      Iterator end_;
 47      bool valid_;
 48      Type tok_;
 49
 50      void increment(){
 51          BOOST_ASSERT(valid_);
 52          valid_ = f_(begin_,end_,tok_);
 53      }
 54
 55      const Type&  dereference() const {
 56          BOOST_ASSERT(valid_);
 57          return tok_;
 58      }
 59      template<class Other>
 60      bool equal(const Other& a) const{
 61          return (a.valid_ && valid_)
 62              ?( (a.begin_==begin_) && (a.end_ == end_) )
 63              :(a.valid_==valid_);
 64
 65      }
 66
 67      void initialize(){
 68          if(valid_) return;
 69          f_.reset();
 70          valid_ = (begin_ != end_)?
 71              f_(begin_,end_,tok_):false;
 72      }
 73  public:
 74      token_iterator():begin_(),end_(),valid_(false),tok_() { }
 75
 76      token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator())
 77          : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); }
 78
 79      token_iterator(Iterator begin, Iterator e = Iterator())
 80            : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();}
 81
 82      template<class OtherIter>
 83      token_iterator(
 84            token_iterator<TokenizerFunc, OtherIter,Type> const& t
 85            , typename enable_if_convertible<OtherIter, Iterator>::type* = 0)
 86            : f_(t.tokenizer_function()),begin_(t.base())
 87            ,end_(t.end()),valid_(!t.at_end()),tok_(t.current_token()) {}
 88
 89      Iterator base()const{return begin_;}
 90
 91      Iterator end()const{return end_;};
 92
 93      TokenizerFunc tokenizer_function()const{return f_;}
 94
 95      Type current_token()const{return tok_;}
 96
 97      bool at_end()const{return !valid_;}
 98
 99
100
101
102  };
103    template <
104        class TokenizerFunc = char_delimiters_separator<char>, 
105        class Iterator = std::string::const_iterator,
106        class Type = std::string
107    >
108    class token_iterator_generator {
109
110    private: 
111    public:
112        typedef token_iterator<TokenizerFunc,Iterator,Type> type;
113    };
114    
115    
116    // Type has to be first because it needs to be explicitly specified
117    // because there is no way the function can deduce it.
118    template<class Type, class Iterator, class TokenizerFunc>
119        typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type 
120    make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
121        typedef typename 
122            token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
123        return ret_type(fun,begin,end);
124    }
125
126} // namespace boost
127
128#endif