← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/regex/concepts.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/boost-lib/boost/regex/concepts.hpp
68
68
//
69
69
} // namespace boost
70
70
namespace std{
71
 
   template<> struct char_traits<boost::char_architype>{};
 
71
   template<> struct char_traits<boost::char_architype>
 
72
   {
 
73
      // The intent is that this template is not instantiated,
 
74
      // but this typedef gives us a chance of compilation in
 
75
      // case it is:
 
76
      typedef boost::char_architype char_type;
 
77
   };
72
78
}
 
79
//
 
80
// Allocator architype:
 
81
//
 
82
template <class T>
 
83
class allocator_architype
 
84
{
 
85
public:
 
86
   typedef T* pointer;
 
87
   typedef const T* const_pointer;
 
88
   typedef T& reference;
 
89
   typedef const T& const_reference;
 
90
   typedef T value_type;
 
91
   typedef unsigned size_type;
 
92
   typedef int difference_type;
 
93
 
 
94
   template <class U>
 
95
   struct rebind
 
96
   {
 
97
      typedef allocator_architype<U> other;
 
98
   };
 
99
 
 
100
   pointer address(reference r);
 
101
   const_pointer address(const_reference r);
 
102
   pointer allocate(size_type);
 
103
   pointer allocate(size_type, pointer);
 
104
   void deallocate(pointer, size_type);
 
105
   size_type max_size()const;
 
106
 
 
107
   allocator_architype();
 
108
   allocator_architype(const allocator_architype&);
 
109
 
 
110
   template <class Other>
 
111
   allocator_architype(const allocator_architype<Other>&);
 
112
 
 
113
   void construct(pointer, const_reference);
 
114
   void destroy(pointer);
 
115
};
 
116
 
 
117
template <class T>
 
118
bool operator == (const allocator_architype<T>&, const allocator_architype<T>&);
 
119
template <class T>
 
120
bool operator != (const allocator_architype<T>&, const allocator_architype<T>&);
 
121
 
73
122
namespace boost{
74
123
//
75
124
// regex_traits_architype:
81
130
public:
82
131
   regex_traits_architype();
83
132
   typedef charT char_type;
84
 
   typedef std::size_t size_type;
 
133
   // typedef std::size_t size_type;
85
134
   typedef std::vector<char_type> string_type;
86
135
   typedef copy_constructible_archetype<assignable_archetype<> > locale_type;
87
136
   typedef bitmask_archetype char_class_type;
88
137
 
89
 
   static size_type length(const char_type* ) { return 0; }
 
138
   static std::size_t length(const char_type* ) { return 0; }
90
139
 
91
140
   charT translate(charT ) const { return charT(); }
92
141
   charT translate_nocase(charT ) const { return static_object<charT>::get(); }
157
206
   RegexTraitsConcept();
158
207
   // required typedefs:
159
208
   typedef typename traits::char_type char_type;
160
 
