ministring.cpp@ 39877

Last change on this file since 39877 was 39873, checked in by vboxsync, 13 years ago
RTCString::find: made it more readable - 2 variable assignments in one if isn't cool.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.7 KB

Line
1	/* $Id: ministring.cpp 39873 2012-01-25 11:49:04Z 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-2011 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.215389.xyz. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*
20	* The contents of this file may alternatively be used under the terms
21	* of the Common Development and Distribution License Version 1.0
22	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
23	* VirtualBox OSE distribution, in which case the provisions of the
24	* CDDL are applicable instead of those of the GPL.
25	*
26	* You may elect to license modified versions of this file under the
27	* terms and conditions of either the GPL or the CDDL or both.
28	*/
29
30
31	/*******************************************************************************
32	* Header Files *
33	*******************************************************************************/
34	#include <iprt/cpp/ministring.h>
35
36
37	/*******************************************************************************
38	* Global Variables *
39	*******************************************************************************/
40	const size_t RTCString::npos = ~(size_t)0;
41
42
43	/*******************************************************************************
44	* Defined Constants And Macros *
45	*******************************************************************************/
46	/** Allocation block alignment used when appending bytes to a string. */
47	#define IPRT_MINISTRING_APPEND_ALIGNMENT 64
48
49
50	RTCString &RTCString::printf(const char *pszFormat, ...)
51	{
52	va_list va;
53	va_start(va, pszFormat);
54	printfV(pszFormat, va);
55	va_end(va);
56	return *this;
57	}
58
59	/**
60	* Callback used with RTStrFormatV by RTCString::printfV.
61	*
62	* @returns The number of bytes added (not used).
63	*
64	* @param pvArg The string object.
65	* @param pachChars The characters to append.
66	* @param cbChars The number of characters. 0 on the final callback.
67	*/
68	/static/ DECLCALLBACK(size_t)
69	RTCString::printfOutputCallback(void pvArg, const char pachChars, size_t cbChars)
70	{
71	RTCString pThis = (RTCString )pvArg;
72	if (cbChars)
73	{
74	size_t cchBoth = pThis->m_cch + cbChars;
75	if (cchBoth >= pThis->m_cbAllocated)
76	{
77	/* Double the buffer size, if it's less that _4M. Align sizes like
78	for append. */
79	size_t cbAlloc = RT_ALIGN_Z(pThis->m_cbAllocated, IPRT_MINISTRING_APPEND_ALIGNMENT);
80	cbAlloc += RT_MIN(cbAlloc, _4M);
81	if (cbAlloc <= cchBoth)
82	cbAlloc = RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT);
83	pThis->reserve(cbAlloc);
84	#ifndef RT_EXCEPTIONS_ENABLED
85	AssertReleaseReturn(pThis->capacity() > cchBoth, 0);
86	#endif
87	}
88
89	memcpy(&pThis->m_psz[pThis->m_cch], pachChars, cbChars);
90	pThis->m_cch = cchBoth;
91	pThis->m_psz[cchBoth] = '\0';
92	}
93	return cbChars;
94	}
95
96	RTCString &RTCString::printfV(const char *pszFormat, va_list va)
97	{
98	cleanup();
99	RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va);
100	return *this;
101	}
102
103	RTCString &RTCString::append(const RTCString &that)
104	{
105	size_t cchThat = that.length();
106	if (cchThat)
107	{
108	size_t cchThis = length();
109	size_t cchBoth = cchThis + cchThat;
110
111	if (cchBoth >= m_cbAllocated)
112	{
113	reserve(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
114	// calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
115	#ifndef RT_EXCEPTIONS_ENABLED
116	AssertRelease(capacity() > cchBoth);
117	#endif
118	}
119
120	memcpy(m_psz + cchThis, that.m_psz, cchThat);
121	m_psz[cchBoth] = '\0';
122	m_cch = cchBoth;
123	}
124	return *this;
125	}
126
127	RTCString &RTCString::append(const char *pszThat)
128	{
129	size_t cchThat = strlen(pszThat);
130	if (cchThat)
131	{
132	size_t cchThis = length();
133	size_t cchBoth = cchThis + cchThat;
134
135	if (cchBoth >= m_cbAllocated)
136	{
137	reserve(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
138	// calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
139	#ifndef RT_EXCEPTIONS_ENABLED
140	AssertRelease(capacity() > cchBoth);
141	#endif
142	}
143
144	memcpy(&m_psz[cchThis], pszThat, cchThat);
145	m_psz[cchBoth] = '\0';
146	m_cch = cchBoth;
147	}
148	return *this;
149	}
150
151	RTCString& RTCString::append(char ch)
152	{
153	Assert((unsigned char)ch < 0x80); /* Don't create invalid UTF-8. */
154	if (ch)
155	{
156	// allocate in chunks of 20 in case this gets called several times
157	if (m_cch + 1 >= m_cbAllocated)
158	{
159	reserve(RT_ALIGN_Z(m_cch + 2, IPRT_MINISTRING_APPEND_ALIGNMENT));
160	// calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
161	#ifndef RT_EXCEPTIONS_ENABLED
162	AssertRelease(capacity() > m_cch + 1);
163	#endif
164	}
165
166	m_psz[m_cch] = ch;
167	m_psz[++m_cch] = '\0';
168	}
169	return *this;
170	}
171
172	RTCString &RTCString::appendCodePoint(RTUNICP uc)
173	{
174	/*
175	* Single byte encoding.
176	*/
177	if (uc < 0x80)
178	return RTCString::append((char)uc);
179
180	/*
181	* Multibyte encoding.
182	* Assume max encoding length when resizing the string, that's simpler.
183	*/
184	AssertReturn(uc <= UINT32_C(0x7fffffff), *this);
185
186	if (m_cch + 6 >= m_cbAllocated)
187	{
188	reserve(RT_ALIGN_Z(m_cch + 6 + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
189	// calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
190	#ifndef RT_EXCEPTIONS_ENABLED
191	AssertRelease(capacity() > m_cch + 6);
192	#endif
193	}
194
195	char *pszNext = RTStrPutCp(&m_psz[m_cch], uc);
196	m_cch = pszNext - m_psz;
197	*pszNext = '\0';
198
199	return *this;
200	}
201
202	size_t RTCString::find(const char pcszFind, size_t pos /= 0*/) const
203	{
204	if (pos < length())
205	{
206	const char *pszThis = c_str();
207	if (pszThis)
208	{
209	const char *pszHit = strstr(pszThis, pcszFind);
210	if (pszHit)
211	return pszHit - pszThis;
212	}
213	}
214
215	return npos;
216	}
217
218	void RTCString::findReplace(char cFind, char cReplace)
219	{
220	for (size_t i = 0; i < length(); ++i)
221	{
222	char *p = &m_psz[i];
223	if (*p == cFind)
224	*p = cReplace;
225	}
226	}
227
228	RTCString RTCString::substrCP(size_t pos /= 0/, size_t n /= npos/) const
229	{
230	RTCString ret;
231
232	if (n)
233	{
234	const char *psz;
235
236	if ((psz = c_str()))
237	{
238	RTUNICP cp;
239
240	// walk the UTF-8 characters until where the caller wants to start
241	size_t i = pos;
242	while (*psz && i--)
243	if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
244	return ret; // return empty string on bad encoding
245
246	const char *pFirst = psz;
247
248	if (n == npos)
249	// all the rest:
250	ret = pFirst;
251	else
252	{
253	i = n;
254	while (*psz && i--)
255	if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
256	return ret; // return empty string on bad encoding
257
258	size_t cbCopy = psz - pFirst;
259	if (cbCopy)
260	{
261	ret.reserve(cbCopy + 1); // may throw bad_alloc
262	#ifndef RT_EXCEPTIONS_ENABLED
263	AssertRelease(capacity() >= cbCopy + 1);
264	#endif
265	memcpy(ret.m_psz, pFirst, cbCopy);
266	ret.m_cch = cbCopy;
267	ret.m_psz[cbCopy] = '\0';
268	}
269	}
270	}
271	}
272
273	return ret;
274	}
275
276	bool RTCString::endsWith(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const
277	{
278	size_t l1 = length();
279	if (l1 == 0)
280	return false;
281
282	size_t l2 = that.length();
283	if (l1 < l2)
284	return false;
285	/** @todo r=bird: If l2 is 0, then m_psz can be NULL and we will crash. See
286	* also handling of l2 == in startsWith. */
287
288	size_t l = l1 - l2;
289	if (cs == CaseSensitive)
290	return ::RTStrCmp(&m_psz[l], that.m_psz) == 0;
291	return ::RTStrICmp(&m_psz[l], that.m_psz) == 0;
292	}
293
294	bool RTCString::startsWith(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const
295	{
296	size_t l1 = length();
297	size_t l2 = that.length();
298	if (l1 == 0 \|\| l2 == 0) /** @todo r=bird: this differs from endsWith, and I think other IPRT code. If l2 == 0, it matches anything. */
299	return false;
300
301	if (l1 < l2)
302	return false;
303
304	if (cs == CaseSensitive)
305	return ::RTStrNCmp(m_psz, that.m_psz, l2) == 0;
306	return ::RTStrNICmp(m_psz, that.m_psz, l2) == 0;
307	}
308
309	bool RTCString::contains(const RTCString &that, CaseSensitivity cs /= CaseSensitive/) const
310	{
311	/** @todo r-bird: Not checking for NULL strings like startsWith does (and
312	* endsWith only does half way). */
313	if (cs == CaseSensitive)
314	return ::RTStrStr(m_psz, that.m_psz) != NULL;
315	return ::RTStrIStr(m_psz, that.m_psz) != NULL;
316	}
317
318	int RTCString::toInt(uint64_t &i) const
319	{
320	if (!m_psz)
321	return VERR_NO_DIGITS;
322	return RTStrToUInt64Ex(m_psz, NULL, 0, &i);
323	}
324
325	int RTCString::toInt(uint32_t &i) const
326	{
327	if (!m_psz)
328	return VERR_NO_DIGITS;
329	return RTStrToUInt32Ex(m_psz, NULL, 0, &i);
330	}
331
332	RTCList<RTCString, RTCString *>
333	RTCString::split(const RTCString &a_rstrSep, SplitMode mode /* = RemoveEmptyParts */) const
334	{
335	RTCList<RTCString> strRet;
336	if (!m_psz)
337	return strRet;
338	if (a_rstrSep.isEmpty())
339	{
340	strRet.append(RTCString(m_psz));
341	return strRet;
342	}
343
344	size_t cch = m_cch;
345	char const *pszTmp = m_psz;
346	while (cch > 0)
347	{
348	char const *pszNext = strstr(pszTmp, a_rstrSep.c_str());
349	if (!pszNext)
350	{
351	strRet.append(RTCString(pszTmp, cch));
352	break;
353	}
354	size_t cchNext = pszNext - pszTmp;
355	if ( cchNext > 0
356	\|\| mode == KeepEmptyParts)
357	strRet.append(RTCString(pszTmp, cchNext));
358	pszTmp += cchNext + a_rstrSep.length();
359	cch -= cchNext + a_rstrSep.length();
360	}
361
362	return strRet;
363	}
364
365	/* static */
366	RTCString
367	RTCString::join(const RTCList<RTCString, RTCString *> &a_rList,
368	const RTCString &a_rstrSep /* = "" */)
369	{
370	RTCString strRet;
371	if (a_rList.size() > 1)
372	{
373	/* calc the required size */
374	size_t cbNeeded = a_rstrSep.length() * (a_rList.size() - 1) + 1;
375	for (size_t i = 0; i < a_rList.size(); ++i)
376	cbNeeded += a_rList.at(i).length();
377	strRet.reserve(cbNeeded);
378
379	/* do the appending. */
380	for (size_t i = 0; i < a_rList.size() - 1; ++i)
381	{
382	strRet.append(a_rList.at(i));
383	strRet.append(a_rstrSep);
384	}
385	strRet.append(a_rList.last());
386	}
387	/* special case: one list item. */
388	else if (a_rList.size() > 0)
389	strRet.append(a_rList.last());
390
391	return strRet;
392	}
393
394	const RTCString operator+(const RTCString &a_rStr1, const RTCString &a_rStr2)
395	{
396	RTCString strRet(a_rStr1);
397	strRet += a_rStr2;
398	return strRet;
399	}
400
401	const RTCString operator+(const RTCString &a_rStr1, const char *a_pszStr2)
402	{
403	RTCString strRet(a_rStr1);
404	strRet += a_pszStr2;
405	return strRet;
406	}
407
408	const RTCString operator+(const char *a_psz1, const RTCString &a_rStr2)
409	{
410	RTCString strRet(a_psz1);
411	strRet += a_rStr2;
412	return strRet;
413	}
414

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

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

Download in other formats: