/*

 *

 * Copyright (c) 2004

 * 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         concepts.hpp

  *   VERSION      see <boost/version.hpp>

  *   DESCRIPTION: Declares regular expression concepts.

  */

#ifndef BOOST_REGEX_CONCEPTS_HPP_INCLUDED

#define BOOST_REGEX_CONCEPTS_HPP_INCLUDED

#include <boost/concept_archetype.hpp>

#include <boost/concept_check.hpp>

#include <boost/type_traits/is_enum.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/static_assert.hpp>

#ifndef BOOST_TEST_TR1_REGEX

#include <boost/regex.hpp>

#endif

#include <bitset>

#include <vector>

#include <iostream>

namespace boost{

//

// bitmask_archetype:

// this can be either an integer type, an enum, or a std::bitset,

// we use the latter as the architype as it offers the "strictest"

// of the possible interfaces:

//

typedef std::bitset<512> bitmask_archetype;

//

// char_architype:

// A strict model for the character type interface.

//

struct char_architype

{

   // default constructable:

   char_architype();

   // copy constructable / assignable:

   char_architype(const char_architype&);

   char_architype& operator=(const char_architype&);

   // constructable from an integral value:

   char_architype(unsigned long val);

   // comparable:

   bool operator==(const char_architype&)const;

   bool operator!=(const char_architype&)const;

   bool operator<(const char_architype&)const;

   bool operator<=(const char_architype&)const;

   bool operator>=(const char_architype&)const;

   bool operator>(const char_architype&)const;

   // conversion to integral type:

   operator long()const;

};

//

// char_architype can not be used with basic_string:

//

} // namespace boost

namespace std{

   template<> struct char_traits<boost::char_architype>

   {

      // The intent is that this template is not instantiated,

      // but this typedef gives us a chance of compilation in

      // case it is:

      typedef boost::char_architype char_type;

   };

}

namespace boost{

//

// regex_traits_architype:

// A strict interpretation of the regular expression traits class requirements.

//

template <class charT>

struct regex_traits_architype

{

public:

   regex_traits_architype();

   typedef charT char_type;

   typedef std::size_t size_type;

   typedef std::vector<char_type> string_type;

   typedef copy_constructible_archetype<assignable_archetype<> > locale_type;

   typedef bitmask_archetype char_class_type;

   static size_type length(const char_type* ) { return 0; }

   charT translate(charT ) const { return charT(); }

   charT translate_nocase(charT ) const { return static_object<charT>::get(); }

   template <class ForwardIterator>

   string_type transform(ForwardIterator , ForwardIterator ) const

   { return static_object<string_type>::get(); }

   template <class ForwardIterator>

   string_type transform_primary(ForwardIterator , ForwardIterator ) const

   { return static_object<string_type>::get(); }

   template <class ForwardIterator>

   char_class_type lookup_classname(ForwardIterator , ForwardIterator ) const

   { return static_object<char_class_type>::get(); }

   template <class ForwardIterator>

   string_type lookup_collatename(ForwardIterator , ForwardIterator ) const

   { return static_object<string_type>::get(); }

   bool isctype(charT, char_class_type) const

   { return false; }

   int value(charT, int) const

   { return 0; }

   locale_type imbue(locale_type l)

   { return l; }

   locale_type getloc()const

   { return static_object<locale_type>::get(); }

private:

   // this type is not copyable:

   regex_traits_architype(const regex_traits_architype&);

   regex_traits_architype& operator=(const regex_traits_architype&);

};

//

// alter this to std::tr1, to test a std implementation:

//

#ifndef BOOST_TEST_TR1_REGEX

namespace global_regex_namespace = ::boost;

#else

namespace global_regex_namespace = ::std::tr1;

#endif

template <class Bitmask>

struct BitmaskConcept

{

   void constraints() 

   {

      function_requires<CopyConstructibleConcept<Bitmask> >();

      function_requires<AssignableConcept<Bitmask> >();

      m_mask1 = m_mask2 | m_mask3;

      m_mask1 = m_mask2 & m_mask3;

      m_mask1 = m_mask2 ^ m_mask3;

      m_mask1 = ~m_mask2;

      m_mask1 |= m_mask2;

      m_mask1 &= m_mask2;

      m_mask1 ^= m_mask2;

   }

   Bitmask m_mask1, m_mask2, m_mask3;

};

template <class traits>

struct RegexTraitsConcept

{

   RegexTraitsConcept();

   // required typedefs:

   typedef typename traits::char_type char_type;

   typedef typename traits::size_type size_type;

   typedef typename traits::string_type string_type;

   typedef typename traits::locale_type locale_type;