   typedef typename traits::size_type size_type;
 
209
   // typedef typename traits::size_type size_type;
161
210
   typedef typename traits::string_type string_type;
162
211
   typedef typename traits::locale_type locale_type;
163
212
   typedef typename traits::char_class_type char_class_type;
164
213
 
165
214
   void constraints() 
166
215
   {
167
 
      function_requires<UnsignedIntegerConcept<size_type> >();
 
216
      //function_requires<UnsignedIntegerConcept<size_type> >();
168
217
      function_requires<RandomAccessContainerConcept<string_type> >();
169
218
      function_requires<DefaultConstructibleConcept<locale_type> >();
170
219
      function_requires<CopyConstructibleConcept<locale_type> >();
171
220
      function_requires<AssignableConcept<locale_type> >();
172
221
      function_requires<BitmaskConcept<char_class_type> >();
173
222
 
174
 
      size_type n = traits::length(m_pointer);
 
223
      std::size_t n = traits::length(m_pointer);
175
224
      ignore_unused_variable_warning(n);
176
225
 
177
226
      char_type c = m_ctraits.translate(m_char);
205
254
   const traits m_ctraits;
206
255
   const char_type* m_pointer;
207
256
   char_type m_char;
 
257
private:
 
258
   RegexTraitsConcept& operator=(RegexTraitsConcept&);
208
259
};
209
260
 
210
261
//
227
278
struct BaseRegexConcept
228
279
{
229
280
   typedef typename Regex::value_type value_type;
230
 
   typedef typename Regex::size_type size_type;
 
281
   //typedef typename Regex::size_type size_type;
231
282
   typedef typename Regex::flag_type flag_type;
232
283
   typedef typename Regex::locale_type locale_type;
233
284
   typedef input_iterator_archetype<value_type> input_iterator_type;
236
287
   typedef const value_type* pointer_type;
237
288
   typedef bidirectional_iterator_archetype<value_type> BidiIterator;
238
289
   typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
239
 
   typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
 
290
   typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
 
291
   typedef global_regex_namespace::match_results<BidiIterator> match_results_default_type;
240
292
   typedef output_iterator_archetype<value_type> OutIterator;
241
293
   typedef typename regex_traits_computer<Regex>::type traits_type;
242
294
   typedef global_regex_namespace::regex_iterator<BidiIterator, value_type, traits_type> regex_iterator_type;
310
362
      const global_regex_namespace::regex_error except(e1);
311
363
      e1 = except.code();
312
364
 
313
 
      typedef typename Regex::value_type value_type;
 
365
      typedef typename Regex::value_type regex_value_type;
314
366
      function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();
315
367
      function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();
316
368
   }
360
412
 
361
413
      // access:
362
414
      const Regex ce;
363
 
      bool b = ce.empty();
364
 
      ignore_unused_variable_warning(b);
365
 
      size_type i = ce.mark_count();
 
415
      unsigned i = ce.mark_count();
366
416
      ignore_unused_variable_warning(i);
367
417
      m_flags = ce.flags();
368
418
      e.imbue(ce.getloc());
377
427
      typedef typename sub_match_type::iterator sub_iter_type;
378
428
      BOOST_STATIC_ASSERT((::boost::is_same<sub_value_type, value_type>::value));
379
429
      BOOST_STATIC_ASSERT((::boost::is_same<sub_iter_type, BidiIterator>::value));
380
 
      b = m_sub.matched;
 
430
      bool b = m_sub.matched;
381
431
      ignore_unused_variable_warning(b);
382
432
      BidiIterator bi = m_sub.first;
383
433
      ignore_unused_variable_warning(bi);
403
453
      match_results_type m3(m1);
404
454
      m1 = m2;
405
455
 
 
456
      int ival = 0;
 
457
 
406
458
      mr_size_type mrs = m_cresults.size();
407
459
      ignore_unused_variable_warning(mrs);
408
460
      mrs = m_cresults.max_size();
411
463
      ignore_unused_variable_warning(b);
412
464
      mr_difference_type mrd = m_cresults.length();
413
465
      ignore_unused_variable_warning(mrd);
414
 
      mrd = m_cresults.length(mrs);
 
466
      mrd = m_cresults.length(ival);
415
467
      ignore_unused_variable_warning(mrd);
416
468
      mrd = m_cresults.position();
417
469
      ignore_unused_variable_warning(mrd);
418
470
      mrd = m_cresults.position(mrs);
419
471
      ignore_unused_variable_warning(mrd);
420
472
 
421
 
      mr_const_reference mrcr = m_cresults[m_size];
 
473
      mr_const_reference mrcr = m_cresults[ival];
422
474
      ignore_unused_variable_warning(mrcr);
423
475
      mr_const_reference mrcr2 = m_cresults.prefix();
424
476
      ignore_unused_variable_warning(mrcr2);
476
528
      typedef typename regex_iterator_type::reference rit_reference;
477
529
      typedef typename regex_iterator_type::iterator_category rit_iterator_category;
478
530
      BOOST_STATIC_ASSERT((::boost::is_same<rit_regex_type, Regex>::value));
479
 
      BOOST_STATIC_ASSERT((::boost::is_same<rit_value_type, match_results_type>::value));
 
531
      BOOST_STATIC_ASSERT((::boost::is_same<rit_value_type, match_results_default_type>::value));
480
532
      BOOST_STATIC_ASSERT((::boost::is_same<rit_difference_type, std::ptrdiff_t>::value));
481
 
