boost/regex/concepts.hpp
/* * * 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; }; inline long hash_value(char_architype val) { return val; } // // 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; }; } // // Allocator architype: // template <class T> class allocator_architype { public: typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; typedef T value_type; typedef unsigned size_type; typedef int difference_type; template <class U> struct rebind { typedef allocator_architype<U> other; }; pointer address(reference r){ return &r; } const_pointer address(const_reference r) { return &r; } pointer allocate(size_type n) { return static_cast<pointer>(std::malloc(n)); } pointer allocate(size_type n, pointer) { return static_cast<pointer>(std::malloc(n)); } void deallocate(pointer p, size_type) { std::free(p); } size_type max_size()const { return UINT_MAX; } allocator_architype(){} allocator_architype(const allocator_architype&){} template <class Other> allocator_architype(const allocator_architype<Other>&){} void construct(pointer p, const_reference r) { new (p)T(r); } void destroy(pointer p) { p->~T(); } }; template <class T> bool operator == (const allocator_architype<T>&, const allocator_architype<T>&) {return true; } template <class T> bool operator != (const allocator_architype<T>&, const allocator_architype<T>&) { return false; } 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 std::size_t 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&){ return *this; } }; // // 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> >(); std::size_t 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, allocator_architype<sub_match_type> > match_results_type; typedef global_regex_namespace::match_results<BidiIterator> match_results_default_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 regex_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; typename Regex::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)); bool 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 - some typedefs are not used, however these // guarante that they exist (some compilers may warn on non-usage) 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); (void) 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_default_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_default_type*>::value)); BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_default_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); ignore_unused_variable_warning(ti6); regex_token_iterator_type ti7(m_in, m_in, e, i_array, m_mft); ignore_unused_variable_warning(ti7); } pointer_type m_pointer; flag_type m_flags; std::size_t m_size; input_iterator_type in1, in2; const sub_match_type m_sub; const value_type m_char; match_results_type m_results; const match_results_type m_cresults; OutIterator m_out; BidiIterator m_in; global_regex_namespace::regex_constants::match_flag_type m_mft; global_regex_namespace::match_results< pointer_type, allocator_architype<global_regex_namespace::sub_match<pointer_type> > > m_pmatch; BaseRegexConcept(); BaseRegexConcept(const BaseRegexConcept&); BaseRegexConcept& operator=(const BaseRegexConcept&); }; // // RegexConcept: // Test every interface in the std: // template <class Regex> struct RegexConcept { 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; // derived test types: typedef const value_type* pointer_type; typedef std::basic_string<value_type> string_type; typedef boost::bidirectional_iterator_archetype<value_type> BidiIterator; typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type; typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type; typedef output_iterator_archetype<value_type> OutIterator; void constraints() { function_requires<BaseRegexConcept<Regex> >(); // string based construct: Regex e1(m_string); ignore_unused_variable_warning(e1); Regex e2(m_string, m_flags); ignore_unused_variable_warning(e2); // assign etc: Regex e; e = m_string; e.assign(m_string); e.assign(m_string, m_flags); // sub_match: string_type s(m_sub); ignore_unused_variable_warning(s); s = m_sub.str(); ignore_unused_variable_warning(s); int i = m_sub.compare(m_string); ignore_unused_variable_warning(i); int i2 = m_sub.compare(m_sub); ignore_unused_variable_warning(i2); i2 = m_sub.compare(m_pointer); ignore_unused_variable_warning(i2); bool b = m_sub == m_sub; ignore_unused_variable_warning(b); b = m_sub != m_sub; ignore_unused_variable_warning(b); b = m_sub <= m_sub; ignore_unused_variable_warning(b); b = m_sub <= m_sub; ignore_unused_variable_warning(b); b = m_sub > m_sub; ignore_unused_variable_warning(b); b = m_sub >= m_sub; ignore_unused_variable_warning(b); b = m_sub == m_pointer; ignore_unused_variable_warning(b); b = m_sub != m_pointer; ignore_unused_variable_warning(b); b = m_sub <= m_pointer; ignore_unused_variable_warning(b); b = m_sub <= m_pointer; ignore_unused_variable_warning(b); b = m_sub > m_pointer; ignore_unused_variable_warning(b); b = m_sub >= m_pointer; ignore_unused_variable_warning(b); b = m_pointer == m_sub; ignore_unused_variable_warning(b); b = m_pointer != m_sub; ignore_unused_variable_warning(b); b = m_pointer <= m_sub; ignore_unused_variable_warning(b); b = m_pointer <= m_sub; ignore_unused_variable_warning(b); b = m_pointer > m_sub; ignore_unused_variable_warning(b); b = m_pointer >= m_sub; ignore_unused_variable_warning(b); b = m_sub == m_char; ignore_unused_variable_warning(b); b = m_sub != m_char; ignore_unused_variable_warning(b); b = m_sub <= m_char; ignore_unused_variable_warning(b); b = m_sub <= m_char; ignore_unused_variable_warning(b); b = m_sub > m_char; ignore_unused_variable_warning(b); b = m_sub >= m_char; ignore_unused_variable_warning(b); b = m_char == m_sub; ignore_unused_variable_warning(b); b = m_char != m_sub; ignore_unused_variable_warning(b); b = m_char <= m_sub; ignore_unused_variable_warning(b); b = m_char <= m_sub; ignore_unused_variable_warning(b); b = m_char > m_sub; ignore_unused_variable_warning(b); b = m_char >= m_sub; ignore_unused_variable_warning(b); b = m_sub == m_string; ignore_unused_variable_warning(b); b = m_sub != m_string; ignore_unused_variable_warning(b); b = m_sub <= m_string; ignore_unused_variable_warning(b); b = m_sub <= m_string; ignore_unused_variable_warning(b); b = m_sub > m_string; ignore_unused_variable_warning(b); b = m_sub >= m_string; ignore_unused_variable_warning(b); b = m_string == m_sub; ignore_unused_variable_warning(b); b = m_string != m_sub; ignore_unused_variable_warning(b); b = m_string <= m_sub; ignore_unused_variable_warning(b); b = m_string <= m_sub; ignore_unused_variable_warning(b); b = m_string > m_sub; ignore_unused_variable_warning(b); b = m_string >= m_sub; ignore_unused_variable_warning(b); // match results: m_string = m_results.str(); ignore_unused_variable_warning(m_string); m_string = m_results.str(0); ignore_unused_variable_warning(m_string); m_out = m_cresults.format(m_out, m_string); m_out = m_cresults.format(m_out, m_string, m_mft); m_string = m_cresults.format(m_string); ignore_unused_variable_warning(m_string); m_string = m_cresults.format(m_string, m_mft); ignore_unused_variable_warning(m_string); // regex_match: b = global_regex_namespace::regex_match(m_string, m_smatch, e); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_match(m_string, m_smatch, e, m_mft); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_match(m_string, e); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_match(m_string, e, m_mft); ignore_unused_variable_warning(b); // regex_search: b = global_regex_namespace::regex_search(m_string, m_smatch, e); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_search(m_string, m_smatch, e, m_mft); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_search(m_string, e); ignore_unused_variable_warning(b); b = global_regex_namespace::regex_search(m_string, e, m_mft); ignore_unused_variable_warning(b); // regex_replace: m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string, m_mft); m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string); m_string = global_regex_namespace::regex_replace(m_string, e, m_string, m_mft); ignore_unused_variable_warning(m_string); m_string = global_regex_namespace::regex_replace(m_string, e, m_string); ignore_unused_variable_warning(m_string); } flag_type m_flags; string_type m_string; const sub_match_type m_sub; match_results_type m_results; pointer_type m_pointer; value_type m_char; const match_results_type m_cresults; OutIterator m_out; BidiIterator m_in; global_regex_namespace::regex_constants::match_flag_type m_mft; global_regex_namespace::match_results<typename string_type::const_iterator, allocator_architype<global_regex_namespace::sub_match<typename string_type::const_iterator> > > m_smatch; RegexConcept(); RegexConcept(const RegexConcept&); RegexConcept& operator=(const RegexConcept&); }; #ifndef BOOST_REGEX_TEST_STD template <class M> struct functor1 { typedef typename M::char_type char_type; const char_type* operator()(const M&)const { static const char_type c = static_cast<char_type>(0); return &c; } }; template <class M> struct functor1b { typedef typename M::char_type char_type; std::vector<char_type> operator()(const M&)const { static const std::vector<char_type> c; return c; } }; template <class M> struct functor2 { template <class O> O operator()(const M& /*m*/, O i)const { return i; } }; template <class M> struct functor3 { template <class O> O operator()(const M& /*m*/, O i, regex_constants::match_flag_type)const { return i; } }; // // BoostRegexConcept: // Test every interface in the Boost implementation: // template <class Regex> struct BoostRegexConcept { 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; // derived test types: typedef const value_type* pointer_type; typedef std::basic_string<value_type> string_type; typedef typename Regex::const_iterator const_iterator; typedef bidirectional_iterator_archetype<value_type> BidiIterator; typedef output_iterator_archetype<value_type> OutputIterator; typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type; typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type; typedef global_regex_namespace::match_results<BidiIterator> match_results_default_type; void constraints() { 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_partial | 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_perl | global_regex_namespace::regex_constants::format_no_copy | global_regex_namespace::regex_constants::format_first_only; (void)mopts; function_requires<RegexConcept<Regex> >(); const global_regex_namespace::regex_error except(global_regex_namespace::regex_constants::error_collate); std::ptrdiff_t pt = except.position(); ignore_unused_variable_warning(pt); const Regex ce, ce2; #ifndef BOOST_NO_STD_LOCALE m_stream << ce; #endif unsigned i = ce.error_code(); ignore_unused_variable_warning(i); pointer_type p = ce.expression(); ignore_unused_variable_warning(p); int i2 = ce.compare(ce2); ignore_unused_variable_warning(i2); bool b = ce == ce2; ignore_unused_variable_warning(b); b = ce.empty(); ignore_unused_variable_warning(b); b = ce != ce2; ignore_unused_variable_warning(b); b = ce < ce2; ignore_unused_variable_warning(b); b = ce > ce2; ignore_unused_variable_warning(b); b = ce <= ce2; ignore_unused_variable_warning(b); b = ce >= ce2; ignore_unused_variable_warning(b); i = ce.status(); ignore_unused_variable_warning(i); size_type s = ce.max_size(); ignore_unused_variable_warning(s); s = ce.size(); ignore_unused_variable_warning(s); const_iterator pi = ce.begin(); ignore_unused_variable_warning(pi); pi = ce.end(); ignore_unused_variable_warning(pi); string_type s2 = ce.str(); ignore_unused_variable_warning(s2); m_string = m_sub + m_sub; ignore_unused_variable_warning(m_string); m_string = m_sub + m_pointer; ignore_unused_variable_warning(m_string); m_string = m_pointer + m_sub; ignore_unused_variable_warning(m_string); m_string = m_sub + m_string; ignore_unused_variable_warning(m_string); m_string = m_string + m_sub; ignore_unused_variable_warning(m_string); m_string = m_sub + m_char; ignore_unused_variable_warning(m_string); m_string = m_char + m_sub; ignore_unused_variable_warning(m_string); // Named sub-expressions: m_sub = m_cresults[&m_char]; ignore_unused_variable_warning(m_sub); m_sub = m_cresults[m_string]; ignore_unused_variable_warning(m_sub); m_sub = m_cresults[""]; ignore_unused_variable_warning(m_sub); m_sub = m_cresults[std::string("")]; ignore_unused_variable_warning(m_sub); m_string = m_cresults.str(&m_char); ignore_unused_variable_warning(m_string); m_string = m_cresults.str(m_string); ignore_unused_variable_warning(m_string); m_string = m_cresults.str(""); ignore_unused_variable_warning(m_string); m_string = m_cresults.str(std::string("")); ignore_unused_variable_warning(m_string); typename match_results_type::difference_type diff; diff = m_cresults.length(&m_char); ignore_unused_variable_warning(diff); diff = m_cresults.length(m_string); ignore_unused_variable_warning(diff); diff = m_cresults.length(""); ignore_unused_variable_warning(diff); diff = m_cresults.length(std::string("")); ignore_unused_variable_warning(diff); diff = m_cresults.position(&m_char); ignore_unused_variable_warning(diff); diff = m_cresults.position(m_string); ignore_unused_variable_warning(diff); diff = m_cresults.position(""); ignore_unused_variable_warning(diff); diff = m_cresults.position(std::string("")); ignore_unused_variable_warning(diff); #ifndef BOOST_NO_STD_LOCALE m_stream << m_sub; m_stream << m_cresults; #endif // // Extended formatting with a functor: // regex_constants::match_flag_type f = regex_constants::match_default; OutputIterator out = static_object<OutputIterator>::get(); functor3<match_results_default_type> func3; functor2<match_results_default_type> func2; functor1<match_results_default_type> func1; functor3<match_results_type> func3b; functor2<match_results_type> func2b; functor1<match_results_type> func1b; out = regex_format(out, m_cresults, func3b, f); out = regex_format(out, m_cresults, func3b); out = regex_format(out, m_cresults, func2b, f); out = regex_format(out, m_cresults, func2b); out = regex_format(out, m_cresults, func1b, f); out = regex_format(out, m_cresults, func1b); out = regex_format(out, m_cresults, boost::ref(func3b), f); out = regex_format(out, m_cresults, boost::ref(func3b)); out = regex_format(out, m_cresults, boost::ref(func2b), f); out = regex_format(out, m_cresults, boost::ref(func2b)); out = regex_format(out, m_cresults, boost::ref(func1b), f); out = regex_format(out, m_cresults, boost::ref(func1b)); out = regex_format(out, m_cresults, boost::cref(func3b), f); out = regex_format(out, m_cresults, boost::cref(func3b)); out = regex_format(out, m_cresults, boost::cref(func2b), f); out = regex_format(out, m_cresults, boost::cref(func2b)); out = regex_format(out, m_cresults, boost::cref(func1b), f); out = regex_format(out, m_cresults, boost::cref(func1b)); m_string += regex_format(m_cresults, func3b, f); m_string += regex_format(m_cresults, func3b); m_string += regex_format(m_cresults, func2b, f); m_string += regex_format(m_cresults, func2b); m_string += regex_format(m_cresults, func1b, f); m_string += regex_format(m_cresults, func1b); m_string += regex_format(m_cresults, boost::ref(func3b), f); m_string += regex_format(m_cresults, boost::ref(func3b)); m_string += regex_format(m_cresults, boost::ref(func2b), f); m_string += regex_format(m_cresults, boost::ref(func2b)); m_string += regex_format(m_cresults, boost::ref(func1b), f); m_string += regex_format(m_cresults, boost::ref(func1b)); m_string += regex_format(m_cresults, boost::cref(func3b), f); m_string += regex_format(m_cresults, boost::cref(func3b)); m_string += regex_format(m_cresults, boost::cref(func2b), f); m_string += regex_format(m_cresults, boost::cref(func2b)); m_string += regex_format(m_cresults, boost::cref(func1b), f); m_string += regex_format(m_cresults, boost::cref(func1b)); out = m_cresults.format(out, func3b, f); out = m_cresults.format(out, func3b); out = m_cresults.format(out, func2b, f); out = m_cresults.format(out, func2b); out = m_cresults.format(out, func1b, f); out = m_cresults.format(out, func1b); out = m_cresults.format(out, boost::ref(func3b), f); out = m_cresults.format(out, boost::ref(func3b)); out = m_cresults.format(out, boost::ref(func2b), f); out = m_cresults.format(out, boost::ref(func2b)); out = m_cresults.format(out, boost::ref(func1b), f); out = m_cresults.format(out, boost::ref(func1b)); out = m_cresults.format(out, boost::cref(func3b), f); out = m_cresults.format(out, boost::cref(func3b)); out = m_cresults.format(out, boost::cref(func2b), f); out = m_cresults.format(out, boost::cref(func2b)); out = m_cresults.format(out, boost::cref(func1b), f); out = m_cresults.format(out, boost::cref(func1b)); m_string += m_cresults.format(func3b, f); m_string += m_cresults.format(func3b); m_string += m_cresults.format(func2b, f); m_string += m_cresults.format(func2b); m_string += m_cresults.format(func1b, f); m_string += m_cresults.format(func1b); m_string += m_cresults.format(boost::ref(func3b), f); m_string += m_cresults.format(boost::ref(func3b)); m_string += m_cresults.format(boost::ref(func2b), f); m_string += m_cresults.format(boost::ref(func2b)); m_string += m_cresults.format(boost::ref(func1b), f); m_string += m_cresults.format(boost::ref(func1b)); m_string += m_cresults.format(boost::cref(func3b), f); m_string += m_cresults.format(boost::cref(func3b)); m_string += m_cresults.format(boost::cref(func2b), f); m_string += m_cresults.format(boost::cref(func2b)); m_string += m_cresults.format(boost::cref(func1b), f); m_string += m_cresults.format(boost::cref(func1b)); out = regex_replace(out, m_in, m_in, ce, func3, f); out = regex_replace(out, m_in, m_in, ce, func3); out = regex_replace(out, m_in, m_in, ce, func2, f); out = regex_replace(out, m_in, m_in, ce, func2); out = regex_replace(out, m_in, m_in, ce, func1, f); out = regex_replace(out, m_in, m_in, ce, func1); out = regex_replace(out, m_in, m_in, ce, boost::ref(func3), f); out = regex_replace(out, m_in, m_in, ce, boost::ref(func3)); out = regex_replace(out, m_in, m_in, ce, boost::ref(func2), f); out = regex_replace(out, m_in, m_in, ce, boost::ref(func2)); out = regex_replace(out, m_in, m_in, ce, boost::ref(func1), f); out = regex_replace(out, m_in, m_in, ce, boost::ref(func1)); out = regex_replace(out, m_in, m_in, ce, boost::cref(func3), f); out = regex_replace(out, m_in, m_in, ce, boost::cref(func3)); out = regex_replace(out, m_in, m_in, ce, boost::cref(func2), f); out = regex_replace(out, m_in, m_in, ce, boost::cref(func2)); out = regex_replace(out, m_in, m_in, ce, boost::cref(func1), f); out = regex_replace(out, m_in, m_in, ce, boost::cref(func1)); functor3<match_results<typename string_type::const_iterator> > func3s; functor2<match_results<typename string_type::const_iterator> > func2s; functor1<match_results<typename string_type::const_iterator> > func1s; m_string += regex_replace(m_string, ce, func3s, f); m_string += regex_replace(m_string, ce, func3s); m_string += regex_replace(m_string, ce, func2s, f); m_string += regex_replace(m_string, ce, func2s); m_string += regex_replace(m_string, ce, func1s, f); m_string += regex_replace(m_string, ce, func1s); m_string += regex_replace(m_string, ce, boost::ref(func3s), f); m_string += regex_replace(m_string, ce, boost::ref(func3s)); m_string += regex_replace(m_string, ce, boost::ref(func2s), f); m_string += regex_replace(m_string, ce, boost::ref(func2s)); m_string += regex_replace(m_string, ce, boost::ref(func1s), f); m_string += regex_replace(m_string, ce, boost::ref(func1s)); m_string += regex_replace(m_string, ce, boost::cref(func3s), f); m_string += regex_replace(m_string, ce, boost::cref(func3s)); m_string += regex_replace(m_string, ce, boost::cref(func2s), f); m_string += regex_replace(m_string, ce, boost::cref(func2s)); m_string += regex_replace(m_string, ce, boost::cref(func1s), f); m_string += regex_replace(m_string, ce, boost::cref(func1s)); } std::basic_ostream<value_type> m_stream; sub_match_type m_sub; pointer_type m_pointer; string_type m_string; const value_type m_char; match_results_type m_results; const match_results_type m_cresults; BidiIterator m_in; BoostRegexConcept(); BoostRegexConcept(const BoostRegexConcept&); BoostRegexConcept& operator=(const BoostRegexConcept&); }; #endif // BOOST_REGEX_TEST_STD } #endif