   typedef typename traits::char_class_type char_class_type;

   void constraints() 

   {

      function_requires<UnsignedIntegerConcept<size_type> >();

      function_requires<RandomAccessContainerConcept<string_type> >();

      function_requires<DefaultConstructibleConcept<locale_type> >();

      function_requires<CopyConstructibleConcept<locale_type> >();

      function_requires<AssignableConcept<locale_type> >();

      function_requires<BitmaskConcept<char_class_type> >();

      size_type n = traits::length(m_pointer);

      ignore_unused_variable_warning(n);

      char_type c = m_ctraits.translate(m_char);

      ignore_unused_variable_warning(c);

      c = m_ctraits.translate_nocase(m_char);

      //string_type::foobar bar;

      string_type s1 = m_ctraits.transform(m_pointer, m_pointer);

      ignore_unused_variable_warning(s1);

      string_type s2 = m_ctraits.transform_primary(m_pointer, m_pointer);

      ignore_unused_variable_warning(s2);

      char_class_type cc = m_ctraits.lookup_classname(m_pointer, m_pointer);

      ignore_unused_variable_warning(cc);

      string_type s3 = m_ctraits.lookup_collatename(m_pointer, m_pointer);

      ignore_unused_variable_warning(s3);

      bool b = m_ctraits.isctype(m_char, cc);

      ignore_unused_variable_warning(b);

      int v = m_ctraits.value(m_char, 16);

      ignore_unused_variable_warning(v);

      locale_type l(m_ctraits.getloc());

      m_traits.imbue(l);

      ignore_unused_variable_warning(l);

   }

   traits m_traits;

   const traits m_ctraits;

   const char_type* m_pointer;

   char_type m_char;

private:

   RegexTraitsConcept& operator=(RegexTraitsConcept&);

};

//

// helper class to compute what traits class a regular expression type is using:

//

template <class Regex>

struct regex_traits_computer;

template <class charT, class traits>

struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >

{

   typedef traits type;

};

//

// BaseRegexConcept does not test anything dependent on basic_string,

// in case our charT does not have an associated char_traits:

//

template <class Regex>

struct BaseRegexConcept

{

   typedef typename Regex::value_type value_type;

   typedef typename Regex::size_type size_type;

   typedef typename Regex::flag_type flag_type;

   typedef typename Regex::locale_type locale_type;

   typedef input_iterator_archetype<value_type> input_iterator_type;

   // derived test types:

   typedef const value_type* pointer_type;

   typedef bidirectional_iterator_archetype<value_type> BidiIterator;

   typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;

   typedef global_regex_namespace::match_results<BidiIterator> match_results_type;

   typedef output_iterator_archetype<value_type> OutIterator;

   typedef typename regex_traits_computer<Regex>::type traits_type;

   typedef global_regex_namespace::regex_iterator<BidiIterator, value_type, traits_type> regex_iterator_type;

   typedef global_regex_namespace::regex_token_iterator<BidiIterator, value_type, traits_type> regex_token_iterator_type;

   void global_constraints()

   {

      //

      // test non-template components:

      //

      function_requires<BitmaskConcept<global_regex_namespace::regex_constants::syntax_option_type> >();

      global_regex_namespace::regex_constants::syntax_option_type opts

         = global_regex_namespace::regex_constants::icase

         | global_regex_namespace::regex_constants::nosubs

         | global_regex_namespace::regex_constants::optimize

         | global_regex_namespace::regex_constants::collate

         | global_regex_namespace::regex_constants::ECMAScript

         | global_regex_namespace::regex_constants::basic

         | global_regex_namespace::regex_constants::extended

         | global_regex_namespace::regex_constants::awk

         | global_regex_namespace::regex_constants::grep

         | global_regex_namespace::regex_constants::egrep;

      ignore_unused_variable_warning(opts);

      function_requires<BitmaskConcept<global_regex_namespace::regex_constants::match_flag_type> >();

      global_regex_namespace::regex_constants::match_flag_type mopts

         = global_regex_namespace::regex_constants::match_default

         | global_regex_namespace::regex_constants::match_not_bol

         | global_regex_namespace::regex_constants::match_not_eol

         | global_regex_namespace::regex_constants::match_not_bow

         | global_regex_namespace::regex_constants::match_not_eow

         | global_regex_namespace::regex_constants::match_any

         | global_regex_namespace::regex_constants::match_not_null

         | global_regex_namespace::regex_constants::match_continuous

         | global_regex_namespace::regex_constants::match_prev_avail

         | global_regex_namespace::regex_constants::format_default

         | global_regex_namespace::regex_constants::format_sed

         | global_regex_namespace::regex_constants::format_no_copy

         | global_regex_namespace::regex_constants::format_first_only;

      ignore_unused_variable_warning(mopts);

      BOOST_STATIC_ASSERT((::boost::is_enum<global_regex_namespace::regex_constants::error_type>::value));

      global_regex_namespace::regex_constants::error_type e1 = global_regex_namespace::regex_constants::error_collate;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_ctype;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_escape;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_backref;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_brack;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_paren;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_brace;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_badbrace;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_range;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_space;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_badrepeat;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_complexity;

      ignore_unused_variable_warning(e1);

      e1 = global_regex_namespace::regex_constants::error_stack;

      ignore_unused_variable_warning(e1);

      BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::runtime_error, global_regex_namespace::regex_error>::value  ));

