FM / detail

/usr/include/boost/spirit/home/support/iterators/detail/

/usr/include/boost/spirit/home/support/iterators/detail

Name	Size	Mode	Actions
buffering_input_iterator_policy.hpp	4295	0644	edit dl rm
buf_id_check_policy.hpp	3303	0644	edit dl rm
combine_policies.hpp	18928	0644	edit dl rm
first_owner_policy.hpp	2426	0644	edit dl rm
fixed_size_queue.hpp	10935	0644	edit dl rm
fixed_size_queue_policy.hpp	5044	0644	edit dl rm
functor_input_policy.hpp	3692	0644	edit dl rm
input_iterator_policy.hpp	3541	0644	edit dl rm
istream_policy.hpp	4030	0644	edit dl rm
lex_input_policy.hpp	2715	0644	edit dl rm
multi_pass.hpp	3244	0644	edit dl rm
no_check_policy.hpp	1166	0644	edit dl rm
ref_counted_policy.hpp	2694	0644	edit dl rm
split_functor_input_policy.hpp	7259	0644	edit dl rm
split_std_deque_policy.hpp	6129	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/support/iterators/detail/istream_policy.hpp (4030B)

#if !defined(BOOST_SPIRIT_ISTREAM_POLICY_JAN_04_2010_0130PM)
#define BOOST_SPIRIT_ISTREAM_POLICY_JAN_04_2010_0130PM

#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp>
#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp>

namespace boost { namespace spirit { namespace iterator_policies
{
    ///////////////////////////////////////////////////////////////////////////
    //  class istream
    //  Implementation of the InputPolicy used by multi_pass
    // 
    //  The istream encapsulates an std::basic_istream
    ///////////////////////////////////////////////////////////////////////////
    struct istream
    {
        ///////////////////////////////////////////////////////////////////////
        template <typename T>
        class unique // : public detail::default_input_policy
        {
        private:
            typedef typename T::char_type result_type;

public:
            typedef typename T::off_type difference_type;
            typedef typename T::off_type distance_type;
            typedef result_type const* pointer;
            typedef result_type const& reference;
            typedef result_type value_type;

protected:
            unique() {}
            explicit unique(T&) {}

void swap(unique&) {}

public:
            template <typename MultiPass>
            static void destroy(MultiPass&) {}

template <typename MultiPass>
            static typename MultiPass::reference get_input(MultiPass& mp)
            {
                if (!mp.shared()->initialized_)
                    mp.shared()->read_one();
                return mp.shared()->curtok_;
            }

template <typename MultiPass>
            static void advance_input(MultiPass& mp)
            {
                // We invalidate the currently cached input character to avoid
                // reading more input from the underlying iterator than 
                // required. Without this we would always read ahead one 
                // character, even if this character never gets consumed by the 
                // client.
                mp.shared()->peek_one();
            }

// test, whether we reached the end of the underlying stream
            template <typename MultiPass>
            static bool input_at_eof(MultiPass const& mp) 
            {
                return mp.shared()->eof_reached_;
            }

template <typename MultiPass>
            static bool input_is_valid(MultiPass const& mp, value_type const&) 
            {
                return mp.shared()->initialized_;
            }

// no unique data elements
        };

///////////////////////////////////////////////////////////////////////
        template <typename T>
        struct shared
        {
        private:
            typedef typename T::char_type result_type;

public:
            explicit shared(T& input) 
              : input_(input), curtok_(-1)
              , initialized_(false), eof_reached_(false) 
            {
                peek_one();   // istreams may be at eof right in the beginning
            }

void read_one()
            {
                if (!(input_ >> curtok_)) {
                    initialized_ = false;
                    eof_reached_ = true;
                }
                else {
                    initialized_ = true;
                }
            }

void peek_one()
            {
                input_.peek();    // try for eof
                initialized_ = false;
                eof_reached_ = input_.eof();
            }

T& input_;
            result_type curtok_;
            bool initialized_;
            bool eof_reached_;
        };
    };

}}}

#endif

// Copyright (c) 2001 Daniel C. Nuffer // 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(BOOST_SPIRIT_ISTREAM_POLICY_JAN_04_2010_0130PM) #define BOOST_SPIRIT_ISTREAM_POLICY_JAN_04_2010_0130PM #include #include namespace boost { namespace spirit { namespace iterator_policies { /////////////////////////////////////////////////////////////////////////// // class istream // Implementation of the InputPolicy used by multi_pass // // The istream encapsulates an std::basic_istream /////////////////////////////////////////////////////////////////////////// struct istream { /////////////////////////////////////////////////////////////////////// template class unique // : public detail::default_input_policy { private: typedef typename T::char_type result_type; public: typedef typename T::off_type difference_type; typedef typename T::off_type distance_type; typedef result_type const* pointer; typedef result_type const& reference; typedef result_type value_type; protected: unique() {} explicit unique(T&) {} void swap(unique&) {} public: template static void destroy(MultiPass&) {} template static typename MultiPass::reference get_input(MultiPass& mp) { if (!mp.shared()->initialized_) mp.shared()->read_one(); return mp.shared()->curtok_; } template static void advance_input(MultiPass& mp) { // We invalidate the currently cached input character to avoid // reading more input from the underlying iterator than // required. Without this we would always read ahead one // character, even if this character never gets consumed by the // client. mp.shared()->peek_one(); } // test, whether we reached the end of the underlying stream template static bool input_at_eof(MultiPass const& mp) { return mp.shared()->eof_reached_; } template static bool input_is_valid(MultiPass const& mp, value_type const&) { return mp.shared()->initialized_; } // no unique data elements }; /////////////////////////////////////////////////////////////////////// template struct shared { private: typedef typename T::char_type result_type; public: explicit shared(T& input) : input_(input), curtok_(-1) , initialized_(false), eof_reached_(false) { peek_one(); // istreams may be at eof right in the beginning } void read_one() { if (!(input_ >> curtok_)) { initialized_ = false; eof_reached_ = true; } else { initialized_ = true; } } void peek_one() { input_.peek(); // try for eof initialized_ = false; eof_reached_ = input_.eof(); } T& input_; result_type curtok_; bool initialized_; bool eof_reached_; }; }; }}} #endif