ministring.cpp@ 96563

Last change on this file since 96563 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 34.2 KB

Line
1	/* $Id: ministring.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT - Mini C++ string class.
4	*
5	* This is a base for both Utf8Str and other places where IPRT may want to use
6	* a lean C++ string class.
7	*/
8
9	/*
10	* Copyright (C) 2007-2022 Oracle and/or its affiliates.
11	*
12	* This file is part of VirtualBox base platform packages, as
13	* available from https://www.virtualbox.org.
14	*
15	* This program is free software; you can redistribute it and/or
16	* modify it under the terms of the GNU General Public License
17	* as published by the Free Software Foundation, in version 3 of the
18	* License.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, see <https://www.gnu.org/licenses>.
27	*
28	* The contents of this file may alternatively be used under the terms
29	* of the Common Development and Distribution License Version 1.0
30	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
31	* in the VirtualBox distribution, in which case the provisions of the
32	* CDDL are applicable instead of those of the GPL.
33	*
34	* You may elect to license modified versions of this file under the
35	* terms and conditions of either the GPL or the CDDL or both.
36	*
37	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
38	*/
39
40
41	/*********************************************************************************************************************************
42	* Header Files *
43	*********************************************************************************************************************************/
44	#include <iprt/cpp/ministring.h>
45	#include "internal/iprt.h"
46
47	#include <iprt/ctype.h>
48	#include <iprt/uni.h>
49	#include <iprt/err.h>
50
51
52
53	/*********************************************************************************************************************************
54	* Global Variables *
55	*********************************************************************************************************************************/
56	const size_t RTCString::npos = ~(size_t)0;
57
58
59	/*********************************************************************************************************************************
60	* Defined Constants And Macros *
61	*********************************************************************************************************************************/
62	/** Allocation block alignment used when appending bytes to a string. */
63	#define IPRT_MINISTRING_APPEND_ALIGNMENT 64
64
65
66	RTCString &RTCString::assign(const RTCString &a_rSrc)
67	{
68	Assert(&a_rSrc != this);
69	size_t const cchSrc = a_rSrc.length();
70	if (cchSrc > 0)
71	{
72	reserve(cchSrc + 1);
73	memcpy(m_psz, a_rSrc.c_str(), cchSrc);
74	m_psz[cchSrc] = '\0';
75	m_cch = cchSrc;
76	return *this;
77	}
78	setNull();
79	return *this;
80
81	}
82
83	int RTCString::assignNoThrow(const RTCString &a_rSrc) RT_NOEXCEPT
84	{
85	AssertReturn(&a_rSrc != this, VINF_SUCCESS);
86	size_t const cchSrc = a_rSrc.length();
87	if (cchSrc > 0)
88	{
89	int rc = reserveNoThrow(cchSrc + 1);
90	if (RT_SUCCESS(rc))
91	{
92	memcpy(m_psz, a_rSrc.c_str(), cchSrc);
93	m_psz[cchSrc] = '\0';
94	m_cch = cchSrc;
95	return VINF_SUCCESS;
96	}
97	return rc;
98	}
99	setNull();
100	return VINF_SUCCESS;
101
102	}
103
104	RTCString &RTCString::assign(const char *a_pszSrc)
105	{
106	if (a_pszSrc)
107	{
108	size_t cchSrc = strlen(a_pszSrc);
109	if (cchSrc)
110	{
111	Assert((uintptr_t)&a_pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
112
113	reserve(cchSrc + 1);
114	memcpy(m_psz, a_pszSrc, cchSrc);
115	m_psz[cchSrc] = '\0';
116	m_cch = cchSrc;
117	return *this;
118	}
119	}
120	setNull();
121	return *this;
122	}
123
124	int RTCString::assignNoThrow(const char *a_pszSrc) RT_NOEXCEPT
125	{
126	if (a_pszSrc)
127	{
128	size_t cchSrc = strlen(a_pszSrc);
129	if (cchSrc)
130	{
131	Assert((uintptr_t)&a_pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
132
133	int rc = reserveNoThrow(cchSrc + 1);
134	if (RT_SUCCESS(rc))
135	{
136	memcpy(m_psz, a_pszSrc, cchSrc);
137	m_psz[cchSrc] = '\0';
138	m_cch = cchSrc;
139	return VINF_SUCCESS;
140	}
141	return rc;
142	}
143	}
144	setNull();
145	return VINF_SUCCESS;
146	}
147
148	RTCString &RTCString::assign(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /= npos/)
149	{
150	AssertReturn(&a_rSrc != this, *this);
151	if (a_offSrc < a_rSrc.length())
152	{
153	size_t cchMax = a_rSrc.length() - a_offSrc;
154	if (a_cchSrc > cchMax)
155	a_cchSrc = cchMax;
156	reserve(a_cchSrc + 1);
157	memcpy(m_psz, a_rSrc.c_str() + a_offSrc, a_cchSrc);
158	m_psz[a_cchSrc] = '\0';
159	m_cch = a_cchSrc;
160	}
161	else
162	setNull();
163	return *this;
164	}
165
166	int RTCString::assignNoThrow(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /= npos/) RT_NOEXCEPT
167	{
168	AssertReturn(&a_rSrc != this, VINF_SUCCESS);
169	if (a_offSrc < a_rSrc.length())
170	{
171	size_t cchMax = a_rSrc.length() - a_offSrc;
172	if (a_cchSrc > cchMax)
173	a_cchSrc = cchMax;
174	int rc = reserveNoThrow(a_cchSrc + 1);
175	if (RT_SUCCESS(rc))
176	{
177	memcpy(m_psz, a_rSrc.c_str() + a_offSrc, a_cchSrc);
178	m_psz[a_cchSrc] = '\0';
179	m_cch = a_cchSrc;
180	return VINF_SUCCESS;
181	}
182	return rc;
183	}
184	setNull();
185	return VINF_SUCCESS;
186	}
187
188	RTCString &RTCString::assign(const char *a_pszSrc, size_t a_cchSrc)
189	{
190	if (a_cchSrc)
191	{
192	a_cchSrc = RTStrNLen(a_pszSrc, a_cchSrc);
193	if (a_cchSrc)
194	{
195	Assert((uintptr_t)&a_pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
196
197	reserve(a_cchSrc + 1);
198	memcpy(m_psz, a_pszSrc, a_cchSrc);
199	m_psz[a_cchSrc] = '\0';
200	m_cch = a_cchSrc;
201	return *this;
202	}
203	}
204	setNull();
205	return *this;
206	}
207
208	int RTCString::assignNoThrow(const char *a_pszSrc, size_t a_cchSrc) RT_NOEXCEPT
209	{
210	if (a_cchSrc)
211	{
212	a_cchSrc = RTStrNLen(a_pszSrc, a_cchSrc);
213	if (a_cchSrc)
214	{
215	Assert((uintptr_t)&a_pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
216
217	int rc = reserveNoThrow(a_cchSrc + 1);
218	if (RT_SUCCESS(rc))
219	{
220	memcpy(m_psz, a_pszSrc, a_cchSrc);
221	m_psz[a_cchSrc] = '\0';
222	m_cch = a_cchSrc;
223	return VINF_SUCCESS;
224	}
225	return rc;
226	}
227	}
228	setNull();
229	return VINF_SUCCESS;
230	}
231
232	RTCString &RTCString::assign(size_t a_cTimes, char a_ch)
233	{
234	reserve(a_cTimes + 1);
235	memset(m_psz, a_ch, a_cTimes);
236	m_psz[a_cTimes] = '\0';
237	m_cch = a_cTimes;
238	return *this;
239	}
240
241
242	int RTCString::assignNoThrow(size_t a_cTimes, char a_ch) RT_NOEXCEPT
243	{
244	int rc = reserveNoThrow(a_cTimes + 1);
245	if (RT_SUCCESS(rc))
246	{
247	memset(m_psz, a_ch, a_cTimes);
248	m_psz[a_cTimes] = '\0';
249	m_cch = a_cTimes;
250	return VINF_SUCCESS;
251	}
252	return rc;
253	}
254
255
256	RTCString &RTCString::printf(const char *pszFormat, ...)
257	{
258	va_list va;
259	va_start(va, pszFormat);
260	printfV(pszFormat, va);
261	va_end(va);
262	return *this;
263	}
264
265	int RTCString::printfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
266	{
267	va_list va;
268	va_start(va, pszFormat);
269	int rc = printfVNoThrow(pszFormat, va);
270	va_end(va);
271	return rc;
272	}
273
274	/**
275	* Callback used with RTStrFormatV by RTCString::printfV.
276	*
277	* @returns The number of bytes added (not used).
278	*
279	* @param pvArg The string object.
280	* @param pachChars The characters to append.
281	* @param cbChars The number of characters. 0 on the final callback.
282	*/
283	/static/ DECLCALLBACK(size_t)
284	RTCString::printfOutputCallback(void pvArg, const char pachChars, size_t cbChars)
285	{
286	RTCString pThis = (RTCString )pvArg;
287	if (cbChars)
288	{
289	size_t const cchBoth = pThis->m_cch + cbChars;
290	if (cchBoth >= pThis->m_cbAllocated)
291	{
292	/* Double the buffer size, if it's less that _4M. Align sizes like
293	for append. */
294	size_t cbAlloc = RT_ALIGN_Z(pThis->m_cbAllocated, IPRT_MINISTRING_APPEND_ALIGNMENT);
295	cbAlloc += RT_MIN(cbAlloc, _4M);
296	if (cbAlloc <= cchBoth)
297	cbAlloc = RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT);
298	pThis->reserve(cbAlloc);
299	#ifndef RT_EXCEPTIONS_ENABLED
300	AssertReleaseReturn(pThis->capacity() > cchBoth, 0);
301	#endif
302	}
303
304	memcpy(&pThis->m_psz[pThis->m_cch], pachChars, cbChars);
305	pThis->m_cch = cchBoth;
306	pThis->m_psz[cchBoth] = '\0';
307	}
308	return cbChars;
309	}
310
311	RTCString &RTCString::printfV(const char *pszFormat, va_list va)
312	{
313	cleanup();
314	RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va);
315	return *this;
316	}
317
318	RTCString &RTCString::appendPrintfV(const char *pszFormat, va_list va)
319	{
320	RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va);
321	return *this;
322	}
323
324	struct RTCSTRINGOTHROW
325	{
326	RTCString *pThis;
327	int rc;
328	};
329
330	/**
331	* Callback used with RTStrFormatV by RTCString::printfVNoThrow.
332	*
333	* @returns The number of bytes added (not used).
334	*
335	* @param pvArg Pointer to a RTCSTRINGOTHROW structure.
336	* @param pachChars The characters to append.
337	* @param cbChars The number of characters. 0 on the final callback.
338	*/
339	/static/ DECLCALLBACK(size_t)
340	RTCString::printfOutputCallbackNoThrow(void pvArg, const char pachChars, size_t cbChars) RT_NOEXCEPT
341	{
342	RTCString pThis = ((RTCSTRINGOTHROW )pvArg)->pThis;
343	if (cbChars)
344	{
345	size_t const cchBoth = pThis->m_cch + cbChars;
346	if (cchBoth >= pThis->m_cbAllocated)
347	{
348	/* Double the buffer size, if it's less that _4M. Align sizes like
349	for append. */
350	size_t cbAlloc = RT_ALIGN_Z(pThis->m_cbAllocated, IPRT_MINISTRING_APPEND_ALIGNMENT);
351	cbAlloc += RT_MIN(cbAlloc, _4M);
352	if (cbAlloc <= cchBoth)
353	cbAlloc = RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT);
354	int rc = pThis->reserveNoThrow(cbAlloc);
355	if (RT_SUCCESS(rc))
356	{ /* likely */ }
357	else
358	{
359	((RTCSTRINGOTHROW *)pvArg)->rc = rc;
360	return cbChars;
361	}
362	}
363
364	memcpy(&pThis->m_psz[pThis->m_cch], pachChars, cbChars);
365	pThis->m_cch = cchBoth;
366	pThis->m_psz[cchBoth] = '\0';
367	}
368	return cbChars;
369	}
370
371	int RTCString::printfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
372	{
373	cleanup();
374	RTCSTRINGOTHROW Args = { this, VINF_SUCCESS };
375	RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
376	return Args.rc;
377	}
378
379	int RTCString::appendPrintfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
380	{
381	RTCSTRINGOTHROW Args = { this, VINF_SUCCESS };
382	RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
383	return Args.rc;
384	}
385
386	RTCString &RTCString::appendPrintf(const char *pszFormat, ...)
387	{
388	va_list va;
389	va_start(va, pszFormat);
390	appendPrintfV(pszFormat, va);
391	va_end(va);
392	return *this;
393	}
394
395	int RTCString::appendPrintfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
396	{
397	va_list va;
398	va_start(va, pszFormat);
399	int rc = appendPrintfVNoThrow(pszFormat, va);
400	va_end(va);
401	return rc;
402	}
403
404	RTCString &RTCString::append(const RTCString &that)
405	{
406	Assert(&that != this);
407	return appendWorker(that.c_str(), that.length());
408	}
409
410	int RTCString::appendNoThrow(const RTCString &that) RT_NOEXCEPT
411	{
412	Assert(&that != this);
413	return appendWorkerNoThrow(that.c_str(), that.length());
414	}
415
416	RTCString &RTCString::append(const char *pszThat)
417	{
418	return appendWorker(pszThat, strlen(pszThat));
419	}
420
421	int RTCString::appendNoThrow(const char *pszThat) RT_NOEXCEPT
422	{
423	return appendWorkerNoThrow(pszThat, strlen(pszThat));
424	}
425
426	RTCString &RTCString::append(const RTCString &rThat, size_t offStart, size_t cchMax /= RTSTR_MAX/)
427	{
428	if (offStart < rThat.length())
429	{
430	size_t cchLeft = rThat.length() - offStart;
431	return appendWorker(rThat.c_str() + offStart, RT_MIN(cchLeft, cchMax));
432	}
433	return *this;
434	}
435
436	int RTCString::appendNoThrow(const RTCString &rThat, size_t offStart, size_t cchMax /= RTSTR_MAX/) RT_NOEXCEPT
437	{
438	if (offStart < rThat.length())
439	{
440	size_t cchLeft = rThat.length() - offStart;
441	return appendWorkerNoThrow(rThat.c_str() + offStart, RT_MIN(cchLeft, cchMax));
442	}
443	return VINF_SUCCESS;
444	}
445
446	RTCString &RTCString::append(const char *pszThat, size_t cchMax)
447	{
448	return appendWorker(pszThat, RTStrNLen(pszThat, cchMax));
449	}
450
451	int RTCString::appendNoThrow(const char *pszThat, size_t cchMax) RT_NOEXCEPT
452	{
453	return appendWorkerNoThrow(pszThat, RTStrNLen(pszThat, cchMax));
454	}
455
456	RTCString &RTCString::appendWorker(const char *pszSrc, size_t cchSrc)
457	{
458	if (cchSrc)
459	{
460	Assert((uintptr_t)&pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
461
462	size_t cchThis = length();
463	size_t cchBoth = cchThis + cchSrc;
464
465	if (cchBoth >= m_cbAllocated)
466	{
467	reserve(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
468	// calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
469	#ifndef RT_EXCEPTIONS_ENABLED
470	AssertRelease(capacity() > cchBoth);
471	#endif
472	}
473
474	memcpy(&m_psz[cchThis], pszSrc, cchSrc);
475	m_psz[cchBoth] = '\0';
476	m_cch = cchBoth;
477	}
478	return *this;
479	}
480
481	int RTCString::appendWorkerNoThrow(const char *pszSrc, size_t cchSrc) RT_NOEXCEPT
482	{
483	if (cchSrc)
484	{
485	Assert((uintptr_t)&pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
486
487	size_t cchThis = length();
488	size_t cchBoth = cchThis + cchSrc;
489
490	if (cchBoth >= m_cbAllocated)
491	{
492	int rc = reserveNoThrow(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
493	if (RT_SUCCESS(rc))
494	{ /* likely */ }
495	else
496	return rc;
497	}
498
499	memcpy(&m_psz[cchThis], pszSrc, cchSrc);
500	m_psz[cchBoth] = '\0';
501	m_cch = cchBoth;
502	}
503	return VINF_SUCCESS;
504	}
505
506	RTCString &RTCString::append(char ch)
507	{
508	Assert((unsigned char)ch < 0x80); /* Don't create invalid UTF-8. */
509	if (ch)
510	{
511	// allocate in chunks of 20 in case this gets called several times
512	if (m_cch + 1 >= m_cbAllocated)
513	{
514	reserve(RT_ALIGN_Z(m_cch + 2, IPRT_MINISTRING_APPEND_ALIGNMENT));
515	// calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
516	#ifndef RT_EXCEPTIONS_ENABLED
517	AssertRelease(capacity() > m_cch + 1);
518	#endif
519	}
520
521	m_psz[m_cch] = ch;
522	m_psz[++m_cch] = '\0';
523	}
524	return *this;
525	}
526
527	int RTCString::appendNoThrow(char ch) RT_NOEXCEPT
528	{
529	Assert((unsigned char)ch < 0x80); /* Don't create invalid UTF-8. */
530	if (ch)
531	{
532	// allocate in chunks of 20 in case this gets called several times
533	if (m_cch + 1 >= m_cbAllocated)
534	{
535	int rc = reserveNoThrow(RT_ALIGN_Z(m_cch + 2, IPRT_MINISTRING_APPEND_ALIGNMENT));
536	if (RT_SUCCESS(rc))
537	{ /* likely */ }
538	else
539	return rc;
540	}
541
542	m_psz[m_cch] = ch;
543	m_psz[++m_cch] = '\0';
544	}
545	return VINF_SUCCESS;
546	}
547
548	RTCString &RTCString::appendCodePoint(RTUNICP uc)
549	{
550	/*
551	* Single byte encoding.
552	*/
553	if (uc < 0x80)
554	return RTCString::append((char)uc);
555
556	/*
557	* Multibyte encoding.
558	* Assume max encoding length when resizing the string, that's simpler.
559	*/
560	AssertReturn(uc <= UINT32_C(0x7fffffff), *this);
561
562	if (m_cch + 6 >= m_cbAllocated)
563	{
564	reserve(RT_ALIGN_Z(m_cch + 6 + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
565	// calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
566	#ifndef RT_EXCEPTIONS_ENABLED
567	AssertRelease(capacity() > m_cch + 6);
568	#endif
569	}
570
571	char *pszNext = RTStrPutCp(&m_psz[m_cch], uc);
572	m_cch = pszNext - m_psz;
573	*pszNext = '\0';
574
575	return *this;
576	}
577
578	int RTCString::appendCodePointNoThrow(RTUNICP uc) RT_NOEXCEPT
579	{
580	/*
581	* Single byte encoding.
582	*/
583	if (uc < 0x80)
584	return RTCString::appendNoThrow((char)uc);
585
586	/*
587	* Multibyte encoding.
588	* Assume max encoding length when resizing the string, that's simpler.
589	*/
590	AssertReturn(uc <= UINT32_C(0x7fffffff), VERR_INVALID_UTF8_ENCODING);
591
592	if (m_cch + 6 >= m_cbAllocated)
593	{
594	int rc = reserveNoThrow(RT_ALIGN_Z(m_cch + 6 + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
595	if (RT_SUCCESS(rc))
596	{ /* likely */ }
597	else
598	return rc;
599	}
600
601	char *pszNext = RTStrPutCp(&m_psz[m_cch], uc);
602	m_cch = pszNext - m_psz;
603	*pszNext = '\0';
604
605	return VINF_SUCCESS;
606	}
607
608	RTCString &RTCString::erase(size_t offStart /= 0/, size_t cchLength /= npos/) RT_NOEXCEPT
609	{
610	size_t cch = length();
611	if (offStart < cch)
612	{
613	if (cchLength >= cch - offStart)
614	{
615	/* Trail removal, nothing to move. */
616	m_cch = offStart;
617	m_psz[offStart] = '\0';
618	}
619	else if (cchLength > 0)
620	{
621	/* Pull up the tail to offStart. */
622	size_t cchAfter = cch - offStart - cchLength;
623	memmove(&m_psz[offStart], &m_psz[offStart + cchLength], cchAfter);
624	m_cch = cch -= cchLength;
625	m_psz[cch] = '\0';
626	}
627	}
628	return *this;
629	}
630
631	RTCString &RTCString::replace(size_t offStart, size_t cchLength, const RTCString &rStrReplacement)
632	{
633	return replaceWorker(offStart, cchLength, rStrReplacement.c_str(), rStrReplacement.length());
634	}
635
636	int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const RTCString &rStrReplacement) RT_NOEXCEPT
637	{
638	return replaceWorkerNoThrow(offStart, cchLength, rStrReplacement.c_str(), rStrReplacement.length());
639	}
640
641	RTCString &RTCString::replace(size_t offStart, size_t cchLength, const RTCString &rStrReplacement,
642	size_t offReplacement, size_t cchReplacement)
643	{
644	Assert(this != &rStrReplacement);
645	if (cchReplacement > 0)
646	{
647	if (offReplacement < rStrReplacement.length())
648	{
649	size_t cchMaxReplacement = rStrReplacement.length() - offReplacement;
650	return replaceWorker(offStart, cchLength, rStrReplacement.c_str() + offReplacement,
651	RT_MIN(cchReplacement, cchMaxReplacement));
652	}
653	/* Our non-standard handling of out_of_range situations. */
654	AssertMsgFailed(("offReplacement=%zu (cchReplacement=%zu) rStrReplacement.length()=%zu\n",
655	offReplacement, cchReplacement, rStrReplacement.length()));
656	}
657	return replaceWorker(offStart, cchLength, "", 0);
658	}
659
660	int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const RTCString &rStrReplacement,
661	size_t offReplacement, size_t cchReplacement) RT_NOEXCEPT
662	{
663	Assert(this != &rStrReplacement);
664	if (cchReplacement > 0)
665	{
666	if (offReplacement < rStrReplacement.length())
667	{
668	size_t cchMaxReplacement = rStrReplacement.length() - offReplacement;
669	return replaceWorkerNoThrow(offStart, cchLength, rStrReplacement.c_str() + offReplacement,
670	RT_MIN(cchReplacement, cchMaxReplacement));
671	}
672	return VERR_OUT_OF_RANGE;
673	}
674	return replaceWorkerNoThrow(offStart, cchLength, "", 0);
675	}
676
677	RTCString &RTCString::replace(size_t offStart, size_t cchLength, const char *pszReplacement)
678	{
679	return replaceWorker(offStart, cchLength, pszReplacement, strlen(pszReplacement));
680	}
681
682	int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const char *pszReplacement) RT_NOEXCEPT
683	{
684	return replaceWorkerNoThrow(offStart, cchLength, pszReplacement, strlen(pszReplacement));
685	}
686
687	RTCString &RTCString::replace(size_t offStart, size_t cchLength, const char *pszReplacement, size_t cchReplacement)
688	{
689	return replaceWorker(offStart, cchLength, pszReplacement, RTStrNLen(pszReplacement, cchReplacement));
690	}
691
692	int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const char *pszReplacement, size_t cchReplacement) RT_NOEXCEPT
693	{
694	return replaceWorkerNoThrow(offStart, cchLength, pszReplacement, RTStrNLen(pszReplacement, cchReplacement));
695	}
696
697	RTCString &RTCString::replaceWorker(size_t offStart, size_t cchLength, const char *pszSrc, size_t cchSrc)
698	{
699	Assert((uintptr_t)&pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated \|\| !cchSrc);
700
701	/*
702	* Our non-standard handling of out_of_range situations.
703	*/
704	size_t const cchOldLength = length();
705	AssertMsgReturn(offStart < cchOldLength, ("offStart=%zu (cchLength=%zu); length()=%zu\n", offStart, cchLength, cchOldLength),
706	*this);
707
708	/*
709	* Correct the length parameter.
710	*/
711	size_t cchMaxLength = cchOldLength - offStart;
712	if (cchMaxLength < cchLength)
713	cchLength = cchMaxLength;
714
715	/*
716	* Adjust string allocation if necessary.
717	*/
718	size_t cchNew = cchOldLength - cchLength + cchSrc;
719	if (cchNew >= m_cbAllocated)
720	{
721	reserve(RT_ALIGN_Z(cchNew + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
722	// calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
723	#ifndef RT_EXCEPTIONS_ENABLED
724	AssertRelease(capacity() > cchNew);
725	#endif
726	}
727
728	/*
729	* Make the change.
730	*/
731	size_t cchAfter = cchOldLength - offStart - cchLength;
732	if (cchAfter > 0)
733	memmove(&m_psz[offStart + cchSrc], &m_psz[offStart + cchLength], cchAfter);
734	memcpy(&m_psz[offStart], pszSrc, cchSrc);
735	m_psz[cchNew] = '\0';
736	m_cch = cchNew;
737
738	return *this;
739	}
740
741	int RTCString::replaceWorkerNoThrow(size_t offStart, size_t cchLength, const char *pszSrc, size_t cchSrc) RT_NOEXCEPT
742	{
743	Assert((uintptr_t)&pszSrc - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated \|\| !cchSrc);
744
745	/*
746	* Our non-standard handling of out_of_range situations.
747	*/
748	size_t const cchOldLength = length();
749	AssertMsgReturn(offStart < cchOldLength, ("offStart=%zu (cchLength=%zu); length()=%zu\n", offStart, cchLength, cchOldLength),
750	VERR_OUT_OF_RANGE);
751
752	/*
753	* Correct the length parameter.
754	*/
755	size_t cchMaxLength = cchOldLength - offStart;
756	if (cchMaxLength < cchLength)
757	cchLength = cchMaxLength;
758
759	/*
760	* Adjust string allocation if necessary.
761	*/
762	size_t cchNew = cchOldLength - cchLength + cchSrc;
763	if (cchNew >= m_cbAllocated)
764	{
765	int rc = reserveNoThrow(RT_ALIGN_Z(cchNew + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
766	if (RT_SUCCESS(rc))
767	{ /* likely */ }
768	else
769	return rc;
770	}
771
772	/*
773	* Make the change.
774	*/
775	size_t cchAfter = cchOldLength - offStart - cchLength;
776	if (cchAfter > 0)
777	memmove(&m_psz[offStart + cchSrc], &m_psz[offStart + cchLength], cchAfter);
778	memcpy(&m_psz[offStart], pszSrc, cchSrc);
779	m_psz[cchNew] = '\0';
780	m_cch = cchNew;
781
782	return VINF_SUCCESS;
783	}
784
785
786	RTCString &RTCString::truncate(size_t cchMax) RT_NOEXCEPT
787	{
788	if (cchMax < m_cch)
789	{
790	/*
791	* Make sure the truncated string ends with a correctly encoded
792	* codepoint and is not missing a few bytes.
793	*/
794	if (cchMax > 0)
795	{
796	char chTail = m_psz[cchMax];
797	if ( (chTail & 0x80) == 0 /* single byte codepoint */
798	\|\| (chTail & 0xc0) == 0xc0) /* first byte of codepoint sequence. */
799	{ /* likely */ }
800	else
801	{
802	/* We need to find the start of the codepoint sequence: */
803	do
804	cchMax -= 1;
805	while ( cchMax > 0
806	&& (m_psz[cchMax] & 0xc0) != 0xc0);
807	}
808	}
809
810	/*
811	* Do the truncating.
812	*/
813	m_psz[cchMax] = '\0';
814	m_cch = cchMax;
815	}
816	return *this;
817	}
818
819
820	size_t RTCString::find(const char pszNeedle, size_t offStart /= 0*/) const RT_NOEXCEPT
821	{
822	if (offStart < length())
823	{
824	const char *pszThis = c_str();
825	if (pszThis)
826	{
827	if (pszNeedle && *pszNeedle != '\0')
828	{
829	const char *pszHit = strstr(pszThis + offStart, pszNeedle);
830	if (pszHit)
831	return pszHit - pszThis;
832	}
833	}
834	}
835
836	return npos;
837	}
838
839	size_t RTCString::find(const RTCString pStrNeedle, size_t offStart /= 0*/) const RT_NOEXCEPT
840	{
841	if (offStart < length())
842	{
843	const char *pszThis = c_str();
844	if (pszThis)
845	{
846	if (pStrNeedle)
847	{
848	const char *pszNeedle = pStrNeedle->c_str();
849	if (pszNeedle && *pszNeedle != '\0')
850	{
851	const char *pszHit = strstr(pszThis + offStart, pszNeedle);
852	if (pszHit)
853	return pszHit - pszThis;
854	}
855	}
856	}
857	}
858
859	return npos;
860	}
861
862
863	size_t RTCString::find(const RTCString &rStrNeedle, size_t offStart /= 0/) const RT_NOEXCEPT
864	{
865	return find(&rStrNeedle, offStart);
866	}
867
868
869	size_t RTCString::find(const char chNeedle, size_t offStart /= 0/) const RT_NOEXCEPT
870	{
871	Assert((unsigned int)chNeedle < 128U);
872	if (offStart < length())
873	{
874	const char *pszThis = c_str();
875	if (pszThis)
876	{
877	const char pszHit = (const char )memchr(&pszThis[offStart], chNeedle, length() - offStart);
878	if (pszHit)
879	return pszHit - pszThis;
880	}
881	}
882	return npos;
883	}
884
885
886	void RTCString::findReplace(char chFind, char chReplace) RT_NOEXCEPT
887	{
888	Assert((unsigned int)chFind < 128U);
889	Assert((unsigned int)chReplace < 128U);
890
891	for (size_t i = 0; i < length(); ++i)
892	{
893	char *p = &m_psz[i];
894	if (*p == chFind)
895	*p = chReplace;
896	}
897	}
898
899	size_t RTCString::count(char ch) const RT_NOEXCEPT
900	{
901	Assert((unsigned int)ch < 128U);
902
903	size_t c = 0;
904	const char *psz = m_psz;
905	if (psz)
906	{
907	char chCur;
908	while ((chCur = *psz++) != '\0')
909	if (chCur == ch)
910	c++;
911	}
912	return c;
913	}
914
915	#if 0 /** @todo implement these when needed. */
916	size_t RTCString::count(const char *psz, CaseSensitivity cs = CaseSensitive) const RT_NOEXCEPT
917	{
918	}
919
920	size_t RTCString::count(const RTCString *pStr, CaseSensitivity cs = CaseSensitive) const RT_NOEXCEPT
921	{
922
923	}
924	#endif
925
926
927	RTCString &RTCString::strip() RT_NOEXCEPT
928	{
929	stripRight();
930	return stripLeft();
931	}
932
933
934	RTCString &RTCString::stripLeft() RT_NOEXCEPT
935	{
936	char *psz = m_psz;
937	size_t const cch = m_cch;
938	size_t off = 0;
939	while (off < cch && RT_C_IS_SPACE(psz[off]))
940	off++;
941	if (off > 0)
942	{
943	if (off != cch)
944	{
945	memmove(psz, &psz[off], cch - off + 1);
946	m_cch = cch - off;
947	}
948	else
949	setNull();
950	}
951	return *this;
952	}
953
954
955	RTCString &RTCString::stripRight() RT_NOEXCEPT
956	{
957	char *psz = m_psz;
958	size_t cch = m_cch;
959	while (cch > 0 && RT_C_IS_SPACE(psz[cch - 1]))
960	cch--;
961	if (m_cch != cch)
962	{
963	m_cch = cch;
964	psz[cch] = '\0';
965	}
966	return *this;
967	}
968
969
970
971	RTCString RTCString::substrCP(size_t pos /= 0/, size_t n /= npos/) const
972	{
973	RTCString ret;
974
975	if (n)
976	{
977	const char *psz;
978
979	if ((psz = c_str()))
980	{
981	RTUNICP cp;
982
983	// walk the UTF-8 characters until where the caller wants to start
984	size_t i = pos;
985	while (*psz && i--)
986	if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
987	return ret; // return empty string on bad encoding
988
989	const char *pFirst = psz;
990
991	if (n == npos)
992	// all the rest:
993	ret = pFirst;
994	else
995	{
996	i = n;
997	while (*psz && i--)
998	if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
999	return ret; // return empty string on bad encoding
1000
1001	size_t cbCopy = psz - pFirst;
1002	if (cbCopy)
1003	{
1004	ret.reserve(cbCopy + 1); // may throw bad_alloc
1005	#ifndef RT_EXCEPTIONS_ENABLED
1006	AssertRelease(capacity() >= cbCopy + 1);
1007	#endif
1008	memcpy(ret.m_psz, pFirst, cbCopy);
1009	ret.m_cch = cbCopy;
1010	ret.m_psz[cbCopy] = '\0';
1011	}
1012	}
1013	}
1014	}
1015
1016	return ret;
1017	}
1018
1019	bool RTCString::endsWith(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const RT_NOEXCEPT
1020	{
1021	size_t l1 = length();
1022	if (l1 == 0)
1023	return false;
1024
1025	size_t l2 = that.length();
1026	if (l1 < l2)
1027	return false;
1028
1029	if (!m_psz) /* Don't crash when running against an empty string. */
1030	return false;
1031
1032	/** @todo r=bird: See handling of l2 == in startsWith; inconsistent output (if l2 == 0, it matches anything). */
1033
1034	size_t l = l1 - l2;
1035	if (cs == CaseSensitive)
1036	return ::RTStrCmp(&m_psz[l], that.m_psz) == 0;
1037	return ::RTStrICmp(&m_psz[l], that.m_psz) == 0;
1038	}
1039
1040	bool RTCString::startsWith(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const RT_NOEXCEPT
1041	{
1042	size_t l1 = length();
1043	size_t l2 = that.length();
1044	if (l1 == 0 \|\| l2 == 0) /** @todo r=bird: this differs from endsWith, and I think other IPRT code. If l2 == 0, it matches anything. */
1045	return false;
1046
1047	if (l1 < l2)
1048	return false;
1049
1050	if (cs == CaseSensitive)
1051	return ::RTStrNCmp(m_psz, that.m_psz, l2) == 0;
1052	return ::RTStrNICmp(m_psz, that.m_psz, l2) == 0;
1053	}
1054
1055	bool RTCString::startsWithWord(const char pszWord, CaseSensitivity enmCase /= CaseSensitive*/) const RT_NOEXCEPT
1056	{
1057	const char pszSrc = RTStrStripL(c_str()); /* @todo RTStrStripL doesn't use RTUniCpIsSpace (nbsp) */
1058	size_t cchWord = strlen(pszWord);
1059	if ( enmCase == CaseSensitive
1060	? RTStrNCmp(pszSrc, pszWord, cchWord) == 0
1061	: RTStrNICmp(pszSrc, pszWord, cchWord) == 0)
1062	{
1063	if ( pszSrc[cchWord] == '\0'
1064	\|\| RT_C_IS_SPACE(pszSrc[cchWord])
1065	\|\| RT_C_IS_PUNCT(pszSrc[cchWord]) )
1066	return true;
1067	RTUNICP uc = RTStrGetCp(&pszSrc[cchWord]);
1068	if (RTUniCpIsSpace(uc))
1069	return true;
1070	}
1071	return false;
1072	}
1073
1074	bool RTCString::startsWithWord(const RTCString &rThat, CaseSensitivity enmCase /= CaseSensitive/) const RT_NOEXCEPT
1075	{
1076	return startsWithWord(rThat.c_str(), enmCase);
1077	}
1078
1079	bool RTCString::contains(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const RT_NOEXCEPT
1080	{
1081	/** @todo r-bird: Not checking for NULL strings like startsWith does (and
1082	* endsWith only does half way). */
1083	if (cs == CaseSensitive)
1084	return ::RTStrStr(m_psz, that.m_psz) != NULL;
1085	return ::RTStrIStr(m_psz, that.m_psz) != NULL;
1086	}
1087
1088	bool RTCString::contains(const char pszNeedle, CaseSensitivity cs /= CaseSensitive*/) const RT_NOEXCEPT
1089	{
1090	/** @todo r-bird: Not checking for NULL strings like startsWith does (and
1091	* endsWith only does half way). */
1092	if (cs == CaseSensitive)
1093	return ::RTStrStr(m_psz, pszNeedle) != NULL;
1094	return ::RTStrIStr(m_psz, pszNeedle) != NULL;
1095	}
1096
1097	int RTCString::toInt(uint64_t &i) const RT_NOEXCEPT
1098	{
1099	if (!m_psz)
1100	return VERR_NO_DIGITS;
1101	return RTStrToUInt64Ex(m_psz, NULL, 0, &i);
1102	}
1103
1104	int RTCString::toInt(uint32_t &i) const RT_NOEXCEPT
1105	{
1106	if (!m_psz)
1107	return VERR_NO_DIGITS;
1108	return RTStrToUInt32Ex(m_psz, NULL, 0, &i);
1109	}
1110
1111	RTCList<RTCString, RTCString *>
1112	RTCString::split(const RTCString &a_rstrSep, SplitMode mode /* = RemoveEmptyParts */) const
1113	{
1114	RTCList<RTCString> strRet;
1115	if (!m_psz)
1116	return strRet;
1117	if (a_rstrSep.isEmpty())
1118	{
1119	strRet.append(RTCString(m_psz));
1120	return strRet;
1121	}
1122
1123	size_t cch = m_cch;
1124	char const *pszTmp = m_psz;
1125	while (cch > 0)
1126	{
1127	char const *pszNext = strstr(pszTmp, a_rstrSep.c_str());
1128	if (!pszNext)
1129	{
1130	strRet.append(RTCString(pszTmp, cch));
1131	break;
1132	}
1133	size_t cchNext = pszNext - pszTmp;
1134	if ( cchNext > 0
1135	\|\| mode == KeepEmptyParts)
1136	strRet.append(RTCString(pszTmp, cchNext));
1137	pszTmp += cchNext + a_rstrSep.length();
1138	cch -= cchNext + a_rstrSep.length();
1139	}
1140
1141	return strRet;
1142	}
1143
1144	/* static */
1145	RTCString
1146	RTCString::joinEx(const RTCList<RTCString, RTCString *> &a_rList,
1147	const RTCString &a_rstrPrefix /* = "" */,
1148	const RTCString &a_rstrSep /* = "" */)
1149	{
1150	RTCString strRet;
1151	if (a_rList.size() > 1)
1152	{
1153	/* calc the required size */
1154	size_t cbNeeded = a_rstrSep.length() * (a_rList.size() - 1) + 1;
1155	cbNeeded += a_rstrPrefix.length() * (a_rList.size() - 1) + 1;
1156	for (size_t i = 0; i < a_rList.size(); ++i)
1157	cbNeeded += a_rList.at(i).length();
1158	strRet.reserve(cbNeeded);
1159
1160	/* do the appending. */
1161	for (size_t i = 0; i < a_rList.size() - 1; ++i)
1162	{
1163	if (a_rstrPrefix.isNotEmpty())
1164	strRet.append(a_rstrPrefix);
1165	strRet.append(a_rList.at(i));
1166	strRet.append(a_rstrSep);
1167	}
1168	strRet.append(a_rList.last());
1169	}
1170	/* special case: one list item. */
1171	else if (a_rList.size() > 0)
1172	{
1173	if (a_rstrPrefix.isNotEmpty())
1174	strRet.append(a_rstrPrefix);
1175	strRet.append(a_rList.last());
1176	}
1177
1178	return strRet;
1179	}
1180
1181	/* static */
1182	RTCString
1183	RTCString::join(const RTCList<RTCString, RTCString *> &a_rList,
1184	const RTCString &a_rstrSep /* = "" */)
1185	{
1186	return RTCString::joinEx(a_rList,
1187	"" /* a_rstrPrefix */, a_rstrSep);
1188	}
1189
1190	RTDECL(const RTCString) operator+(const RTCString &a_rStr1, const RTCString &a_rStr2)
1191	{
1192	RTCString strRet(a_rStr1);
1193	strRet += a_rStr2;
1194	return strRet;
1195	}
1196
1197	RTDECL(const RTCString) operator+(const RTCString &a_rStr1, const char *a_pszStr2)
1198	{
1199	RTCString strRet(a_rStr1);
1200	strRet += a_pszStr2;
1201	return strRet;
1202	}
1203
1204	RTDECL(const RTCString) operator+(const char *a_psz1, const RTCString &a_rStr2)
1205	{
1206	RTCString strRet(a_psz1);
1207	strRet += a_rStr2;
1208	return strRet;
1209	}
1210

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/string/ministring.cpp@ 96563

Download in other formats: