///////////////////////////////////////////////////////////////////////////////

 /// \file basic_regex.hpp

 /// Contains the definition of the basic_regex\<\> class template and its

 /// associated helper functions.

 //

 //  Copyright 2004 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_BASIC_REGEX_HPP_EAN_10_04_2005

 #define BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005

 // MS compatible compilers support #pragma once

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

 # pragma once

 #endif

 #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER

 # include <iostream>

 #endif

 #include <boost/mpl/bool.hpp>

 #include <boost/xpressive/proto/proto_fwd.hpp>

 #include <boost/xpressive/regex_constants.hpp>

 #include <boost/xpressive/detail/detail_fwd.hpp>

 #include <boost/xpressive/detail/core/regex_impl.hpp>

 namespace boost { namespace xpressive

 {

 ///////////////////////////////////////////////////////////////////////////////

 // basic_regex

 //

 /// \brief Class template basic_regex\<\> is a class for holding a compiled regular expression.

 template<typename BidiIter>

 struct basic_regex

 {

     typedef BidiIter iterator_type;

     typedef typename iterator_value<BidiIter>::type char_type;

     typedef std::basic_string<char_type> string_type;

     typedef regex_constants::syntax_option_type flag_type;

     /// \post regex_id()    == 0

     /// \post mark_count()  == 0

     basic_regex()

       : impl_()

     {

     }

     /// \param that The basic_regex object to copy.

     /// \post regex_id()    == that.regex_id()

     /// \post mark_count()  == that.mark_count()

     basic_regex(basic_regex<BidiIter> const &that)

       : impl_(that.impl_)

     {

     }

     /// \param that The basic_regex object to copy.

     /// \post regex_id()    == that.regex_id()

     /// \post mark_count()  == that.mark_count()

     /// \return *this

     basic_regex<BidiIter> &operator =(basic_regex<BidiIter> const &that)

     {

         this->impl_ = that.impl_;

         return *this;

     }

     /// Construct from a static regular expression.

     ///

     /// \param  xpr The static regular expression

     /// \pre    Xpr is the type of a static regular expression.

     /// \post   regex_id()   != 0

     /// \post   mark_count() \>= 0

     template<typename Xpr>

     basic_regex(Xpr const &xpr)

       : impl_()

     {

         this->operator =(xpr);

     }

     /// Construct from a static regular expression.

     ///

     /// \param  xpr The static regular expression.

     /// \pre    Xpr is the type of a static regular expression.

     /// \post   regex_id()   != 0

     /// \post   mark_count() \>= 0

     /// \throw  std::bad_alloc on out of memory

     /// \return *this

     template<typename Xpr>

     basic_regex<BidiIter> &operator =(Xpr const &xpr)

     {

         detail::static_compile(xpr, *this->impl_.get());

         return *this;

     }

     /// Returns the count of capturing sub-expressions in this regular expression

     ///

     std::size_t mark_count() const

     {

         return this->impl_ ? this->impl_->mark_count_ : 0;

     }

     /// Returns a token which uniquely identifies this regular expression.

     ///

     regex_id_type regex_id() const

     {

         return this->impl_ ? this->impl_->xpr_.get() : 0;

     }

     /// Swaps the contents of this basic_regex object with another.

     ///

     /// \param      that The other basic_regex object.

     /// \attention  This is a shallow swap that does not do reference tracking. If you embed

     /// a basic_regex object by reference in another regular expression and then swap its

     /// contents with another basic_regex object, the change will not be visible to the enclosing

     /// regular expression. It is done this way to ensure that swap() cannot throw.

     /// \throw nothrow

     void swap(basic_regex<BidiIter> &that) // throw()

     {

         this->impl_.swap(that.impl_);

     }

     /// Factory method for building a regex object from a string.

     /// Equivalent to regex_compiler\< BidiIter \>().compile(str, flags);

     ///

     /// \param str The std::basic_string containing the regular expression.

     /// \param flags Optional bitmask of type syntax_option_type to control how str is interpreted.

     static basic_regex<BidiIter> compile(string_type const &str, flag_type flags = regex_constants::ECMAScript)

     {

         return regex_compiler<BidiIter>().compile(str, flags);

     }

     // for binding actions to this regex when it is nested statically in another regex

     /// INTERNAL ONLY

     template<typename Action>

     proto::binary_op

     <

         proto::unary_op<basic_regex<BidiIter>, proto::noop_tag>

       , proto::unary_op<Action, proto::noop_tag>

       , proto::right_shift_tag

     > const

     operator [](detail::action_matcher<Action> const &action) const

     {

         return proto::noop(*this) >> proto::noop(*static_cast<Action const *>(&action));

     }

     //{{AFX_DEBUG

     #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER

     // BUGBUG debug only

     /// INTERNAL ONLY

     friend std::ostream &operator <<(std::ostream &sout, basic_regex<BidiIter> const &rex)

     {

         rex.dump_(sout);

         return sout;

     }

     #endif

     //}}AFX_DEBUG

 private:

     friend struct detail::core_access<BidiIter>;

     // Avoid a common programming mistake. Construction from a string is ambiguous. It could mean

     //   sregex rx = sregex::compile(str); // compile the string into a regex

     // or

     //   sregex rx = as_xpr(str);          // treat the string as a literal

     // Since there is no easy way to disambiguate, disallow it and force users to say what they mean

     /// INTERNAL ONLY

     basic_regex(char_type const *);

     /// INTERNAL ONLY

     basic_regex(string_type const &);

     // used from parser, via core_access

     /// INTERNAL ONLY

     explicit basic_regex(detail::regex_impl<BidiIter> const &that)

       : impl_()

     {

         this->impl_.tracking_copy(that);

     }

     /// INTERNAL ONLY

     bool match_(detail::state_type<BidiIter> &state) const

     {

         return this->impl_->xpr_->match(state);

     }

     // Returns true if this basic_regex object does not contain a valid regular expression.

     /// INTERNAL ONLY

     bool invalid_() const

     {

         return !this->impl_ || !this->impl_->xpr_;

     }

     /// INTERNAL ONLY

     void dump_(std::ostream &sout) const;

     // the tracking_ptr manages lazy-init, COW, cycle-breaking, and

     // reference/dependency tracking.

     detail::tracking_ptr<detail::regex_impl<BidiIter> > impl_;

 };

 //{{AFX_DEBUG

 #ifdef BOOST_XPRESSIVE_DEBUG_TRACKING_POINTER

 ///////////////////////////////////////////////////////////////////////////////

 // dump_

 /// INTERNAL ONLY

 template<typename BidiIter>

 inline void basic_regex<BidiIter>::dump_(std::ostream &sout) const

 {

     if(!this->impl_)

     {

         sout << "<null> refs={} deps={}";

     }

     else

     {

         sout << *this->impl_;

     }

 }

 #endif

 //}}AFX_DEBUG

 ///////////////////////////////////////////////////////////////////////////////

 // swap

 /// \brief      Swaps the contents of two basic_regex objects.

 /// \param      left The first basic_regex object.

 /// \param      right The second basic_regex object.

 /// \attention  This is a shallow swap that does not do reference tracking.

 /// If you embed a basic_regex object by reference in another regular expression

 /// and then swap its contents with another basic_regex object, the change will

 /// not be visible to the enclosing regular expression. It is done this way to

 /// ensure that swap() cannot throw.

 /// \throw nothrow

 template<typename BidiIter>

 inline void swap(basic_regex<BidiIter> &left, basic_regex<BidiIter> &right) // throw()

 {

     left.swap(right);

 }

 }} // namespace boost::xpressive

 #endif // BOOST_XPRESSIVE_REGEX_HPP_EAN_10_04_2005