include/boost/regex/v5/sub_match.hpp

97.6% Lines (162/166) 72.5% List of functions (150/208)

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

sub_match.hpp

f(x) Functions (208)

Function Calls Lines Blocks

Line	Hits	Source Code
1		/*
2		*
3		* Copyright (c) 1998-2002
4		* John Maddock
5		*
6		* Use, modification and distribution are subject to the
7		* Boost Software License, Version 1.0. (See accompanying file
8		* LICENSE_1_0.txt or copy at 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 sub_match.cpp
15		* VERSION see <boost/version.hpp>
16		* DESCRIPTION: Declares template class sub_match.
17		*/
18
19		#ifndef BOOST_REGEX_V5_SUB_MATCH_HPP
20		#define BOOST_REGEX_V5_SUB_MATCH_HPP
21
22		#ifndef BOOST_REGEX_AS_MODULE
23		#include <iterator>
24		#include <utility>
25		#endif
26
27		namespace boost{
28
29		BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
30		struct sub_match : public std::pair<BidiIterator, BidiIterator>
31		{
32		typedef typename std::iterator_traits<BidiIterator>::value_type value_type;
33		typedef typename std::iterator_traits<BidiIterator>::difference_type difference_type;
34		typedef BidiIterator iterator_type;
35		typedef BidiIterator iterator;
36		typedef BidiIterator const_iterator;
37
38		bool matched;
39
40	5968759x	sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
41	2089619x	sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
42		template <class T, class A>
43	9x	operator std::basic_string<value_type, T, A> ()const
44		{
45	23x	return matched ? std::basic_string<value_type, T, A>(this->first, this->second) : std::basic_string<value_type, T, A>();
46		}
47	415981x	difference_type length()const
48		{
49	828002x	difference_type n = matched ? std::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
50	415981x	return n;
51		}
52	2657x	std::basic_string<value_type> str()const
53		{
54	2657x	std::basic_string<value_type> result;
55	2657x	if(matched)
56		{
57	2652x	std::size_t len = std::distance((BidiIterator)this->first, (BidiIterator)this->second);
58	2652x	result.reserve(len);
59	2652x	BidiIterator i = this->first;
60	28556x	while(i != this->second)
61		{
62	25904x	result.append(1, *i);
63	25904x	++i;
64		}
65		}
66	2657x	return result;
67	✗	}
68	216x	int compare(const sub_match& s)const
69		{
70	216x	if(matched != s.matched)
71	✗	return static_cast<int>(matched) - static_cast<int>(s.matched);
72	216x	return str().compare(s.str());
73		}
74		int compare(const std::basic_string<value_type>& s)const
75		{
76		return str().compare(s);
77		}
78		int compare(const value_type* p)const
79		{
80		return str().compare(p);
81		}
82
83	36x	bool operator==(const sub_match& that)const
84	36x	{ return compare(that) == 0; }
85	36x	bool operator !=(const sub_match& that)const
86	36x	{ return compare(that) != 0; }
87	36x	bool operator<(const sub_match& that)const
88	36x	{ return compare(that) < 0; }
89	36x	bool operator>(const sub_match& that)const
90	36x	{ return compare(that) > 0; }
91	36x	bool operator<=(const sub_match& that)const
92	36x	{ return compare(that) <= 0; }
93	36x	bool operator>=(const sub_match& that)const
94	36x	{ return compare(that) >= 0; }
95
96		#ifdef BOOST_REGEX_MATCH_EXTRA
97		typedef std::vector<sub_match<BidiIterator> > capture_sequence_type;
98
99	1880x	const capture_sequence_type& captures()const
100		{
101	1880x	if(!m_captures)
102	51x	m_captures.reset(new capture_sequence_type());
103	1880x	return *m_captures;
104		}
105		//
106		// Private implementation API: DO NOT USE!
107		//
108	2129x	capture_sequence_type& get_captures()const
109		{
110	2129x	if(!m_captures)
111	152x	m_captures.reset(new capture_sequence_type());
112	2129x	return *m_captures;
113		}
114
115		private:
116		mutable std::unique_ptr<capture_sequence_type> m_captures;
117		public:
118
119		#endif
120	29397700x	sub_match(const sub_match& that, bool
121		#ifdef BOOST_REGEX_MATCH_EXTRA
122		deep_copy
123		#endif
124		= true
125		)
126		: std::pair<BidiIterator, BidiIterator>(that),
127	29397700x	matched(that.matched)
128		{
129		#ifdef BOOST_REGEX_MATCH_EXTRA
130	2822x	if(that.m_captures)
131	1876x	if(deep_copy)
132	1876x	m_captures.reset(new capture_sequence_type(*(that.m_captures)));
133		#endif
134	29397700x	}
135	14847818x	sub_match& operator=(const sub_match& that)
136		{
137	14847818x	this->first = that.first;
138	14847818x	this->second = that.second;
139	14847818x	matched = that.matched;
140		#ifdef BOOST_REGEX_MATCH_EXTRA
141	272x	if(that.m_captures)
142	244x	get_captures() = *(that.m_captures);
143		#endif
144	14847818x	return *this;
145		}
146		//
147		// Make this type a range, for both Boost.Range, and C++11:
148		//
149	✗	BidiIterator begin()const { return this->first; }
150	✗	BidiIterator end()const { return this->second; }
151		};
152
153		BOOST_REGEX_MODULE_EXPORT typedef sub_match<const char*> csub_match;
154		BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::string::const_iterator> ssub_match;
155		#ifndef BOOST_NO_WREGEX
156		BOOST_REGEX_MODULE_EXPORT typedef sub_match<const wchar_t*> wcsub_match;
157		BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::wstring::const_iterator> wssub_match;
158		#endif
159
160		// comparison to std::basic_string<> part 1:
161		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
162	36x	inline bool operator == (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
163		const sub_match<RandomAccessIterator>& m)
164	36x	{ return s.compare(m.str()) == 0; }
165		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
166	36x	inline bool operator != (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
167		const sub_match<RandomAccessIterator>& m)
168	36x	{ return s.compare(m.str()) != 0; }
169		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
170	36x	inline bool operator < (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
171		const sub_match<RandomAccessIterator>& m)
172	36x	{ return s.compare(m.str()) < 0; }
173		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
174	36x	inline bool operator <= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
175		const sub_match<RandomAccessIterator>& m)
176	36x	{ return s.compare(m.str()) <= 0; }
177		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
178	36x	inline bool operator >= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
179		const sub_match<RandomAccessIterator>& m)
180	36x	{ return s.compare(m.str()) >= 0; }
181		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
182	36x	inline bool operator > (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
183		const sub_match<RandomAccessIterator>& m)
184	36x	{ return s.compare(m.str()) > 0; }
185		// comparison to std::basic_string<> part 2:
186		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
187	143x	inline bool operator == (const sub_match<RandomAccessIterator>& m,
188		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
189	143x	{ return m.str().compare(s) == 0; }
190		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
191	36x	inline bool operator != (const sub_match<RandomAccessIterator>& m,
192		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
193	36x	{ return m.str().compare(s) != 0; }
194		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
195	36x	inline bool operator < (const sub_match<RandomAccessIterator>& m,
196		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
197	36x	{ return m.str().compare(s) < 0; }
198		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
199	36x	inline bool operator > (const sub_match<RandomAccessIterator>& m,
200		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
201	36x	{ return m.str().compare(s) > 0; }
202		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
203	36x	inline bool operator <= (const sub_match<RandomAccessIterator>& m,
204		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
205	36x	{ return m.str().compare(s) <= 0; }
206		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
207	36x	inline bool operator >= (const sub_match<RandomAccessIterator>& m,
208		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
209	36x	{ return m.str().compare(s) >= 0; }
210		// comparison to const charT* part 1:
211		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
212	210x	inline bool operator == (const sub_match<RandomAccessIterator>& m,
213		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
214	210x	{ return m.str().compare(s) == 0; }
215		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
216	36x	inline bool operator != (const sub_match<RandomAccessIterator>& m,
217		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
218	36x	{ return m.str().compare(s) != 0; }
219		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
220	36x	inline bool operator > (const sub_match<RandomAccessIterator>& m,
221		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
222	36x	{ return m.str().compare(s) > 0; }
223		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
224	36x	inline bool operator < (const sub_match<RandomAccessIterator>& m,
225		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
226	36x	{ return m.str().compare(s) < 0; }
227		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
228	36x	inline bool operator >= (const sub_match<RandomAccessIterator>& m,
229		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
230	36x	{ return m.str().compare(s) >= 0; }
231		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
232	36x	inline bool operator <= (const sub_match<RandomAccessIterator>& m,
233		typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
234	36x	{ return m.str().compare(s) <= 0; }
235		// comparison to const charT* part 2:
236		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
237	36x	inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
238		const sub_match<RandomAccessIterator>& m)
239	36x	{ return m.str().compare(s) == 0; }
240		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
241	36x	inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
242		const sub_match<RandomAccessIterator>& m)
243	36x	{ return m.str().compare(s) != 0; }
244		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
245	36x	inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
246		const sub_match<RandomAccessIterator>& m)
247	36x	{ return m.str().compare(s) > 0; }
248		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
249	36x	inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
250		const sub_match<RandomAccessIterator>& m)
251	36x	{ return m.str().compare(s) < 0; }
252		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
253	36x	inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
254		const sub_match<RandomAccessIterator>& m)
255	36x	{ return m.str().compare(s) >= 0; }
256		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
257	36x	inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
258		const sub_match<RandomAccessIterator>& m)
259	36x	{ return m.str().compare(s) <= 0; }
260
261		// comparison to const charT& part 1:
262		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
263	36x	inline bool operator == (const sub_match<RandomAccessIterator>& m,
264		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
265	36x	{ return m.str().compare(0, m.length(), &s, 1) == 0; }
266		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
267	36x	inline bool operator != (const sub_match<RandomAccessIterator>& m,
268		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
269	36x	{ return m.str().compare(0, m.length(), &s, 1) != 0; }
270		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
271	36x	inline bool operator > (const sub_match<RandomAccessIterator>& m,
272		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
273	36x	{ return m.str().compare(0, m.length(), &s, 1) > 0; }
274		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
275	36x	inline bool operator < (const sub_match<RandomAccessIterator>& m,
276		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
277	36x	{ return m.str().compare(0, m.length(), &s, 1) < 0; }
278		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
279	36x	inline bool operator >= (const sub_match<RandomAccessIterator>& m,
280		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
281	36x	{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
282		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
283	36x	inline bool operator <= (const sub_match<RandomAccessIterator>& m,
284		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
285	36x	{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
286		// comparison to const charT* part 2:
287		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
288	36x	inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
289		const sub_match<RandomAccessIterator>& m)
290	36x	{ return m.str().compare(0, m.length(), &s, 1) == 0; }
291		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
292	36x	inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
293		const sub_match<RandomAccessIterator>& m)
294	36x	{ return m.str().compare(0, m.length(), &s, 1) != 0; }
295		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
296	36x	inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
297		const sub_match<RandomAccessIterator>& m)
298	36x	{ return m.str().compare(0, m.length(), &s, 1) > 0; }
299		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
300	36x	inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
301		const sub_match<RandomAccessIterator>& m)
302	36x	{ return m.str().compare(0, m.length(), &s, 1) < 0; }
303		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
304	36x	inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
305		const sub_match<RandomAccessIterator>& m)
306	36x	{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
307		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
308	36x	inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
309		const sub_match<RandomAccessIterator>& m)
310	36x	{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
311
312		// addition operators:
313		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
314		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
315	24x	operator + (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
316		const sub_match<RandomAccessIterator>& m)
317		{
318	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
319	24x	result.reserve(s.size() + m.length() + 1);
320	46x	return result.append(s).append(m.first, m.second);
321	24x	}
322		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
323		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
324	24x	operator + (const sub_match<RandomAccessIterator>& m,
325		const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
326		{
327	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
328	24x	result.reserve(s.size() + m.length() + 1);
329	46x	return result.append(m.first, m.second).append(s);
330	24x	}
331		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
332		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
333	24x	operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
334		const sub_match<RandomAccessIterator>& m)
335		{
336	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> result;
337	24x	result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
338	46x	return result.append(s).append(m.first, m.second);
339	24x	}
340		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
341		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
342	24x	operator + (const sub_match<RandomAccessIterator>& m,
343		typename std::iterator_traits<RandomAccessIterator>::value_type const * s)
344		{
345	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> result;
346	24x	result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
347	46x	return result.append(m.first, m.second).append(s);
348	24x	}
349		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
350		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
351	24x	operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
352		const sub_match<RandomAccessIterator>& m)
353		{
354	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> result;
355	24x	result.reserve(m.length() + 2);
356	46x	return result.append(1, s).append(m.first, m.second);
357	24x	}
358		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
359		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
360	24x	operator + (const sub_match<RandomAccessIterator>& m,
361		typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
362		{
363	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> result;
364	24x	result.reserve(m.length() + 2);
365	46x	return result.append(m.first, m.second).append(1, s);
366	24x	}
367		BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
368		inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
369	24x	operator + (const sub_match<RandomAccessIterator>& m1,
370		const sub_match<RandomAccessIterator>& m2)
371		{
372	24x	std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> result;
373	24x	result.reserve(m1.length() + m2.length() + 1);
374	46x	return result.append(m1.first, m1.second).append(m2.first, m2.second);
375	24x	}
376		BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class RandomAccessIterator>
377		std::basic_ostream<charT, traits>&
378	421x	operator << (std::basic_ostream<charT, traits>& os,
379		const sub_match<RandomAccessIterator>& s)
380		{
381	421x	return (os << s.str());
382		}
383
384		} // namespace boost
385
386		#endif
387
388