// Boost token_iterator.hpp  -------------------------------------------------//

 // Copyright John R. Bandela 2001

 // 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/tokenizer for documentation.

 // Revision History:

 // 16 Jul 2003   John Bandela

 //      Allowed conversions from convertible base iterators

 // 03 Jul 2003   John Bandela

 //      Converted to new iterator adapter

 #ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_

 #define BOOST_TOKENIZER_POLICY_JRB070303_HPP_

 #include<boost/assert.hpp>

 #include<boost/iterator/iterator_adaptor.hpp>

 #include<boost/iterator/detail/minimum_category.hpp>

 #include<boost/token_functions.hpp>

 #include<utility>

 namespace boost

 {

   template <class TokenizerFunc, class Iterator, class Type>

   class token_iterator

       : public iterator_facade<

             token_iterator<TokenizerFunc, Iterator, Type>

           , Type

           , typename detail::minimum_category<

                 forward_traversal_tag

               , typename iterator_traversal<Iterator>::type

             >::type 

           , const Type&

         >

   {

       friend class iterator_core_access;

       TokenizerFunc f_;

       Iterator begin_;

       Iterator end_;

       bool valid_;

       Type tok_;

       void increment(){

           BOOST_ASSERT(valid_);

           valid_ = f_(begin_,end_,tok_);

       }

       const Type&  dereference() const {

           BOOST_ASSERT(valid_);

           return tok_;

       }

       template<class Other>

       bool equal(const Other& a) const{

           return (a.valid_ && valid_)

               ?( (a.begin_==begin_) && (a.end_ == end_) )

               :(a.valid_==valid_);

       }

       void initialize(){

           if(valid_) return;

           f_.reset();

           valid_ = (begin_ != end_)?

               f_(begin_,end_,tok_):false;

       }

   public:

       token_iterator():begin_(),end_(),valid_(false),tok_() { }

       token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator())

           : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); }

       token_iterator(Iterator begin, Iterator e = Iterator())

             : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();}

       template<class OtherIter>

       token_iterator(

             token_iterator<TokenizerFunc, OtherIter,Type> const& t

             , typename enable_if_convertible<OtherIter, Iterator>::type* = 0)

             : f_(t.tokenizer_function()),begin_(t.base())

             ,end_(t.end()),valid_(t.at_end()),tok_(t.current_token()) {}

       Iterator base()const{return begin_;}

       Iterator end()const{return end_;};

       TokenizerFunc tokenizer_function()const{return f_;}

       Type current_token()const{return tok_;}

       bool at_end()const{return valid_;}

   };

     template <

         class TokenizerFunc = char_delimiters_separator<char>, 

         class Iterator = std::string::const_iterator,

         class Type = std::string

     >

     class token_iterator_generator {

     private: 

     public:

         typedef token_iterator<TokenizerFunc,Iterator,Type> type;

     };

     // Type has to be first because it needs to be explicitly specified

     // because there is no way the function can deduce it.

     template<class Type, class Iterator, class TokenizerFunc>

         typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type 

     make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){

         typedef typename 

             token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;

         return ret_type(fun,begin,end);

     }

 } // namespace boost

 #endif