/*

 *

 * Copyright (c) 1998-2002

 * John Maddock

 *

 * Use, modification and distribution are 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)

 *

 */

 /*

  *   LOCATION:    see http://www.boost.org for most recent version.

  *   FILE         sub_match.cpp

  *   VERSION      see <boost/version.hpp>

  *   DESCRIPTION: Declares template class sub_match.

  */

#ifndef BOOST_REGEX_V4_SUB_MATCH_HPP

#define BOOST_REGEX_V4_SUB_MATCH_HPP

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable: 4103)

#endif

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_PREFIX

#endif

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

namespace boost{

template <class BidiIterator>

struct sub_match : public std::pair<BidiIterator, BidiIterator>

{

   typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type       value_type;

#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   typedef          std::ptrdiff_t                                                   difference_type;

#else

   typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type  difference_type;

#endif

   typedef          BidiIterator                                                     iterator_type;

   typedef          BidiIterator                                                     iterator;

   typedef          BidiIterator                                                     const_iterator;

   bool matched;

   sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}

   sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

               && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)\

               && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\

               && !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))

   template <class T, class A>

   operator std::basic_string<value_type, T, A> ()const

   {

      return std::basic_string<value_type, T, A>(this->first, this->second);

   }

#else

   operator std::basic_string<value_type> ()const

   {

      return str();

   }

#endif

   difference_type BOOST_REGEX_CALL length()const

   {

      difference_type n = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);

      return n;

   }

   std::basic_string<value_type> str()const

   {

      std::basic_string<value_type> result;

      std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);

      result.reserve(len);

      BidiIterator i = this->first;

      while(i != this->second)

      {

         result.append(1, *i);

         ++i;

      }

      return result;

   }

   int compare(const sub_match& s)const

   {

      if(matched != s.matched)

         return static_cast<int>(matched) - static_cast<int>(s.matched);

      return str().compare(s.str());

   }

   int compare(const std::basic_string<value_type>& s)const

   {

      return str().compare(s);

   }

   int compare(const value_type* p)const

   {

      return str().compare(p);

   }

   bool operator==(const sub_match& that)const

   { return compare(that) == 0; }

   bool BOOST_REGEX_CALL operator !=(const sub_match& that)const

   { return compare(that) != 0; }

   bool operator<(const sub_match& that)const

   { return compare(that) < 0; }

   bool operator>(const sub_match& that)const

   { return compare(that) > 0; }

   bool operator<=(const sub_match& that)const

   { return compare(that) <= 0; }

   bool operator>=(const sub_match& that)const

   { return compare(that) >= 0; }

#ifdef BOOST_REGEX_MATCH_EXTRA

   typedef std::vector<sub_match<BidiIterator> > capture_sequence_type;

   const capture_sequence_type& captures()const

   {

      if(!m_captures) 

         m_captures.reset(new capture_sequence_type());

      return *m_captures;

   }

   //

   // Private implementation API: DO NOT USE!

   //

   capture_sequence_type& get_captures()const

   {

      if(!m_captures) 

         m_captures.reset(new capture_sequence_type());

      return *m_captures;

   }

private:

   mutable boost::scoped_ptr<capture_sequence_type> m_captures;

public:

#endif

   sub_match(const sub_match& that, bool 

#ifdef BOOST_REGEX_MATCH_EXTRA

      deep_copy

#endif

      = true

      ) 

      : std::pair<BidiIterator, BidiIterator>(that), 

        matched(that.matched) 

   {

#ifdef BOOST_REGEX_MATCH_EXTRA

      if(that.m_captures)

         if(deep_copy)

            m_captures.reset(new capture_sequence_type(*(that.m_captures)));

#endif

   }

   sub_match& operator=(const sub_match& that)

   {

      this->first = that.first;

      this->second = that.second;

      matched = that.matched;

#ifdef BOOST_REGEX_MATCH_EXTRA

      if(that.m_captures)

         get_captures() = *(that.m_captures);

#endif

      return *this;

   }

#ifdef BOOST_OLD_REGEX_H

   //

   // the following are deprecated, do not use!!

   //

   operator int()const;

   operator unsigned int()const;

   operator short()const

   {

      return (short)(int)(*this);

   }

   operator unsigned short()const

   {

      return (unsigned short)(unsigned int)(*this);

   }

#endif

};

typedef sub_match<const char*> csub_match;

typedef sub_match<std::string::const_iterator> ssub_match;

#ifndef BOOST_NO_WREGEX

typedef sub_match<const wchar_t*> wcsub_match;

typedef sub_match<std::wstring::const_iterator> wssub_match;

#endif

// comparison to std::basic_string<> part 1:

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator == (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                  const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) == 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator != (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                  const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) != 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator < (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                 const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) < 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator <= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                  const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) <= 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator >= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                  const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) >= 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator > (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                 const sub_match<RandomAccessIterator>& m)

{ return s.compare(m.str()) > 0; }

// comparison to std::basic_string<> part 2:

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator == (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) == 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator != (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) != 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator < (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) < 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator > (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) > 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator <= (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) <= 0; }

template <class RandomAccessIterator, class traits, class Allocator>

inline bool operator >= (const sub_match<RandomAccessIterator>& m,

                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{ return m.str().compare(s) >= 0; }

// comparison to const charT* part 1:

template <class RandomAccessIterator>

inline bool operator == (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) == 0; }

template <class RandomAccessIterator>

inline bool operator != (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) != 0; }

