// 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