PageRenderTime 30ms CodeModel.GetById 15ms app.highlight 11ms RepoModel.GetById 2ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/spirit/home/support/iterators/detail/functor_input_policy.hpp

http://hadesmem.googlecode.com/
C++ Header | 114 lines | 77 code | 17 blank | 20 comment | 3 complexity | 5b1cbaf0145784f46ae2a8298a870534 MD5 | raw file
  1//  Copyright (c) 2001-2011 Hartmut Kaiser
  2// 
  3//  Distributed under the Boost Software License, Version 1.0. (See accompanying
  4//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5
  6#if !defined(BOOST_SPIRIT_ITERATOR_SPLIT_FUNCTOR_INPUT_POLICY_JAN_16_2008_0448M)
  7#define BOOST_SPIRIT_ITERATOR_SPLIT_FUNCTOR_INPUT_POLICY_JAN_16_2008_0448M
  8
  9#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
 10#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>
 11#include <boost/assert.hpp>
 12
 13namespace boost { namespace spirit { namespace iterator_policies
 14{
 15    namespace is_valid_test_
 16    {
 17        template <typename Token>
 18        inline bool token_is_valid(Token const&)
 19        {
 20            return true;
 21        }
 22    }
 23
 24    ///////////////////////////////////////////////////////////////////////////
 25    //  class functor_input
 26    //  Implementation of the InputPolicy used by multi_pass
 27    //  functor_input gets tokens from a functor
 28    // 
 29    //  Note: the functor must have a typedef for result_type
 30    //        It also must have a static variable of type result_type defined 
 31    //        to represent EOF that is called eof.
 32    //
 33    ///////////////////////////////////////////////////////////////////////////
 34    struct functor_input
 35    {
 36        ///////////////////////////////////////////////////////////////////////
 37        template <typename Functor>
 38        class unique : public detail::default_input_policy
 39        {
 40        private:
 41            typedef typename Functor::result_type result_type;
 42
 43        protected:
 44            unique() {}
 45            explicit unique(Functor const& x) : ftor(x) {}
 46
 47            void swap(unique& x)
 48            {
 49                boost::swap(ftor, x.ftor);
 50            }
 51
 52        public:
 53            typedef result_type value_type;
 54            typedef std::ptrdiff_t difference_type;
 55            typedef std::ptrdiff_t distance_type;
 56            typedef result_type* pointer;
 57            typedef result_type& reference;
 58
 59        public:
 60            // get the next token
 61            template <typename MultiPass>
 62            static typename MultiPass::reference get_input(MultiPass& mp)
 63            {
 64                value_type& curtok = mp.shared()->curtok;
 65                if (!input_is_valid(mp, curtok))
 66                    curtok = mp.ftor();
 67                return curtok;
 68            }
 69
 70            template <typename MultiPass>
 71            static void advance_input(MultiPass& mp)
 72            {
 73                // if mp.shared is NULL then this instance of the multi_pass 
 74                // represents a end iterator
 75                BOOST_ASSERT(0 != mp.shared());
 76                mp.shared()->curtok = mp.ftor();
 77            }
 78
 79            // test, whether we reached the end of the underlying stream
 80            template <typename MultiPass>
 81            static bool input_at_eof(MultiPass const& mp) 
 82            {
 83                return mp.shared()->curtok == mp.ftor.eof;
 84            }
 85
 86            template <typename MultiPass>
 87            static bool input_is_valid(MultiPass const&, value_type const& t) 
 88            {
 89                using namespace is_valid_test_;
 90                return token_is_valid(t);
 91            }
 92
 93            Functor& get_functor() const
 94            {
 95                return ftor;
 96            }
 97
 98        protected:
 99            mutable Functor ftor;
100        };
101
102        ///////////////////////////////////////////////////////////////////////
103        template <typename Functor>
104        struct shared
105        {
106            explicit shared(Functor const&) : curtok(0) {}
107
108            typename Functor::result_type curtok;
109        };
110    };
111
112}}}
113
114#endif