/////////////////////////////////////////////////////////////////////////////// | |
// regex_impl.hpp | |
// | |
// Copyright 2008 Eric Niebler. 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) | |
#ifndef BOOST_XPRESSIVE_DETAIL_CORE_REGEX_IMPL_HPP_EAN_10_04_2005 | |
#define BOOST_XPRESSIVE_DETAIL_CORE_REGEX_IMPL_HPP_EAN_10_04_2005 | |
// MS compatible compilers support #pragma once | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
#include <vector> | |
#include <boost/intrusive_ptr.hpp> | |
#include <boost/xpressive/regex_traits.hpp> | |
#include <boost/xpressive/detail/detail_fwd.hpp> | |
#include <boost/xpressive/detail/dynamic/matchable.hpp> | |
#include <boost/xpressive/detail/utility/tracking_ptr.hpp> | |
#include <boost/xpressive/detail/utility/counted_base.hpp> | |
namespace boost { namespace xpressive { namespace detail | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// finder | |
template<typename BidiIter> | |
struct finder | |
: counted_base<finder<BidiIter> > | |
{ | |
virtual ~finder() {} | |
virtual bool ok_for_partial_matches() const { return true; } | |
virtual bool operator ()(match_state<BidiIter> &state) const = 0; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// traits | |
template<typename Char> | |
struct traits | |
: counted_base<traits<Char> > | |
{ | |
virtual ~traits() {} | |
virtual Char tolower(Char ch) const = 0; | |
virtual Char toupper(Char ch) const = 0; | |
virtual bool in_range(Char from, Char to, Char ch) const = 0; | |
virtual int value(Char ch, int radix) const = 0; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// named_mark | |
template<typename Char> | |
struct named_mark | |
{ | |
typedef typename detail::string_type<Char>::type string_type; | |
named_mark(string_type name, std::size_t mark_nbr) | |
: name_(name) | |
, mark_nbr_(mark_nbr) | |
{} | |
string_type name_; | |
std::size_t mark_nbr_; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// traits_holder | |
template<typename Traits> | |
struct traits_holder | |
: traits<typename Traits::char_type> | |
{ | |
typedef typename Traits::char_type char_type; | |
explicit traits_holder(Traits const &tr) | |
: traits_(tr) | |
{ | |
} | |
Traits const &traits() const | |
{ | |
return this->traits_; | |
} | |
char_type tolower(char_type ch) const | |
{ | |
return this->tolower_(ch, typename Traits::version_tag()); | |
} | |
char_type toupper(char_type ch) const | |
{ | |
return this->toupper_(ch, typename Traits::version_tag()); | |
} | |
int value(char_type ch, int radix) const | |
{ | |
return this->traits_.value(ch, radix); | |
} | |
bool in_range(char_type from, char_type to, char_type ch) const | |
{ | |
return this->traits_.in_range(from, to, ch); | |
} | |
private: | |
char_type tolower_(char_type ch, regex_traits_version_1_tag) const | |
{ | |
return ch; | |
} | |
char_type toupper_(char_type ch, regex_traits_version_1_tag) const | |
{ | |
return ch; | |
} | |
char_type tolower_(char_type ch, regex_traits_version_2_tag) const | |
{ | |
return this->traits_.tolower(ch); | |
} | |
char_type toupper_(char_type ch, regex_traits_version_2_tag) const | |
{ | |
return this->traits_.toupper(ch); | |
} | |
Traits traits_; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_impl | |
// | |
template<typename BidiIter> | |
struct regex_impl | |
: enable_reference_tracking<regex_impl<BidiIter> > | |
{ | |
typedef typename iterator_value<BidiIter>::type char_type; | |
regex_impl() | |
: enable_reference_tracking<regex_impl<BidiIter> >() | |
, xpr_() | |
, traits_() | |
, finder_() | |
, named_marks_() | |
, mark_count_(0) | |
, hidden_mark_count_(0) | |
{ | |
#ifdef BOOST_XPRESSIVE_DEBUG_CYCLE_TEST | |
++instances; | |
#endif | |
} | |
regex_impl(regex_impl<BidiIter> const &that) | |
: enable_reference_tracking<regex_impl<BidiIter> >(that) | |
, xpr_(that.xpr_) | |
, traits_(that.traits_) | |
, finder_(that.finder_) | |
, named_marks_(that.named_marks_) | |
, mark_count_(that.mark_count_) | |
, hidden_mark_count_(that.hidden_mark_count_) | |
{ | |
#ifdef BOOST_XPRESSIVE_DEBUG_CYCLE_TEST | |
++instances; | |
#endif | |
} | |
~regex_impl() | |
{ | |
#ifdef BOOST_XPRESSIVE_DEBUG_CYCLE_TEST | |
--instances; | |
#endif | |
} | |
void swap(regex_impl<BidiIter> &that) | |
{ | |
enable_reference_tracking<regex_impl<BidiIter> >::swap(that); | |
this->xpr_.swap(that.xpr_); | |
this->traits_.swap(that.traits_); | |
this->finder_.swap(that.finder_); | |
this->named_marks_.swap(that.named_marks_); | |
std::swap(this->mark_count_, that.mark_count_); | |
std::swap(this->hidden_mark_count_, that.hidden_mark_count_); | |
} | |
intrusive_ptr<matchable_ex<BidiIter> const> xpr_; | |
intrusive_ptr<traits<char_type> const> traits_; | |
intrusive_ptr<finder<BidiIter> > finder_; | |
std::vector<named_mark<char_type> > named_marks_; | |
std::size_t mark_count_; | |
std::size_t hidden_mark_count_; | |
#ifdef BOOST_XPRESSIVE_DEBUG_CYCLE_TEST | |
static int instances; | |
#endif | |
private: | |
regex_impl &operator =(regex_impl const &); | |
}; | |
template<typename BidiIter> | |
void swap(regex_impl<BidiIter> &left, regex_impl<BidiIter> &right) | |
{ | |
left.swap(right); | |
} | |
#ifdef BOOST_XPRESSIVE_DEBUG_CYCLE_TEST | |
template<typename BidiIter> | |
int regex_impl<BidiIter>::instances = 0; | |
#endif | |
}}} // namespace boost::xpressive::detail | |
#endif |