| /*============================================================================= |
| Copyright (c) 2001-2003 Joel de Guzman |
| http://spirit.sourceforge.net/ |
| |
| Use, modification and distribution is subject to 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) |
| =============================================================================*/ |
| #ifndef BOOST_XPRESSIVE_SPIRIT_RANGE_RUN_HPP_EAN_10_04_2005 |
| #define BOOST_XPRESSIVE_SPIRIT_RANGE_RUN_HPP_EAN_10_04_2005 |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <vector> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace xpressive { namespace detail |
| { |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // range class |
| // |
| // Implements a closed range of values. This class is used in |
| // the implementation of the range_run class. |
| // |
| // { Low level implementation detail } |
| // { Not to be confused with spirit::range } |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template<typename Char> |
| struct range |
| { |
| range(Char first, Char last); |
| |
| bool is_valid() const; |
| bool includes(Char v) const; |
| bool includes(range const &r) const; |
| bool overlaps(range const &r) const; |
| void merge(range const &r); |
| |
| Char first_; |
| Char last_; |
| }; |
| |
| ////////////////////////////////// |
| template<typename Char> |
| struct range_compare |
| { |
| bool operator()(range<Char> const &x, range<Char> const &y) const |
| { |
| return x.first_ < y.first_; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // range_run |
| // |
| // An implementation of a sparse bit (boolean) set. The set uses |
| // a sorted vector of disjoint ranges. This class implements the |
| // bare minimum essentials from which the full range of set |
| // operators can be implemented. The set is constructed from |
| // ranges. Internally, adjacent or overlapping ranges are |
| // coalesced. |
| // |
| // range_runs are very space-economical in situations where there |
| // are lots of ranges and a few individual disjoint values. |
| // Searching is O(log n) where n is the number of ranges. |
| // |
| // { Low level implementation detail } |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template<typename Char> |
| struct range_run |
| { |
| typedef range<Char> range_type; |
| typedef std::vector<range_type> run_type; |
| typedef typename run_type::iterator iterator; |
| typedef typename run_type::const_iterator const_iterator; |
| |
| void swap(range_run& rr); |
| bool empty() const; |
| bool test(Char v) const; |
| template<typename Traits> |
| bool test(Char v, Traits const &tr) const; |
| void set(range_type const &r); |
| void clear(range_type const &r); |
| void clear(); |
| |
| const_iterator begin() const; |
| const_iterator end() const; |
| |
| private: |
| void merge(iterator iter, range_type const &r); |
| |
| run_type run_; |
| }; |
| |
| }}} // namespace boost::xpressive::detail |
| |
| #endif |
| |