diff options
author | Vlad Voicu <vladv@rosedu.org> | 2012-03-02 10:01:11 (GMT) |
---|---|---|
committer | Kevin Smith <git@kismith.co.uk> | 2012-03-09 15:04:05 (GMT) |
commit | 1c8cd160b79b6bbcec72042bdb104ba530508a93 (patch) | |
tree | cff302b81e74c557fbc9e30fd43144d981b613d0 /3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp | |
parent | 2944711aefec9a9dd66052440bc4f921910dd780 (diff) | |
download | swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.zip swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.tar.bz2 |
Added spirit to bundled boost
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp | 252 |
1 files changed, 252 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp new file mode 100644 index 0000000..a1ebb6d --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp @@ -0,0 +1,252 @@ +// Copyright (c) 2001, Daniel C. Nuffer +// Copyright (c) 2001-2011 Hartmut Kaiser +// http://spirit.sourceforge.net/ +// +// 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_ITERATOR_MULTI_PASS_MAR_16_2007_1124AM) +#define BOOST_SPIRIT_ITERATOR_MULTI_PASS_MAR_16_2007_1124AM + +#include <boost/config.hpp> +#include <boost/spirit/home/support/iterators/multi_pass_fwd.hpp> +#include <boost/spirit/home/support/iterators/detail/multi_pass.hpp> +#include <boost/spirit/home/support/iterators/detail/combine_policies.hpp> +#include <boost/limits.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/utility/base_from_member.hpp> + +namespace boost { namespace spirit +{ + /////////////////////////////////////////////////////////////////////////// + // The default multi_pass instantiation uses a ref-counted std_deque scheme. + /////////////////////////////////////////////////////////////////////////// + template<typename T, typename Policies> + class multi_pass + : private boost::base_from_member< + typename Policies::BOOST_NESTED_TEMPLATE shared<T>*> + , public Policies::BOOST_NESTED_TEMPLATE unique<T> +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + , typename iterator_base_creator<T, typename Policies::input_policy>::type +#endif + { + private: + // unique and shared data types + typedef typename Policies::BOOST_NESTED_TEMPLATE unique<T> + policies_base_type; + typedef typename Policies::BOOST_NESTED_TEMPLATE shared<T> + shared_data_type; + + typedef boost::base_from_member<shared_data_type*> member_base; + + // define the types the standard embedded iterator typedefs are taken + // from +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + typedef typename iterator_base_creator<Input, T>::type iterator_type; +#else + typedef typename policies_base_type::input_policy iterator_type; +#endif + + public: + // standard iterator typedefs + typedef std::forward_iterator_tag iterator_category; + typedef typename iterator_type::value_type value_type; + typedef typename iterator_type::difference_type difference_type; + typedef typename iterator_type::distance_type distance_type; + typedef typename iterator_type::reference reference; + typedef typename iterator_type::pointer pointer; + + multi_pass() : member_base((shared_data_type*)0) {} + + explicit multi_pass(T& input) + : member_base(new shared_data_type(input)), policies_base_type(input) {} + + explicit multi_pass(T const& input) + : member_base(new shared_data_type(input)), policies_base_type(input) {} + + multi_pass(multi_pass const& x) + : member_base(x.member), policies_base_type(x) + { + policies_base_type::clone(*this); + } + +#if BOOST_WORKAROUND(__GLIBCPP__, == 20020514) + // The standard library shipped with gcc-3.1 has a bug in + // bits/basic_string.tcc. It tries to use iter::iter(0) to + // construct an iterator. Ironically, this happens in sanity + // checking code that isn't required by the standard. + // The workaround is to provide an additional constructor that + // ignores its int argument and behaves like the default constructor. + multi_pass(int) : member_base((shared_data_type*)0) {} +#endif // BOOST_WORKAROUND(__GLIBCPP__, == 20020514) + + ~multi_pass() + { + if (policies_base_type::release(*this)) { + policies_base_type::destroy(*this); + delete this->member; + } + } + + multi_pass& operator=(multi_pass const& x) + { + if (this != &x) { + multi_pass temp(x); + temp.swap(*this); + } + return *this; + } + + void swap(multi_pass& x) + { + boost::swap(this->member, x.member); + this->policies_base_type::swap(x); + } + + reference operator*() const + { + policies_base_type::docheck(*this); + return policies_base_type::dereference(*this); + } + pointer operator->() const + { + return &(operator*()); + } + + multi_pass& operator++() + { + policies_base_type::docheck(*this); + policies_base_type::increment(*this); + return *this; + } + multi_pass operator++(int) + { + multi_pass tmp(*this); + ++*this; + return tmp; + } + + void clear_queue(BOOST_SCOPED_ENUM(traits::clear_mode) mode = + traits::clear_mode::clear_if_enabled) + { + if (mode == traits::clear_mode::clear_always || !inhibit_clear_queue()) + policies_base_type::clear_queue(*this); + } + bool inhibit_clear_queue() const + { + return this->member->inhibit_clear_queue_; + } + void inhibit_clear_queue(bool flag) + { + this->member->inhibit_clear_queue_ = flag; + } + + bool operator==(multi_pass const& y) const + { + if (is_eof()) + return y.is_eof(); + if (y.is_eof()) + return false; + + return policies_base_type::equal_to(*this, y); + } + bool operator<(multi_pass const& y) const + { + return policies_base_type::less_than(*this, y); + } + + bool operator!=(multi_pass const& y) + { + return !(*this == y); + } + bool operator>(multi_pass const& y) + { + return y < *this; + } + bool operator>=(multi_pass const& y) + { + return !(*this < y); + } + bool operator<=(multi_pass const& y) + { + return !(y < *this); + } + + // allow access to base member + shared_data_type* shared() const { return this->member; } + + private: // helper functions + bool is_eof() const + { + return (0 == this->member) || policies_base_type::is_eof(*this); + } + }; + + /////////////////////////////////////////////////////////////////////////// + // Generator function + /////////////////////////////////////////////////////////////////////////// + template <typename Policies, typename T> + inline multi_pass<T, Policies> + make_multi_pass(T& i) + { + return multi_pass<T, Policies>(i); + } + template <typename Policies, typename T> + inline multi_pass<T, Policies> + make_multi_pass(T const& i) + { + return multi_pass<T, Policies>(i); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename T> + inline multi_pass<T> + make_default_multi_pass(T& i) + { + return multi_pass<T>(i); + } + template <typename T> + inline multi_pass<T> + make_default_multi_pass(T const& i) + { + return multi_pass<T>(i); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename T, typename Policies> + inline void + swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y) + { + x.swap(y); + } + + /////////////////////////////////////////////////////////////////////////// + // define special functions allowing to integrate any multi_pass iterator + // with expectation points + namespace traits + { + template <typename T, typename Policies> + void clear_queue(multi_pass<T, Policies>& mp + , BOOST_SCOPED_ENUM(traits::clear_mode) mode) + { + mp.clear_queue(mode); + } + + template <typename T, typename Policies> + void inhibit_clear_queue(multi_pass<T, Policies>& mp, bool flag) + { + mp.inhibit_clear_queue(flag); + } + + template <typename T, typename Policies> + bool inhibit_clear_queue(multi_pass<T, Policies>& mp) + { + return mp.inhibit_clear_queue(); + } + } + +}} // namespace boost::spirit + +#endif + + |