template <class RandomAccessIterator>

inline bool operator > (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) > 0; }

template <class RandomAccessIterator>

inline bool operator < (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) < 0; }

template <class RandomAccessIterator>

inline bool operator >= (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) >= 0; }

template <class RandomAccessIterator>

inline bool operator <= (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

{ return m.str().compare(s) <= 0; }

// comparison to const charT* part 2:

template <class RandomAccessIterator>

inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) == 0; }

template <class RandomAccessIterator>

inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) != 0; }

template <class RandomAccessIterator>

inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) > 0; }

template <class RandomAccessIterator>

inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) < 0; }

template <class RandomAccessIterator>

inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) >= 0; }

template <class RandomAccessIterator>

inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(s) <= 0; }

// comparison to const charT& part 1:

template <class RandomAccessIterator>

inline bool operator == (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) == 0; }

template <class RandomAccessIterator>

inline bool operator != (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) != 0; }

template <class RandomAccessIterator>

inline bool operator > (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) > 0; }

template <class RandomAccessIterator>

inline bool operator < (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) < 0; }

template <class RandomAccessIterator>

inline bool operator >= (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) >= 0; }

template <class RandomAccessIterator>

inline bool operator <= (const sub_match<RandomAccessIterator>& m,

                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{ return m.str().compare(0, m.length(), &s, 1) <= 0; }

// comparison to const charT* part 2:

template <class RandomAccessIterator>

inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) == 0; }

template <class RandomAccessIterator>

inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) != 0; }

template <class RandomAccessIterator>

inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) > 0; }

template <class RandomAccessIterator>

inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) < 0; }

template <class RandomAccessIterator>

inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) >= 0; }

template <class RandomAccessIterator>

inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{ return m.str().compare(0, m.length(), &s, 1) <= 0; }

// addition operators:

template <class RandomAccessIterator, class traits, class Allocator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 

operator + (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

                  const sub_match<RandomAccessIterator>& m)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;

   result.reserve(s.size() + m.length() + 1);

   return result.append(s).append(m.first, m.second);

}

template <class RandomAccessIterator, class traits, class Allocator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 

operator + (const sub_match<RandomAccessIterator>& m,

            const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;

   result.reserve(s.size() + m.length() + 1);

   return result.append(m.first, m.second).append(s);

}

#if !(defined(__GNUC__) && defined(BOOST_NO_STD_LOCALE))

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);

   return result.append(s).append(m.first, m.second);

}

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (const sub_match<RandomAccessIterator>& m,

            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);

   return result.append(m.first, m.second).append(s);

}

#else

// worwaround versions:

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

                  const sub_match<RandomAccessIterator>& m)

{

   return s + m.str();

}

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (const sub_match<RandomAccessIterator>& m,

            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)

{

   return m.str() + s;

}

#endif

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

                  const sub_match<RandomAccessIterator>& m)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   result.reserve(m.length() + 2);

   return result.append(1, s).append(m.first, m.second);

}

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (const sub_match<RandomAccessIterator>& m,

            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   result.reserve(m.length() + 2);

   return result.append(m.first, m.second).append(1, s);

}

template <class RandomAccessIterator>

inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

operator + (const sub_match<RandomAccessIterator>& m1,

            const sub_match<RandomAccessIterator>& m2)

{

   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   result.reserve(m1.length() + m2.length() + 1);

   return result.append(m1.first, m1.second).append(m2.first, m2.second);

}

#ifndef BOOST_NO_STD_LOCALE

template <class charT, class traits, class RandomAccessIterator>

std::basic_ostream<charT, traits>&

   operator << (std::basic_ostream<charT, traits>& os,

                const sub_match<RandomAccessIterator>& s)

{

   return (os << s.str());

}

#else

template <class RandomAccessIterator>

std::ostream& operator << (std::ostream& os,

                           const sub_match<RandomAccessIterator>& s)

{

   return (os << s.str());

}

#endif

#ifdef BOOST_OLD_REGEX_H

namespace re_detail{

template <class BidiIterator, class charT>

int do_toi(BidiIterator i, BidiIterator j, char c, int radix)

{

   std::string s(i, j);

   char* p;

   int result = std::strtol(s.c_str(), &p, radix);

   if(*p)raise_regex_exception("Bad sub-expression");

   return result;

}

//

// helper:

template <class I, class charT>

int do_toi(I& i, I j, charT c)

{

   int result = 0;

   while((i != j) && (isdigit(*i)))

   {

      result = result*10 + (*i - '0');

      ++i;

   }

   return result;

}

}

template <class BidiIterator>

sub_match<BidiIterator>::operator int()const

{

   BidiIterator i = first;

   BidiIterator j = second;

   if(i == j)raise_regex_exception("Bad sub-expression");

   int neg = 1;

   if((i != j) && (*i == '-'))

   {

      neg = -1;

      ++i;

   }

   neg *= re_detail::do_toi(i, j, *i);

   if(i != j)raise_regex_exception("Bad sub-expression");

   return neg;

}

template <class BidiIterator>

sub_match<BidiIterator>::operator unsigned int()const

{

   BidiIterator i = first;

   BidiIterator j = second;

   if(i == j)

      raise_regex_exception("Bad sub-expression");

   return re_detail::do_toi(i, j, *first);

}

#endif

} // namespace boost

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable: 4103)

#endif

#ifdef BOOST_HAS_ABI_HEADERS

#  include BOOST_ABI_SUFFIX

#endif

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

#endif