PageRenderTime 20ms CodeModel.GetById 10ms app.highlight 7ms RepoModel.GetById 2ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/xpressive/detail/core/results_cache.hpp

http://hadesmem.googlecode.com/
C++ Header | 134 lines | 97 code | 18 blank | 19 comment | 8 complexity | ed077559a9fc25464a914da9b76ab4c5 MD5 | raw file
  1///////////////////////////////////////////////////////////////////////////////
  2// results_cache.hpp
  3//
  4//  Copyright 2008 Eric Niebler. Distributed under the Boost
  5//  Software License, Version 1.0. (See accompanying file
  6//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7
  8#ifndef BOOST_XPRESSIVE_DETAIL_CORE_RESULTS_CACHE_HPP_EAN_10_04_2005
  9#define BOOST_XPRESSIVE_DETAIL_CORE_RESULTS_CACHE_HPP_EAN_10_04_2005
 10
 11// MS compatible compilers support #pragma once
 12#if defined(_MSC_VER) && (_MSC_VER >= 1020)
 13# pragma once
 14#endif
 15
 16#include <cstddef>
 17#include <boost/detail/workaround.hpp>
 18#include <boost/assert.hpp>
 19#include <boost/xpressive/detail/detail_fwd.hpp>
 20#include <boost/xpressive/detail/core/list.hpp>
 21#include <boost/xpressive/detail/core/access.hpp>
 22#include <boost/xpressive/match_results.hpp>
 23
 24namespace boost { namespace xpressive { namespace detail
 25{
 26
 27    ///////////////////////////////////////////////////////////////////////////////
 28    // nested_results
 29    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
 30    template<typename BidiIter>
 31    struct nested_results
 32      : detail::list<match_results<BidiIter> >
 33    {
 34        friend struct results_cache<BidiIter>;
 35        friend struct match_results<BidiIter>;
 36    };
 37    #else
 38    template<typename BidiIter>
 39    struct nested_results
 40      : private detail::list<match_results<BidiIter> >
 41    {
 42        friend struct results_cache<BidiIter>;
 43        friend struct xpressive::match_results<BidiIter>;
 44        typedef list<xpressive::match_results<BidiIter> > base_type;
 45
 46        typedef typename base_type::iterator iterator;
 47        typedef typename base_type::const_iterator const_iterator;
 48        typedef typename base_type::pointer pointer;
 49        typedef typename base_type::const_pointer const_pointer;
 50        typedef typename base_type::reference reference;
 51        typedef typename base_type::const_reference const_reference;
 52        typedef typename base_type::size_type size_type;
 53        using base_type::begin;
 54        using base_type::end;
 55        using base_type::size;
 56        using base_type::empty;
 57        using base_type::front;
 58        using base_type::back;
 59    };
 60    #endif
 61
 62    ///////////////////////////////////////////////////////////////////////////////
 63    // results_cache
 64    //
 65    //   cache storage for reclaimed match_results structs
 66    template<typename BidiIter>
 67    struct results_cache
 68    {
 69        typedef core_access<BidiIter> access;
 70
 71        match_results<BidiIter> &append_new(nested_results<BidiIter> &out)
 72        {
 73            if(this->cache_.empty())
 74            {
 75                out.push_back(match_results<BidiIter>());
 76            }
 77            else
 78            {
 79                BOOST_ASSERT(access::get_nested_results(this->cache_.back()).empty());
 80                out.splice(out.end(), this->cache_, --this->cache_.end());
 81            }
 82            return out.back();
 83        }
 84
 85        // move the last match_results struct into the cache
 86        void reclaim_last(nested_results<BidiIter> &out)
 87        {
 88            BOOST_ASSERT(!out.empty());
 89            // first, reclaim any nested results
 90            nested_results<BidiIter> &nested = access::get_nested_results(out.back());
 91            if(!nested.empty())
 92            {
 93                this->reclaim_all(nested);
 94            }
 95            // then, reclaim the last match_results
 96            this->cache_.splice(this->cache_.end(), out, --out.end());
 97        }
 98
 99        // move the last n match_results structs into the cache
100        void reclaim_last_n(nested_results<BidiIter> &out, std::size_t count)
101        {
102            for(; 0 != count; --count)
103            {
104                this->reclaim_last(out);
105            }
106        }
107
108        void reclaim_all(nested_results<BidiIter> &out)
109        {
110            typedef typename nested_results<BidiIter>::iterator iter_type;
111
112            // first, recursively reclaim all the nested results
113            for(iter_type begin = out.begin(); begin != out.end(); ++begin)
114            {
115                nested_results<BidiIter> &nested = access::get_nested_results(*begin);
116
117                if(!nested.empty())
118                {
119                    this->reclaim_all(nested);
120                }
121            }
122
123            // next, reclaim the results themselves
124            this->cache_.splice(this->cache_.end(), out);
125        }
126
127    private:
128
129        nested_results<BidiIter> cache_;
130    };
131
132}}} // namespace boost::xpressive::detail
133
134#endif