      BOOST_STATIC_ASSERT((::boost::is_same<rit_pointer, const match_results_type*>::value));
482
 
      BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_type&>::value));
 
533
      BOOST_STATIC_ASSERT((::boost::is_same<rit_pointer, const match_results_default_type*>::value));
 
534
      BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_default_type&>::value));
483
535
      BOOST_STATIC_ASSERT((::boost::is_convertible<rit_iterator_category*, std::forward_iterator_tag*>::value));
484
536
      // this takes care of most of the checks needed:
485
537
      function_requires<ForwardIteratorConcept<regex_iterator_type> >();
523
575
 
524
576
   pointer_type m_pointer;
525
577
   flag_type m_flags;
526
 
   size_type m_size;
 
578
   std::size_t m_size;
527
579
   input_iterator_type in1, in2;
528
580
   const sub_match_type m_sub;
529
581
   const value_type m_char;
532
584
   OutIterator m_out;
533
585
   BidiIterator m_in;
534
586
   global_regex_namespace::regex_constants::match_flag_type m_mft;
535
 
   global_regex_namespace::match_results<pointer_type> m_pmatch;
 
587
   global_regex_namespace::match_results<
 
588
      pointer_type, 
 
589
      allocator_architype<global_regex_namespace::sub_match<pointer_type> > > 
 
590
      m_pmatch;
536
591
 
537
592
   BaseRegexConcept();
538
593
   BaseRegexConcept(const BaseRegexConcept&);
547
602
struct RegexConcept
548
603
{
549
604
   typedef typename Regex::value_type value_type;
550
 
   typedef typename Regex::size_type size_type;
 
605
   //typedef typename Regex::size_type size_type;
551
606
   typedef typename Regex::flag_type flag_type;
552
607
   typedef typename Regex::locale_type locale_type;
553
608
 
556
611
   typedef std::basic_string<value_type> string_type;
557
612
   typedef boost::bidirectional_iterator_archetype<value_type> BidiIterator;
558
613
   typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
559
 
   typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
 
614
   typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
560
615
   typedef output_iterator_archetype<value_type> OutIterator;
561
616
 
562
617
 
731
786
   OutIterator m_out;
732
787
   BidiIterator m_in;
733
788
   global_regex_namespace::regex_constants::match_flag_type m_mft;
734
 
   global_regex_namespace::match_results<typename string_type::const_iterator> m_smatch;
 
789
   global_regex_namespace::match_results<typename string_type::const_iterator, allocator_architype<global_regex_namespace::sub_match<typename string_type::const_iterator> > > m_smatch;
735
790
 
736
791
   RegexConcept();
737
792
   RegexConcept(const RegexConcept&);
738
793
   RegexConcept& operator=(const RegexConcept&);
739
794
};
740
795
 
 
796
#ifndef BOOST_REGEX_TEST_STD
 
797
 
 
798
template <class M>
 
799
struct functor1
 
800
{
 
801
   typedef typename M::char_type char_type;
 
802
   const char_type* operator()(const M&)const
 
803
   {
 
804
      static const char_type c = static_cast<char_type>(0);
 
805
      return &c;
 
806
   }
 
807
};
 
808
template <class M>
 
809
struct functor1b
 
810
{
 
811
   typedef typename M::char_type char_type;
 
812
   std::vector<char_type> operator()(const M&)const
 
813
   {
 
814
      static const std::vector<char_type> c;
 
815
      return c;
 
816
   }
 
817
};
 
818
template <class M>
 
819
struct functor2
 
820
{
 
821
   template <class O>
 
822
   O operator()(const M& /*m*/, O i)const
 
823
   {
 
824
      return i;
 
825
   }
 
826
};
 
827
template <class M>
 
828
struct functor3
 
829
{
 
830
   template <class O>
 
831
   O operator()(const M& /*m*/, O i, regex_constants::match_flag_type)const
 
832
   {
 
833
      return i;
 
834
   }
 
835
};
 
836
 
741
837
//
742
838
// BoostRegexConcept:
743
839
// Test every interface in the Boost implementation:
755
851
   typedef std::basic_string<value_type> string_type;
756
852
   typedef typename Regex::const_iterator const_iterator;
757
853
   typedef bidirectional_iterator_archetype<value_type> BidiIterator;
 
