path: root/boost/wave/util/unput_queue_iterator.hpp

/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library

    Definition of the unput queue iterator
    
    http://www.boost.org/

    Copyright (c) 2001-2011 Hartmut Kaiser. 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)
=============================================================================*/
#if !defined(UNPUT_QUEUE_ITERATOR_HPP_76DA23D0_4893_4AD5_ABCC_6CED7CFB89BC_INCLUDED)
#define UNPUT_QUEUE_ITERATOR_HPP_76DA23D0_4893_4AD5_ABCC_6CED7CFB89BC_INCLUDED

#include <list>

#include <boost/assert.hpp>
#include <boost/iterator_adaptors.hpp>

#include <boost/wave/wave_config.hpp>
#include <boost/wave/token_ids.hpp>     // token_id 

// this must occur after all of the includes and before any code appears
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_PREFIX
#endif

///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {
namespace util {

///////////////////////////////////////////////////////////////////////////////
//
//  unput_queue_iterator
//
//      The unput_queue_iterator templates encapsulates an unput_queue together
//      with the direct input to be read after the unput queue is emptied
//
//      This version is for the new iterator_adaptors (was released with
//      Boost V1.31.0)
//
///////////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename TokenT, typename ContainerT>
class unput_queue_iterator 
:   public boost::iterator_adaptor<
        unput_queue_iterator<IteratorT, TokenT, ContainerT>, 
            IteratorT, TokenT const, std::forward_iterator_tag>
{
    typedef boost::iterator_adaptor<
                unput_queue_iterator<IteratorT, TokenT, ContainerT>, 
                IteratorT, TokenT const, std::forward_iterator_tag>
        base_type;

public:
    typedef ContainerT  container_type;
    typedef IteratorT   iterator_type;

    unput_queue_iterator(IteratorT const &it, ContainerT &queue)
    :   base_type(it), unput_queue(queue)
    {}
    
    ContainerT &get_unput_queue() 
        { return unput_queue; }
    ContainerT const &get_unput_queue() const 
        { return unput_queue; }
    IteratorT &get_base_iterator() 
        { return base_type::base_reference(); }
    IteratorT const &get_base_iterator() const 
        { return base_type::base_reference(); }
    
    unput_queue_iterator &operator= (unput_queue_iterator const &rhs)
    { 
        if (this != &rhs) {
            unput_queue = rhs.unput_queue; 
            base_type::operator=(rhs);
        }
        return *this; 
    }

    typename base_type::reference dereference() const
    {
        if (!unput_queue.empty())
            return unput_queue.front();
        return *base_type::base_reference(); 
    }

    void increment()
    { 
        if (!unput_queue.empty()) {
        // there exist pending tokens in the unput queue
            unput_queue.pop_front();
        }
        else {
        // the unput_queue is empty, so advance the base iterator
            ++base_type::base_reference(); 
        }
    }

    template <
        typename OtherDerivedT, typename OtherIteratorT, 
        typename V, typename C, typename R, typename D
    >   
    bool equal(
        boost::iterator_adaptor<OtherDerivedT, OtherIteratorT, V, C, R, D> 
        const &x) const
    {
    // two iterators are equal, if both begin() iterators of the queue 
    // objects are equal and the base iterators are equal as well
        OtherDerivedT const &rhs = static_cast<OtherDerivedT const &>(x);
        return 
            ((unput_queue.empty() && rhs.unput_queue.empty()) ||
              (&unput_queue == &rhs.unput_queue &&
               unput_queue.begin() == rhs.unput_queue.begin()
              )
            ) &&
            (get_base_iterator() == rhs.get_base_iterator()); 
    }

private:
    ContainerT &unput_queue;
};

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_type(it.base(), last);
        }

        static return_type 
        generate(ContainerT &queue, iterator_type &it)
        {
            return return_type(it.base(), queue);
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    template <typename IteratorT>
    struct assign_iterator 
    {
        static void 
        do_ (IteratorT &dest, IteratorT const &src)
        {
            dest = src;
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    //
    // 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);
        }
    };

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

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

// the suffix header occurs after all of the code
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif

#endif // !defined(UNPUT_QUEUE_ITERATOR_HPP_76DA23D0_4893_4AD5_ABCC_6CED7CFB89BC_INCLUDED)