boost/xpressive/detail/core/regex_impl.hpp
///////////////////////////////////////////////////////////////////////////////
// regex_impl.hpp
//
// Copyright 2007 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 &traits)
: traits_(traits)
{
}
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