854
   typedef output_iterator_archetype<value_type> OutputIterator;
758
855
   typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
759
 
   typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
 
856
   typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
 
857
   typedef global_regex_namespace::match_results<BidiIterator> match_results_default_type;
760
858
 
761
859
   void constraints() 
762
860
   {
777
875
         | global_regex_namespace::regex_constants::format_no_copy
778
876
         | global_regex_namespace::regex_constants::format_first_only;
779
877
 
 
878
      (void)mopts;
 
879
 
780
880
      function_requires<RegexConcept<Regex> >();
781
881
      const global_regex_namespace::regex_error except(global_regex_namespace::regex_constants::error_collate);
782
882
      std::ptrdiff_t pt = except.position();
793
893
      ignore_unused_variable_warning(i2);
794
894
      bool b = ce == ce2;
795
895
      ignore_unused_variable_warning(b);
 
896
      b = ce.empty();
 
897
      ignore_unused_variable_warning(b);
796
898
      b = ce != ce2;
797
899
      ignore_unused_variable_warning(b);
798
900
      b = ce < ce2;
831
933
      m_string = m_char + m_sub;
832
934
      ignore_unused_variable_warning(m_string);
833
935
 
 
936
      // Named sub-expressions:
 
937
      m_sub = m_cresults[&m_char];
 
938
      ignore_unused_variable_warning(m_sub);
 
939
      m_sub = m_cresults[m_string];
 
940
      ignore_unused_variable_warning(m_sub);
 
941
      m_sub = m_cresults[""];
 
942
      ignore_unused_variable_warning(m_sub);
 
943
      m_sub = m_cresults[std::string("")];
 
944
      ignore_unused_variable_warning(m_sub);
 
945
      m_string = m_cresults.str(&m_char);
 
946
      ignore_unused_variable_warning(m_string);
 
947
      m_string = m_cresults.str(m_string);
 
948
      ignore_unused_variable_warning(m_string);
 
949
      m_string = m_cresults.str("");
 
950
      ignore_unused_variable_warning(m_string);
 
951
      m_string = m_cresults.str(std::string(""));
 
952
      ignore_unused_variable_warning(m_string);
 
953
 
 
954
      typename match_results_type::difference_type diff;
 
955
      diff = m_cresults.length(&m_char);
 
956
      ignore_unused_variable_warning(diff);
 
957
      diff = m_cresults.length(m_string);
 
958
      ignore_unused_variable_warning(diff);
 
959
      diff = m_cresults.length("");
 
960
      ignore_unused_variable_warning(diff);
 
961
      diff = m_cresults.length(std::string(""));
 
962
      ignore_unused_variable_warning(diff);
 
963
      diff = m_cresults.position(&m_char);
 
964
      ignore_unused_variable_warning(diff);
 
965
      diff = m_cresults.position(m_string);
 
966
      ignore_unused_variable_warning(diff);
 
967
      diff = m_cresults.position("");
 
968
      ignore_unused_variable_warning(diff);
 
969
      diff = m_cresults.position(std::string(""));
 
970
      ignore_unused_variable_warning(diff);
 
971
 
834
972
#ifndef BOOST_NO_STD_LOCALE
835
973
      m_stream << m_sub;
836
974
      m_stream << m_cresults;
837
975
#endif
 
976
      //
 
977
      // Extended formatting with a functor:
 
978
      //
 
979
      regex_constants::match_flag_type f = regex_constants::match_default;
 
980
      OutputIterator out = static_object<OutputIterator>::get();
 
981
      
 
982
      functor3<match_results_default_type> func3;
 
983
      functor2<match_results_default_type> func2;
 
984
      functor1<match_results_default_type> func1;
 
985
      
 
986
      functor3<match_results_type> func3b;
 
987
      functor2<match_results_type> func2b;
 
988
      functor1<match_results_type> func1b;
 
989
 
 
990
      out = regex_format(out, m_cresults, func3b, f);
 
991
      out = regex_format(out, m_cresults, func3b);
 
992
      out = regex_format(out, m_cresults, func2b, f);
 
993
      out = regex_format(out, m_cresults, func2b);
 
994
      out = regex_format(out, m_cresults, func1b, f);
 
995
      out = regex_format(out, m_cresults, func1b);
 
996
      out = regex_format(out, m_cresults, boost::ref(func3b), f);
 
997
      out = regex_format(out, m_cresults, boost::ref(func3b));
 
998
      out = regex_format(out, m_cresults, boost::ref(func2b), f);
 
999
      out = regex_format(out, m_cresults, boost::ref(func2b));
 
1000
      out = regex_format(out, m_cresults, boost::ref(func1b), f);
 
1001
      out = regex_format(out, m_cresults, boost::ref(func1b));
 
1002
      out = regex_format(out, m_cresults, boost::cref(func3b), f);
 
1003
      out = regex_format(out, m_cresults, boost::cref(func3b));
 
1004
      out = regex_format(out, m_cresults, boost::cref(func2b), f);
 
1005
      out = regex_format(out, m_cresults, boost::cref(func2b));
 
1006
      out = regex_format(out, m_cresults, boost::cref(func1b), f);
 
1007
      out = regex_format(out, m_cresults, boost::cref(func1b));
 
1008
 
 
1009
      m_string += regex_format(m_cresults, func3b, f);
 
1010
      m_string += regex_format(m_cresults, func3b);
 
1011
      m_string += regex_format(m_cresults, func2b, f);
 
1012
      m_string += regex_format(m_cresults, func2b);
 
1013
      m_string += regex_format(m_cresults, func1b, f);
 
1014
      m_string += regex_format(m_cresults, func1b);
 
1015
      m_string += regex_format(m_cresults, boost::ref(func3b), f);
 
1016
      m_string += regex_format(m_cresults, boost::ref(func3b));
 
1017
      m_string += regex_format(m_cresults, boost::ref(func2b), f);
 
1018
      m_string += regex_format(m_cresults, boost::ref(func2b));
 
1019
      m_string += regex_format(m_cresults, boost::ref(func1b), f);
 
1020
      m_string += regex_format(m_cresults, boost::ref(func1b));
 
1021
      m_string += regex_format(m_cresults, boost::cref(func3b), f);
 
1022
      m_string += regex_format(m_cresults, boost::cref(func3b));
 
1023
      m_string += regex_format(m_cresults, boost::cref(func2b), f);
 
1024
      m_string += regex_format(m_cresults, boost::cref(func2b));
 
1025
      m_string += regex_format(m_cresults, boost::cref(func1b), f);
 
1026
      m_string += regex_format(m_cresults, boost::cref(func1b));
 
1027
 
 
1028
      out = m_cresults.format(out, func3b, f);
 
1029
      out = m_cresults.format(out, func3b);
 
1030
      out = m_cresults.format(out, func2b, f);
 
1031
      out = m_cresults.format(out, func2b);
 
1032
      out = m_cresults.format(out, func1b, f);
 
1033
      out = m_cresults.format(out, func1b);
 
1034
      out = m_cresults.format(out, boost::ref(func3b), f);
 
1035
      out = m_cresults.format(out, boost::ref(func3b));
 
1036
      out = m_cresults.format(out, boost::ref(func2b), f);
 
1037
      out = m_cresults.format(out, boost::ref(func2b));
 
1038
      out = m_cresults.format(out, boost::ref(func1b), f);
 
1039
      out = m_cresults.format(out, boost::ref(func1b));
 
1040
      out = m_cresults.format(out, boost::cref(func3b), f);
 
1041
      out = m_cresults.format(out, boost::cref(func3b));
 
1042
      out = m_cresults.format(out, boost::cref(func2b), f);
 
1043
      out = m_cresults.format(out, boost::cref(func2b));
 
1044
      out = m_cresults.format(out, boost::cref(func1b), f);
 
1045
      out = m_cresults.format(out, boost::cref(func1b));
 
1046
 
 
1047
      m_string += m_cresults.format(func3b, f);
 
1048
      m_string += m_cresults.format(func3b);
 
1049
      m_string += m_cresults.format(func2b, f);
 
1050
      m_string += m_cresults.format(func2b);
 
1051
      m_string += m_cresults.format(func1b, f);
 
1052
      m_string += m_cresults.format(func1b);
 
1053
      m_string += m_cresults.format(boost::ref(func3b), f);
 
1054
      m_string += m_cresults.format(boost::ref(func3b));
 
1055
      m_string += m_cresults.format(boost::ref(func2b), f);
 
1056
      m_string += m_cresults.format(boost::ref(func2b));
 
1057
      m_string += m_cresults.format(boost::ref(func1b), f);
 
1058
      m_string += m_cresults.format(boost::ref(func1b));
 
1059
      m_string += m_cresults.format(boost::cref(func3b), f);
 
1060
      m_string += m_cresults.format(boost::cref(func3b));
 
1061
      m_string += m_cresults.format(boost::cref(func2b), f);
 
1062
      m_string += m_cresults.format(boost::cref(func2b));
 
1063
      m_string += m_cresults.format(boost::cref(func1b), f);
 
1064
      m_string += m_cresults.format(boost::cref(func1b));
 
1065
 
 
1066
      out = regex_replace(out, m_in, m_in, ce, func3, f);
 
1067
      out = regex_replace(out, m_in, m_in, ce, func3);
 
1068
      out = regex_replace(out, m_in, m_in, ce, func2, f);
 
1069
      out = regex_replace(out, m_in, m_in, ce, func2);
 
1070
      out = regex_replace(out, m_in, m_in, ce, func1, f);
 
1071
      out = regex_replace(out, m_in, m_in, ce, func1);
 
1072
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func3), f);
 
