unput_queue_iterator.hpp

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

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

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

    Copyright (c) 2001-2005 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>

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

#if !defined(BOOST_ITERATOR_ADAPTORS_VERSION) || \
    BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200

template <typename TokenT, typename ContainerT>
class unput_queue_policies : public boost::default_iterator_policies
{
public:
    unput_queue_policies(ContainerT &unput_queue_)
    :   unput_queue(unput_queue_)
    {}
    
    unput_queue_policies &operator= (unput_queue_policies const &rhs)
    { 
        unput_queue = rhs.unput_queue; 
        return *this; 
    }
    
    template <typename BaseT>
    void initialize(BaseT &)
    {}

    template <typename IteratorAdaptorT>
    typename IteratorAdaptorT::reference 
    dereference(const IteratorAdaptorT &x) const
    { 
        if (x.policies().unput_queue.size() > 0)
            return x.policies().unput_queue.front();
        return *x.base(); 
    }

    template <typename IteratorAdaptorT>
    void 
    increment(IteratorAdaptorT &x)
    { 
        if (x.policies().unput_queue.size() > 0) {
        // there exist pending tokens in the unput queue
            x.policies().unput_queue.pop_front();
        }
        else {
        // the unput_queue is empty, so advance the base iterator
            ++x.base(); 
        }
    }

    template <typename IteratorAdaptorT1, typename IteratorAdaptorT2>
    bool 
    equal(const IteratorAdaptorT1 &x, const IteratorAdaptorT2 &y) const
    { 
    // two iterators are equal, if both begin() iterators of the queue objects
    // are equal and the base iterators are equal as well
        return 
           (x.policies().unput_queue.begin() == y.policies().unput_queue.begin() ||
            (0 == x.policies().queuesize() && 0 == y.policies().queuesize())) &&
            x.base() == y.base(); 
    }
    
    typename ContainerT::size_type queuesize() const 
    { return unput_queue.size(); }

    ContainerT &get_unput_queue() { return unput_queue; }
    ContainerT const &get_unput_queue() const { return unput_queue; }
    
private:
    ContainerT &unput_queue;
};

///////////////////////////////////////////////////////////////////////////////
//
//  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 old iterator_adaptors (Boost V1.30.x)
//
///////////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename TokenT, typename ContainerT>
class unput_queue_iterator 
:   public boost::iterator_adaptor<
        IteratorT, unput_queue_policies<TokenT, ContainerT>, TokenT, 
        TokenT const &, TokenT const *>
{
    typedef 
        boost::iterator_adaptor<
            IteratorT, unput_queue_policies<TokenT, ContainerT>, TokenT, 
            TokenT const &, TokenT const *
        >
        base_type;
    typedef unput_queue_policies<TokenT, ContainerT> policies_type;
        
public:
    typedef ContainerT  container_type;
    typedef IteratorT   iterator_type;
    
    unput_queue_iterator(IteratorT const &it, ContainerT &queue)
    :   base_type(it, policies_type(queue))
    {}
    
    ContainerT &get_unput_queue() 
        { return policies().get_unput_queue(); }
    ContainerT const &get_unput_queue() const 
        { return policies().get_unput_queue(); }
    IteratorT &get_base_iterator() 
        { return base(); }
    IteratorT const &get_base_iterator() const 
        { return base(); }
};

#else // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200

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

#endif // BOOST_ITERATOR_ADAPTORS_VERSION < 0x0200