unput_queue_iterator.hpp

C++的一个好库。。。现在很流行

namespace impl {

    ///////////////////////////////////////////////////////////////////////////
    template <typename IteratorT, typename TokenT, typename ContainerT>
    struct gen_unput_queue_iterator 
    {
        typedef ContainerT  container_type;
        typedef IteratorT iterator_type;
        typedef unput_queue_iterator<IteratorT, TokenT, ContainerT> 
            return_type;
                
        static container_type last;
        
        static return_type
        generate(iterator_type const &it)
        {
            return return_type(it, last);
        }

        static return_type
        generate(ContainerT &queue, iterator_type const &it)
        {
            return return_type(it, queue);
        }
    };
    
    template <typename IteratorT, typename TokenT, typename ContainerT>
    typename gen_unput_queue_iterator<IteratorT, TokenT, ContainerT>::
          container_type  
        gen_unput_queue_iterator<IteratorT, TokenT, ContainerT>::last = 
            typename gen_unput_queue_iterator<IteratorT, TokenT, ContainerT>::
                  container_type();

    ///////////////////////////////////////////////////////////////////////////
    template <typename IteratorT, typename TokenT, typename ContainerT>
    struct gen_unput_queue_iterator<
        unput_queue_iterator<IteratorT, TokenT, ContainerT>, 
            TokenT, ContainerT> 
    {
        typedef ContainerT  container_type;
        typedef unput_queue_iterator<IteratorT, TokenT, ContainerT> 
            iterator_type;
        typedef unput_queue_iterator<IteratorT, TokenT, ContainerT> 
            return_type;
        
        static container_type last;
        
        static return_type 
        generate(iterator_type &it)
        {
            return return_t(it.base(), last);
        }

        static return_type 
        generate(ContainerT &queue, iterator_type &it)
        {
            return return_t(it.base(), queue);
        }
    };
    
    ///////////////////////////////////////////////////////////////////////////
    template <typename IteratorT>
    struct assign_iterator {
    
        static void 
        do_ (IteratorT &dest, IteratorT const &src)
        {
            dest = src;
        }
    };
    
#if !defined(BOOST_ITERATOR_ADAPTORS_VERSION) || \
    BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200
    
    template <typename IteratorT, typename TokenT, typename ContainerT>
    struct assign_iterator<
        unput_queue_iterator<IteratorT, TokenT, ContainerT> > 
    {
        typedef unput_queue_iterator<IteratorT, TokenT, ContainerT> 
            iterator_type;
        
        static void 
        do_ (iterator_type &dest, iterator_type const &src)
        {
            dest.base() = src.base();
            dest.policies() = src.policies();
        }
    };
    
#endif // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200

    ///////////////////////////////////////////////////////////////////////////
    //
    // Look for the first non-whitespace token and return this token id.
    // Note though, that the embedded unput_queues are not touched in any way!
    //
    template <typename IteratorT>
    struct next_token {
    
        static boost::wave::token_id  
        peek(IteratorT it, IteratorT end, bool skip_whitespace = true)
        {
            using namespace boost::wave;
            if (skip_whitespace) {
                for (++it; it != end; ++it) {
                    if (!IS_CATEGORY(*it, WhiteSpaceTokenType) &&
                        T_NEWLINE != token_id(*it))
                    {
                        break;  // stop at the first non-whitespace token
                    }
                }
            }
            else {
                ++it;           // we have at least to look ahead
            }
            if (it != end) 
                return token_id(*it);
            return T_EOI;
        }
    };
    
    template <typename IteratorT, typename TokenT, typename ContainerT>
    struct next_token<
        unput_queue_iterator<IteratorT, TokenT, ContainerT> > {
        
        typedef unput_queue_iterator<IteratorT, TokenT, ContainerT> iterator_type;
        
        static boost::wave::token_id 
        peek(iterator_type it, iterator_type end, bool skip_whitespace = true)
        {
            using namespace boost::wave;
            
        typename iterator_type::container_type &queue = it.get_unput_queue();
        
        // first try to find it in the unput_queue
            if (0 != queue.size()) {
            typename iterator_type::container_type::iterator cit = queue.begin();
            typename iterator_type::container_type::iterator cend = queue.end();

                if (skip_whitespace) {            
                    for (++cit; cit != cend; ++cit) {
                        if (!IS_CATEGORY(*cit, WhiteSpaceTokenType) &&
                            T_NEWLINE != token_id(*cit))
                        {
                            break;  // stop at the first non-whitespace token
                        }
                    }
                }
                else {
                    ++cit;          // we have at least to look ahead
                }
                if (cit != cend) 
                    return token_id(*cit);
            }
            
        // second try to move on into the base iterator stream
        typename iterator_type::iterator_type base_it = it.get_base_iterator();
        typename iterator_type::iterator_type base_end = end.get_base_iterator();

            if (0 == queue.size())
                ++base_it;  // advance, if the unput queue is empty

            if (skip_whitespace) {
                for (/**/; base_it != base_end; ++base_it) {
                    if (!IS_CATEGORY(*base_it, WhiteSpaceTokenType) &&
                        T_NEWLINE != token_id(*base_it))
                    {
                        break;  // stop at the first non-whitespace token
                    }
                }
            }
            if (base_it == base_end)
                return T_EOI;

            return token_id(*base_it);
        }
    };

    // Skip all whitespace characters and queue the skipped characters into the
    // given container
    template <typename IteratorT>
    inline boost::wave::token_id 
    skip_whitespace(IteratorT &first, IteratorT const &last)
    {
        using namespace cpplexer;
        
    token_id id = next_token<IteratorT>::peek(first, last, false);

        if (IS_CATEGORY(id, WhiteSpaceTokenType)) {
            do {
                ++first;
                id = next_token<IteratorT>::peek(first, last, false);
            } while (IS_CATEGORY(id, WhiteSpaceTokenType));
        }
        ++first;
        return id;
    }
    
    template <typename IteratorT, typename ContainerT>
    inline boost::wave::token_id 
    skip_whitespace(IteratorT &first, IteratorT const &last, ContainerT &queue)
    {
        using namespace cpplexer;
        queue.push_back (*first);       // queue up the current token
        
    token_id id = next_token<IteratorT>::peek(first, last, false);

        if (IS_CATEGORY(id, WhiteSpaceTokenType)) {
            do {
                queue.push_back(*++first);  // queue up the next whitespace 
                id = next_token<IteratorT>::peek(first, last, false);
            } while (IS_CATEGORY(id, WhiteSpaceTokenType));
        }
        ++first;
        return id;
    }

///////////////////////////////////////////////////////////////////////////////
}   // namespace impl

///////////////////////////////////////////////////////////////////////////////
}   // namespace util
}   // namespace wave
}   // namespace boost

#endif // !defined(UNPUT_QUEUE_ITERATOR_HPP_76DA23D0_4893_4AD5_ABCC_6CED7CFB89BC_INCLUDED)