1073
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func3));
 
1074
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func2), f);
 
1075
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func2));
 
1076
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func1), f);
 
1077
      out = regex_replace(out, m_in, m_in, ce, boost::ref(func1));
 
1078
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func3), f);
 
1079
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func3));
 
1080
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func2), f);
 
1081
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func2));
 
1082
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func1), f);
 
1083
      out = regex_replace(out, m_in, m_in, ce, boost::cref(func1));
 
1084
 
 
1085
      functor3<match_results<typename string_type::const_iterator> > func3s;
 
1086
      functor2<match_results<typename string_type::const_iterator> > func2s;
 
1087
      functor1<match_results<typename string_type::const_iterator> > func1s;
 
1088
      m_string += regex_replace(m_string, ce, func3s, f);
 
1089
      m_string += regex_replace(m_string, ce, func3s);
 
1090
      m_string += regex_replace(m_string, ce, func2s, f);
 
1091
      m_string += regex_replace(m_string, ce, func2s);
 
1092
      m_string += regex_replace(m_string, ce, func1s, f);
 
1093
      m_string += regex_replace(m_string, ce, func1s);
 
1094
      m_string += regex_replace(m_string, ce, boost::ref(func3s), f);
 
1095
      m_string += regex_replace(m_string, ce, boost::ref(func3s));
 
