include/boost/regex/v5/basic_regex.hpp

97.6% Lines (200/205) 96.9% List of functions (341/352)

[ ] prev/next file n p prev/next uncovered line

basic_regex.hpp

f(x) Functions (352)

Function Calls Lines Blocks

Line	Hits	Source Code
1		/*
2		*
3		* Copyright (c) 1998-2004 John Maddock
4		* Copyright 2011 Garmin Ltd. or its subsidiaries
5		*
6		* Distributed under the Boost Software License, Version 1.0.
7		* (See accompanying file LICENSE_1_0.txt or copy at
8		* http://www.boost.org/LICENSE_1_0.txt)
9		*
10		*/
11
12		/*
13		* LOCATION: see http://www.boost.org/ for most recent version.
14		* FILE basic_regex.cpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Declares template class basic_regex.
17		*/
18
19		#ifndef BOOST_REGEX_V5_BASIC_REGEX_HPP
20		#define BOOST_REGEX_V5_BASIC_REGEX_HPP
21
22		#include <boost/regex/v5/regbase.hpp>
23		#include <boost/regex/v5/syntax_type.hpp>
24		#include <boost/regex/v5/regex_traits.hpp>
25		#include <boost/regex/v5/states.hpp>
26		#include <boost/regex/v5/regex_raw_buffer.hpp>
27
28		#ifndef BOOST_REGEX_AS_MODULE
29		#include <algorithm>
30		#include <limits>
31		#include <memory>
32		#include <vector>
33		#endif
34
35		namespace boost{
36		#ifdef BOOST_REGEX_MSVC
37		#pragma warning(push)
38		#pragma warning(disable : 4251)
39		#if BOOST_REGEX_MSVC < 1700
40		# pragma warning(disable : 4231)
41		#endif
42		#if BOOST_REGEX_MSVC < 1600
43		#pragma warning(disable : 4660)
44		#endif
45		#if BOOST_REGEX_MSVC < 1910
46		#pragma warning(disable:4800)
47		#endif
48		#endif
49
50		namespace BOOST_REGEX_DETAIL_NS{
51
52		//
53		// forward declaration, we will need this one later:
54		//
55		template <class charT, class traits>
56		class basic_regex_parser;
57
58		template <class I>
59	20848x	void bubble_down_one(I first, I last)
60		{
61	20848x	if(first != last)
62		{
63	20848x	I next = last - 1;
64	27640x	while((next != first) && (next < (next-1)))
65		{
66	6792x	(next-1)->swap(*next);
67	6792x	--next;
68		}
69		}
70	20848x	}
71
72		#ifndef BOOST_REGEX_AS_MODULE
73		static
74		#else
75		inline
76		#endif
77		const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
78
79		template <class Iterator>
80	198658x	inline int hash_value_from_capture_name(Iterator i, Iterator j)
81		{
82	198658x	std::size_t r = 0;
83	624786x	while (i != j)
84		{
85	426128x	r ^= *i + 0x9e3779b9 + (r << 6) + (r >> 2);
86	426128x	++i;
87		}
88	198658x	r %= ((std::numeric_limits<int>::max)());
89	198658x	return static_cast<int>(r) \| hash_value_mask;
90		}
91
92	✗	class named_subexpressions
93		{
94		public:
95		struct name
96		{
97		template <class charT>
98	184544x	name(const charT* i, const charT* j, int idx)
99	184544x	: index(idx)
100		{
101	184544x	hash = hash_value_from_capture_name(i, j);
102	184544x	}
103	33019x	name(int h, int idx)
104	33019x	: index(idx), hash(h)
105		{
106	33019x	}
107		int index;
108		int hash;
109	114716x	bool operator < (const name& other)const
110		{
111	114716x	return hash < other.hash;
112		}
113	12425x	bool operator == (const name& other)const
114		{
115	12425x	return hash == other.hash;
116		}
117	6792x	void swap(name& other)
118		{
119	6792x	std::swap(index, other.index);
120	6792x	std::swap(hash, other.hash);
121	6792x	}
122		};
123
124		typedef std::vector<name>::const_iterator const_iterator;
125		typedef std::pair<const_iterator, const_iterator> range_type;
126
127	408299x	named_subexpressions(){}
128
129		template <class charT>
130	20848x	void set_name(const charT* i, const charT* j, int index)
131		{
132	20848x	m_sub_names.push_back(name(i, j, index));
133	20848x	bubble_down_one(m_sub_names.begin(), m_sub_names.end());
134	20848x	}
135		template <class charT>
136		int get_id(const charT* i, const charT* j)const
137		{
138		name t(i, j, 0);
139		typename std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);
140		if((pos != m_sub_names.end()) && (*pos == t))
141		{
142		return pos->index;
143		}
144		return -1;
145		}
146		template <class charT>
147	163696x	range_type equal_range(const charT* i, const charT* j)const
148		{
149	163696x	name t(i, j, 0);
150	313756x	return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t);
151		}
152	13435x	int get_id(int h)const
153		{
154	13435x	name t(h, 0);
155	13435x	std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);
156	13435x	if((pos != m_sub_names.end()) && (*pos == t))
157		{
158	11249x	return pos->index;
159		}
160	2186x	return -1;
161		}
162	19584x	range_type equal_range(int h)const
163		{
164	19584x	name t(h, 0);
165	37536x	return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t);
166		}
167		private:
168		std::vector<name> m_sub_names;
169		};
170
171		//
172		// class regex_data:
173		// represents the data we wish to expose to the matching algorithms.
174		//
175		template <class charT, class traits>
176		struct regex_data : public named_subexpressions
177		{
178		typedef regex_constants::syntax_option_type flag_type;
179		typedef std::size_t size_type;
180
181	111103x	regex_data(const ::std::shared_ptr<
182		::boost::regex_traits_wrapper<traits> >& t)
183	111103x	: m_ptraits(t), m_flags(0), m_status(0), m_expression(0), m_expression_len(0),
184	111103x	m_mark_count(0), m_first_state(0), m_restart_type(0),
185	111103x	m_startmap{ 0 },
186	222206x	m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
187	297196x	regex_data()
188	297196x	: m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_flags(0), m_status(0), m_expression(0), m_expression_len(0),
189	297196x	m_mark_count(0), m_first_state(0), m_restart_type(0),
190	297196x	m_startmap{ 0 },
191	594392x	m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
192
193		::std::shared_ptr<
194		::boost::regex_traits_wrapper<traits>
195		> m_ptraits; // traits class instance
196		flag_type m_flags; // flags with which we were compiled
197		int m_status; // error code (0 implies OK).
198		const charT* m_expression; // the original expression
199		std::ptrdiff_t m_expression_len; // the length of the original expression
200		size_type m_mark_count; // the number of marked sub-expressions
201		BOOST_REGEX_DETAIL_NS::re_syntax_base* m_first_state; // the first state of the machine
202		unsigned m_restart_type; // search optimisation type
203		unsigned char m_startmap[1 << CHAR_BIT]; // which characters can start a match
204		unsigned int m_can_be_null; // whether we can match a null string
205		BOOST_REGEX_DETAIL_NS::raw_storage m_data; // the buffer in which our states are constructed
206		typename traits::char_class_type m_word_mask; // mask used to determine if a character is a word character
207		std::vector<
208		std::pair<
209		std::size_t, std::size_t> > m_subs; // Position of sub-expressions within the string.
210		bool m_has_recursions; // whether we have recursive expressions;
211		bool m_disable_match_any; // when set we need to disable the match_any flag as it causes different/buggy behaviour.
212		};
213		//
214		// class basic_regex_implementation
215		// pimpl implementation class for basic_regex.
216		//
217		template <class charT, class traits>
218	✗	class basic_regex_implementation
219		: public regex_data<charT, traits>
220		{
221		public:
222		typedef regex_constants::syntax_option_type flag_type;
223		typedef std::ptrdiff_t difference_type;
224		typedef std::size_t size_type;
225		typedef typename traits::locale_type locale_type;
226		typedef const charT* const_iterator;
227
228	297196x	basic_regex_implementation(){}
229	111103x	basic_regex_implementation(const ::std::shared_ptr<
230		::boost::regex_traits_wrapper<traits> >& t)
231	111103x	: regex_data<charT, traits>(t) {}
232	408235x	void assign(const charT* arg_first,
233		const charT* arg_last,
234		flag_type f)
235		{
236	408235x	regex_data<charT, traits>* pdat = this;
237	408235x	basic_regex_parser<charT, traits> parser(pdat);
238	408235x	parser.parse(arg_first, arg_last, f);
239	408235x	}
240
241	64x	locale_type imbue(locale_type l)
242		{
243	64x	return this->m_ptraits->imbue(l);
244		}
245		locale_type getloc()const
246		{
247		return this->m_ptraits->getloc();
248		}
249	26772x	std::basic_string<charT> str()const
250		{
251	26772x	std::basic_string<charT> result;
252	26772x	if(this->m_status == 0)
253	✗	result = std::basic_string<charT>(this->m_expression, this->m_expression_len);
254	26772x	return result;
255	✗	}
256	137232x	const_iterator expression()const
257		{
258	137232x	return this->m_expression;
259		}
260	154394x	std::pair<const_iterator, const_iterator> subexpression(std::size_t n)const
261		{
262	154394x	const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n);
263	68616x	std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);
264	68616x	return p;
265		}
266		//
267		// begin, end:
268	147120x	const_iterator begin()const
269		{
270	147120x	return (this->m_status ? 0 : this->m_expression);
271		}
272	147120x	const_iterator end()const
273		{
274	147120x	return (this->m_status ? 0 : this->m_expression + this->m_expression_len);
275		}
276	5045095x	flag_type flags()const
277		{
278	5045095x	return this->m_flags;
279		}
280	1606782x	size_type size()const
281		{
282	1606782x	return this->m_expression_len;
283		}
284	1977512x	int status()const
285		{
286	1977512x	return this->m_status;
287		}
288	2182611x	size_type mark_count()const
289		{
290	2182611x	return this->m_mark_count - 1;
291		}
292	4272452x	const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
293		{
294	4272452x	return this->m_first_state;
295		}
296	1644974x	unsigned get_restart_type()const
297		{
298	1644974x	return this->m_restart_type;
299		}
300	1631528x	const unsigned char* get_map()const
301		{
302	1631528x	return this->m_startmap;
303		}
304	1727561x	const ::boost::regex_traits_wrapper<traits>& get_traits()const
305		{
306	1727561x	return *(this->m_ptraits);
307		}
308	763270x	bool can_be_null()const
309		{
310	763270x	return this->m_can_be_null;
311		}
312	5728331x	const regex_data<charT, traits>& get_data()const
313		{
314	5728331x	basic_regex_implementation<charT, traits> const* p = this;
315	5728331x	return static_cast<const regex_data<charT, traits>>(p);
316		}
317		};
318
319		} // namespace BOOST_REGEX_DETAIL_NS
320		//
321		// class basic_regex:
322		// represents the compiled
323		// regular expression:
324		//
325		BOOST_REGEX_MODULE_EXPORT
326		#ifdef BOOST_REGEX_NO_FWD
327		template <class charT, class traits = regex_traits<charT> >
328		#else
329		template <class charT, class traits >
330		#endif
331		class basic_regex : public regbase
332		{
333		public:
334		// typedefs:
335		typedef std::size_t traits_size_type;
336		typedef typename traits::string_type traits_string_type;
337		typedef charT char_type;
338		typedef traits traits_type;
339
340		typedef charT value_type;
341		typedef charT& reference;
342		typedef const charT& const_reference;
343		typedef const charT* const_iterator;
344		typedef const_iterator iterator;
345		typedef std::ptrdiff_t difference_type;
346		typedef std::size_t size_type;
347		typedef regex_constants::syntax_option_type flag_type;
348		// locale_type
349		// placeholder for actual locale type used by the
350		// traits class to localise *this.
351		typedef typename traits::locale_type locale_type;
352
353		public:
354	178028x	explicit basic_regex(){}
355	40x	explicit basic_regex(const charT* p, flag_type f = regex_constants::normal)
356	40x	{
357	40x	assign(p, f);
358	40x	}
359		basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
360		{
361		assign(p1, p2, f);
362		}
363		basic_regex(const charT* p, size_type len, flag_type f)
364		{
365		assign(p, len, f);
366		}
367	771144x	basic_regex(const basic_regex& that)
368	771144x	: m_pimpl(that.m_pimpl) {}
369	1068586x	~basic_regex(){}
370	105360x	basic_regex& operator=(const basic_regex& that)
371		{
372	105360x	return assign(that);
373		}
374		basic_regex& operator=(const charT* ptr)
375		{
376		return assign(ptr);
377		}
378
379		//
380		// assign:
381	105360x	basic_regex& assign(const basic_regex& that)
382		{
383	105360x	m_pimpl = that.m_pimpl;
384	105360x	return *this;
385		}
386	45x	basic_regex& assign(const charT* p, flag_type f = regex_constants::normal)
387		{
388	45x	return assign(p, p + traits::length(p), f);
389		}
390		basic_regex& assign(const charT* p, size_type len, flag_type f)
391		{
392		return assign(p, p + len, f);
393		}
394		private:
395		basic_regex& do_assign(const charT* p1,
396		const charT* p2,
397		flag_type f);
398		public:
399	408235x	basic_regex& assign(const charT* p1,
400		const charT* p2,
401		flag_type f = regex_constants::normal)
402		{
403	408235x	return do_assign(p1, p2, f);
404		}
405
406		template <class ST, class SA>
407		unsigned int set_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
408		{
409		return set_expression(p.data(), p.data() + p.size(), f);
410		}
411
412		template <class ST, class SA>
413	36x	explicit basic_regex(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
414	36x	{
415	36x	assign(p, f);
416	36x	}
417
418		template <class InputIterator>
419	119348x	basic_regex(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
420	119348x	{
421		typedef typename traits::string_type seq_type;
422	119348x	seq_type a(arg_first, arg_last);
423	119348x	if(!a.empty())
424	119252x	assign(static_cast<const charT>(&a.begin()), static_cast<const charT>(&a.begin() + a.size()), f);
425		else
426	96x	assign(static_cast<const charT>(0), static_cast<const charT>(0), f);
427	119348x	}
428
429		template <class ST, class SA>
430		basic_regex& operator=(const std::basic_string<charT, ST, SA>& p)
431		{
432		return assign(p.data(), p.data() + p.size(), regex_constants::normal);
433		}
434
435		template <class string_traits, class A>
436	222473x	basic_regex& assign(
437		const std::basic_string<charT, string_traits, A>& s,
438		flag_type f = regex_constants::normal)
439		{
440	222473x	return assign(s.data(), s.data() + s.size(), f);
441		}
442
443		template <class InputIterator>
444	33388x	basic_regex& assign(InputIterator arg_first,
445		InputIterator arg_last,
446		flag_type f = regex_constants::normal)
447		{
448		typedef typename traits::string_type seq_type;
449	33388x	seq_type a(arg_first, arg_last);
450	33388x	if(a.size())
451		{
452	33352x	const charT* p1 = &*a.begin();
453	33352x	const charT* p2 = &*a.begin() + a.size();
454	33352x	return assign(p1, p2, f);
455		}
456	36x	return assign(static_cast<const charT>(0), static_cast<const charT>(0), f);
457	33388x	}
458
459		//
460		// locale:
461		locale_type imbue(locale_type l);
462		locale_type getloc()const
463		{
464		return m_pimpl.get() ? m_pimpl->getloc() : locale_type();
465		}
466		//
467		// getflags:
468		// retained for backwards compatibility only, "flags"
469		// is now the preferred name:
470		flag_type getflags()const
471		{
472		return flags();
473		}
474	5045095x	flag_type flags()const
475		{
476	5045095x	return m_pimpl.get() ? m_pimpl->flags() : 0;
477		}
478		//
479		// str:
480	74654x	std::basic_string<charT> str()const
481		{
482	74654x	return m_pimpl.get() ? m_pimpl->str() : std::basic_string<charT>();
483		}
484		//
485		// begin, end, subexpression:
486	154394x	std::pair<const_iterator, const_iterator> subexpression(std::size_t n)const
487		{
488		#ifdef BOOST_REGEX_STANDALONE
489		if (!m_pimpl.get())
490		throw std::logic_error("Can't access subexpressions in an invalid regex.");
491		#else
492	154394x	if(!m_pimpl.get())
493	✗	boost::throw_exception(std::logic_error("Can't access subexpressions in an invalid regex."));
494		#endif
495	154394x	return m_pimpl->subexpression(n);
496		}
497	242884x	const_iterator begin()const
498		{
499	242884x	return (m_pimpl.get() ? m_pimpl->begin() : 0);
500		}
501	242884x	const_iterator end()const
502		{
503	242884x	return (m_pimpl.get() ? m_pimpl->end() : 0);
504		}
505		//
506		// swap:
507		void swap(basic_regex& that)noexcept
508		{
509		m_pimpl.swap(that.m_pimpl);
510		}
511		//
512		// size:
513	1654664x	size_type size()const
514		{
515	1654664x	return (m_pimpl.get() ? m_pimpl->size() : 0);
516		}
517		//
518		// max_size:
519		size_type max_size()const
520		{
521		return UINT_MAX;
522		}
523		//
524		// empty:
525	1772453x	bool empty()const
526		{
527	1772453x	return (m_pimpl.get() ? 0 != m_pimpl->status() : true);
528		}
529
530	2182611x	size_type mark_count()const
531		{
532	2182611x	return (m_pimpl.get() ? m_pimpl->mark_count() : 0);
533		}
534
535	300823x	int status()const
536		{
537	300823x	return (m_pimpl.get() ? m_pimpl->status() : regex_constants::error_empty);
538		}
539
540		int compare(const basic_regex& that) const
541		{
542		if(m_pimpl.get() == that.m_pimpl.get())
543		return 0;
544		if(!m_pimpl.get())
545		return -1;
546		if(!that.m_pimpl.get())
547		return 1;
548		if(status() != that.status())
549		return status() - that.status();
550		if(flags() != that.flags())
551		return flags() - that.flags();
552
553		const char_type* i = m_pimpl->begin();
554		const char_type* j = that.m_pimpl->begin();
555		while ((i != m_pimpl->end()) && (j != that.m_pimpl->end()))
556		{
557		if (i != j)
558		return i < j ? -1 : 1;
559		++i;
560		++j;
561		}
562		if (i != m_pimpl->end())
563		return *i > static_cast<char_type>(0) ? 1 : -1;
564		if (j != that.m_pimpl->end())
565		return *j > static_cast<char_type>(0) ? -1 : 1;
566		return 0;
567		}
568		bool operator==(const basic_regex& e)const
569		{
570		return compare(e) == 0;
571		}
572		bool operator != (const basic_regex& e)const
573		{
574		return compare(e) != 0;
575		}
576		bool operator<(const basic_regex& e)const
577		{
578		return compare(e) < 0;
579		}
580		bool operator>(const basic_regex& e)const
581		{
582		return compare(e) > 0;
583		}
584		bool operator<=(const basic_regex& e)const
585		{
586		return compare(e) <= 0;
587		}
588		bool operator>=(const basic_regex& e)const
589		{
590		return compare(e) >= 0;
591		}
592
593		//
594		// The following are deprecated as public interfaces
595		// but are available for compatibility with earlier versions.
596		const charT* expression()const
597		{
598		return (m_pimpl.get() && !m_pimpl->status() ? m_pimpl->expression() : 0);
599		}
600	32981x	unsigned int set_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
601		{
602	32981x	assign(p1, p2, f \| regex_constants::no_except);
603	32981x	return status();
604		}
605		unsigned int set_expression(const charT* p, flag_type f = regex_constants::normal)
606		{
607		assign(p, f \| regex_constants::no_except);
608		return status();
609		}
610	32981x	unsigned int error_code()const
611		{
612	32981x	return status();
613		}
614		//
615		// private access methods:
616		//
617	4272452x	const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
618		{
619	4272452x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
620	4272452x	return m_pimpl->get_first_state();
621		}
622	1644974x	unsigned get_restart_type()const
623		{
624	1644974x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
625	1644974x	return m_pimpl->get_restart_type();
626		}
627	1631528x	const unsigned char* get_map()const
628		{
629	1631528x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
630	1631528x	return m_pimpl->get_map();
631		}
632	1727561x	const ::boost::regex_traits_wrapper<traits>& get_traits()const
633		{
634	1727561x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
635	1727561x	return m_pimpl->get_traits();
636		}
637	763270x	bool can_be_null()const
638		{
639	763270x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
640	763270x	return m_pimpl->can_be_null();
641		}
642	5728331x	const BOOST_REGEX_DETAIL_NS::regex_data<charT, traits>& get_data()const
643		{
644	5728331x	BOOST_REGEX_ASSERT(0 != m_pimpl.get());
645	5728331x	return m_pimpl->get_data();
646		}
647	1776594x	std::shared_ptr<BOOST_REGEX_DETAIL_NS::named_subexpressions > get_named_subs()const
648		{
649	1776594x	return m_pimpl;
650		}
651
652		private:
653		std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > m_pimpl;
654		};
655
656		//
657		// out of line members;
658		// these are the only members that mutate the basic_regex object,
659		// and are designed to provide the strong exception guarantee
660		// (in the event of a throw, the state of the object remains unchanged).
661		//
662
663		namespace detail
664		{
665		template <class charT, class F, class Traits>
666	408235x	std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > create_implemenation(const charT* p1, const charT* p2, F f, std::shared_ptr<boost::regex_traits_wrapper<Traits> > ptraits)
667		{
668	408235x	std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > result;
669	408235x	if (!ptraits.get())
670		{
671	297132x	result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>());
672		}
673		else
674		{
675	111103x	result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>(ptraits));
676		}
677	408235x	result->assign(p1, p2, f);
678	392220x	return result;
679	16015x	}
680		#ifdef BOOST_REGEX_AS_MODULE
681		std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<char, basic_regex<char>::traits_type> >
682		create_implemenation(const char* p1, const char* p2, basic_regex<char>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<char>::traits_type> > ptraits);
683		std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<wchar_t, basic_regex<wchar_t>::traits_type> >
684		create_implemenation(const wchar_t* p1, const wchar_t* p2, basic_regex<wchar_t>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<wchar_t>::traits_type> > ptraits);
685		#endif
686		}
687
688		template <class charT, class traits>
689	408235x	basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p1,
690		const charT* p2,
691		flag_type f)
692		{
693	424250x	m_pimpl = detail::create_implemenation(p1, p2, f, m_pimpl.get() ? m_pimpl->m_ptraits : std::shared_ptr<boost::regex_traits_wrapper<traits> >());
694	392220x	return *this;
695		}
696
697		template <class charT, class traits>
698	64x	typename basic_regex<charT, traits>::locale_type basic_regex<charT, traits>::imbue(locale_type l)
699		{
700	64x	std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
701	64x	locale_type result = temp->imbue(l);
702	64x	temp.swap(m_pimpl);
703	96x	return result;
704	64x	}
705
706		//
707		// non-members:
708		//
709		BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
710		void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
711		{
712		e1.swap(e2);
713		}
714
715		BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class traits2>
716		std::basic_ostream<charT, traits>&
717		operator << (std::basic_ostream<charT, traits>& os,
718		const basic_regex<charT, traits2>& e)
719		{
720		return (os << e.str());
721		}
722
723		//
724		// class reg_expression:
725		// this is provided for backwards compatibility only,
726		// it is deprecated, no not use!
727		//
728		#ifdef BOOST_REGEX_NO_FWD
729		template <class charT, class traits = regex_traits<charT> >
730		#else
731		template <class charT, class traits >
732		#endif
733		class reg_expression : public basic_regex<charT, traits>
734		{
735		public:
736		typedef typename basic_regex<charT, traits>::flag_type flag_type;
737		typedef typename basic_regex<charT, traits>::size_type size_type;
738		explicit reg_expression(){}
739		explicit reg_expression(const charT* p, flag_type f = regex_constants::normal)
740		: basic_regex<charT, traits>(p, f){}
741		reg_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)
742		: basic_regex<charT, traits>(p1, p2, f){}
743		reg_expression(const charT* p, size_type len, flag_type f)
744		: basic_regex<charT, traits>(p, len, f){}
745		reg_expression(const reg_expression& that)
746		: basic_regex<charT, traits>(that) {}
747		~reg_expression(){}
748		reg_expression& operator=(const reg_expression& that)
749		{
750		return this->assign(that);
751		}
752
753		template <class ST, class SA>
754		explicit reg_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)
755		: basic_regex<charT, traits>(p, f)
756		{
757		}
758
759		template <class InputIterator>
760		reg_expression(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)
761		: basic_regex<charT, traits>(arg_first, arg_last, f)
762		{
763		}
764
765		template <class ST, class SA>
766		reg_expression& operator=(const std::basic_string<charT, ST, SA>& p)
767		{
768		this->assign(p);
769		return *this;
770		}
771
772		};
773
774		#ifdef BOOST_REGEX_MSVC
775		#pragma warning (pop)
776		#endif
777
778		} // namespace boost
779
780		#endif
781