      const global_regex_namespace::regex_error except(e1);

      e1 = except.code();

      typedef typename Regex::value_type value_type;

      function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();

      function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();

   }

   void constraints() 

   {

      global_constraints();

      BOOST_STATIC_ASSERT((::boost::is_same< flag_type, global_regex_namespace::regex_constants::syntax_option_type>::value));

      flag_type opts

         = Regex::icase

         | Regex::nosubs

         | Regex::optimize

         | Regex::collate

         | Regex::ECMAScript

         | Regex::basic

         | Regex::extended

         | Regex::awk

         | Regex::grep

         | Regex::egrep;

      ignore_unused_variable_warning(opts);

      function_requires<DefaultConstructibleConcept<Regex> >();

      function_requires<CopyConstructibleConcept<Regex> >();

      // Regex constructors:

      Regex e1(m_pointer);

      ignore_unused_variable_warning(e1);

      Regex e2(m_pointer, m_flags);

      ignore_unused_variable_warning(e2);

      Regex e3(m_pointer, m_size, m_flags);

      ignore_unused_variable_warning(e3);

      Regex e4(in1, in2);

      ignore_unused_variable_warning(e4);

      Regex e5(in1, in2, m_flags);

      ignore_unused_variable_warning(e5);

      // assign etc:

      Regex e;

      e = m_pointer;

      e = e1;

      e.assign(e1);

      e.assign(m_pointer);

      e.assign(m_pointer, m_flags);

      e.assign(m_pointer, m_size, m_flags);

      e.assign(in1, in2);

      e.assign(in1, in2, m_flags);

      // access:

      const Regex ce;

      bool b = ce.empty();

      ignore_unused_variable_warning(b);

      size_type i = ce.mark_count();

      ignore_unused_variable_warning(i);

      m_flags = ce.flags();

      e.imbue(ce.getloc());

      e.swap(e1);

      global_regex_namespace::swap(e, e1);

      // sub_match:

      BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::pair<BidiIterator, BidiIterator>, sub_match_type>::value));

      typedef typename sub_match_type::value_type sub_value_type;

      typedef typename sub_match_type::difference_type sub_diff_type;

      typedef typename sub_match_type::iterator sub_iter_type;

      BOOST_STATIC_ASSERT((::boost::is_same<sub_value_type, value_type>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<sub_iter_type, BidiIterator>::value));

      b = m_sub.matched;

      ignore_unused_variable_warning(b);

      BidiIterator bi = m_sub.first;

      ignore_unused_variable_warning(bi);

      bi = m_sub.second;

      ignore_unused_variable_warning(bi);

      sub_diff_type diff = m_sub.length();

      ignore_unused_variable_warning(diff);

      // match_results tests:

      typedef typename match_results_type::value_type mr_value_type;

      typedef typename match_results_type::const_reference mr_const_reference;

      typedef typename match_results_type::reference mr_reference;

      typedef typename match_results_type::const_iterator mr_const_iterator;

      typedef typename match_results_type::iterator mr_iterator;

      typedef typename match_results_type::difference_type mr_difference_type;

      typedef typename match_results_type::size_type mr_size_type;

      typedef typename match_results_type::allocator_type mr_allocator_type;

      typedef typename match_results_type::char_type mr_char_type;

      typedef typename match_results_type::string_type mr_string_type;

      match_results_type m1;

      mr_allocator_type at;

      match_results_type m2(at);

      match_results_type m3(m1);

      m1 = m2;

      int ival = 0;

      mr_size_type mrs = m_cresults.size();

      ignore_unused_variable_warning(mrs);

      mrs = m_cresults.max_size();

      ignore_unused_variable_warning(mrs);

      b = m_cresults.empty();

      ignore_unused_variable_warning(b);

      mr_difference_type mrd = m_cresults.length();

      ignore_unused_variable_warning(mrd);

      mrd = m_cresults.length(ival);

      ignore_unused_variable_warning(mrd);

      mrd = m_cresults.position();

      ignore_unused_variable_warning(mrd);

      mrd = m_cresults.position(mrs);

      ignore_unused_variable_warning(mrd);

      mr_const_reference mrcr = m_cresults[ival];

      ignore_unused_variable_warning(mrcr);

      mr_const_reference mrcr2 = m_cresults.prefix();

      ignore_unused_variable_warning(mrcr2);

      mr_const_reference mrcr3 = m_cresults.suffix();

      ignore_unused_variable_warning(mrcr3);

      mr_const_iterator mrci = m_cresults.begin();

      ignore_unused_variable_warning(mrci);

      mrci = m_cresults.end();

      ignore_unused_variable_warning(mrci);

      mr_allocator_type at2 = m_cresults.get_allocator();

      m_results.swap(m_results);

      global_regex_namespace::swap(m_results, m_results);

      // regex_match:

      b = global_regex_namespace::regex_match(m_in, m_in, m_results, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_in, m_in, m_results, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_in, m_in, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_in, m_in, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_pointer, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_match(m_pointer, e, m_mft);

      ignore_unused_variable_warning(b);

      // regex_search:

      b = global_regex_namespace::regex_search(m_in, m_in, m_results, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_in, m_in, m_results, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_in, m_in, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_in, m_in, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e, m_mft);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_pointer, e);

      ignore_unused_variable_warning(b);

      b = global_regex_namespace::regex_search(m_pointer, e, m_mft);

      ignore_unused_variable_warning(b);

      // regex_iterator:

      typedef typename regex_iterator_type::regex_type rit_regex_type;

      typedef typename regex_iterator_type::value_type rit_value_type;

      typedef typename regex_iterator_type::difference_type rit_difference_type;

      typedef typename regex_iterator_type::pointer rit_pointer;

      typedef typename regex_iterator_type::reference rit_reference;

      typedef typename regex_iterator_type::iterator_category rit_iterator_category;

      BOOST_STATIC_ASSERT((::boost::is_same<rit_regex_type, Regex>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rit_value_type, match_results_type>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rit_difference_type, std::ptrdiff_t>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rit_pointer, const match_results_type*>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_type&>::value));

      BOOST_STATIC_ASSERT((::boost::is_convertible<rit_iterator_category*, std::forward_iterator_tag*>::value));

      // this takes care of most of the checks needed:

      function_requires<ForwardIteratorConcept<regex_iterator_type> >();

      regex_iterator_type iter1(m_in, m_in, e);

      ignore_unused_variable_warning(iter1);

      regex_iterator_type iter2(m_in, m_in, e, m_mft);

      ignore_unused_variable_warning(iter2);

      // regex_token_iterator:

      typedef typename regex_token_iterator_type::regex_type rtit_regex_type;

      typedef typename regex_token_iterator_type::value_type rtit_value_type;

      typedef typename regex_token_iterator_type::difference_type rtit_difference_type;

      typedef typename regex_token_iterator_type::pointer rtit_pointer;

      typedef typename regex_token_iterator_type::reference rtit_reference;

      typedef typename regex_token_iterator_type::iterator_category rtit_iterator_category;

      BOOST_STATIC_ASSERT((::boost::is_same<rtit_regex_type, Regex>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rtit_value_type, sub_match_type>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rtit_difference_type, std::ptrdiff_t>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rtit_pointer, const sub_match_type*>::value));

      BOOST_STATIC_ASSERT((::boost::is_same<rtit_reference, const sub_match_type&>::value));

      BOOST_STATIC_ASSERT((::boost::is_convertible<rtit_iterator_category*, std::forward_iterator_tag*>::value));

      // this takes care of most of the checks needed:

      function_requires<ForwardIteratorConcept<regex_token_iterator_type> >();

      regex_token_iterator_type ti1(m_in, m_in, e);

      ignore_unused_variable_warning(ti1);

      regex_token_iterator_type ti2(m_in, m_in, e, 0);

      ignore_unused_variable_warning(ti2);

      regex_token_iterator_type ti3(m_in, m_in, e, 0, m_mft);

      ignore_unused_variable_warning(ti3);

      std::vector<int> subs;

      regex_token_iterator_type ti4(m_in, m_in, e, subs);

      ignore_unused_variable_warning(ti4);

      regex_token_iterator_type ti5(m_in, m_in, e, subs, m_mft);

      ignore_unused_variable_warning(ti5);

      static const int i_array[3] = { 1, 2, 3, };

      regex_token_iterator_type ti6(m_in, m_in, e, i_array);