1096
      m_string += regex_replace(m_string, ce, boost::ref(func2s), f);
 
1097
      m_string += regex_replace(m_string, ce, boost::ref(func2s));
 
1098
      m_string += regex_replace(m_string, ce, boost::ref(func1s), f);
 
1099
      m_string += regex_replace(m_string, ce, boost::ref(func1s));
 
1100
      m_string += regex_replace(m_string, ce, boost::cref(func3s), f);
 
1101
      m_string += regex_replace(m_string, ce, boost::cref(func3s));
 
1102
      m_string += regex_replace(m_string, ce, boost::cref(func2s), f);
 
1103
      m_string += regex_replace(m_string, ce, boost::cref(func2s));
 
1104
      m_string += regex_replace(m_string, ce, boost::cref(func1s), f);
 
1105
      m_string += regex_replace(m_string, ce, boost::cref(func1s));
838
1106
   }
839
1107
 
840
1108
   std::basic_ostream<value_type> m_stream;
844
1112
   const value_type m_char;
845
1113
   match_results_type m_results;
846
1114
   const match_results_type m_cresults;
 
1115
   BidiIterator m_in;
847
1116
 
848
1117
   BoostRegexConcept();
849
1118
   BoostRegexConcept(const BoostRegexConcept&);
850
1119
   BoostRegexConcept& operator=(const BoostRegexConcept&);
851
1120
};
852
1121
 
 
1122
#endif // BOOST_REGEX_TEST_STD
 
1123
 
853
1124
}
854
1125
 
855
1126
#endif