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