string.h@ 17646

Last change on this file since 17646 was 17646, checked in by vboxsync, 16 years ago
OVF: add actual image export
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.3 KB

Line
1	/* $Id: string.h 17646 2009-03-10 17:47:31Z vboxsync $ */
2
3	/** @file
4	* MS COM / XPCOM Abstraction Layer:
5	* Smart string classes declaration
6	*/
7
8	/*
9	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* The contents of this file may alternatively be used under the terms
20	* of the Common Development and Distribution License Version 1.0
21	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
22	* VirtualBox OSE distribution, in which case the provisions of the
23	* CDDL are applicable instead of those of the GPL.
24	*
25	* You may elect to license modified versions of this file under the
26	* terms and conditions of either the GPL or the CDDL or both.
27	*
28	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
29	* Clara, CA 95054 USA or visit http://www.sun.com if you need
30	* additional information or have any questions.
31	*/
32
33	#ifndef ___VBox_com_string_h
34	#define ___VBox_com_string_h
35
36	/* Make sure all the stdint.h macros are included - must come first! */
37	#ifndef __STDC_LIMIT_MACROS
38	# define __STDC_LIMIT_MACROS
39	#endif
40	#ifndef __STDC_CONSTANT_MACROS
41	# define __STDC_CONSTANT_MACROS
42	#endif
43
44	#if defined (VBOX_WITH_XPCOM)
45	# include <nsMemory.h>
46	#endif
47
48	#include "VBox/com/defs.h"
49	#include "VBox/com/assert.h"
50
51	#include <iprt/string.h>
52	#include <iprt/cpputils.h>
53	#include <iprt/alloc.h>
54
55	namespace com
56	{
57
58	class Utf8Str;
59
60	/**
61	* Helper class that represents the \|BSTR\| type and hides platform-specific
62	* implementation details.
63	*
64	* This class uses COM/XPCOM-provided memory management routines to allocate
65	* and free string buffers. This makes it possible to:
66	* - use it as a type of member variables of COM/XPCOM components and pass
67	* their values to callers through component methods' output parameters
68	* using the #cloneTo() operation;
69	* - adopt (take ownership of) string buffers returned in output parameters
70	* of COM methods using the #asOutParam() operation and correctly free them
71	* afterwards.
72	*/
73	class Bstr
74	{
75	public:
76
77	typedef BSTR String;
78	typedef CBSTR ConstString;
79
80	Bstr () : bstr (NULL) {}
81
82	Bstr (const Bstr &that) : bstr (NULL) { raw_copy (bstr, that.bstr); }
83	Bstr (CBSTR that) : bstr (NULL) { raw_copy (bstr, that); }
84
85	#if defined (VBOX_WITH_XPCOM)
86	Bstr (const wchar_t *that) : bstr (NULL)
87	{
88	AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
89	raw_copy (bstr, (CBSTR) that);
90	}
91	#endif
92
93	Bstr (const Utf8Str &that);
94	Bstr (const char *that);
95
96	/** Shortcut that calls #alloc(aSize) right after object creation. */
97	Bstr (size_t aSize) : bstr (NULL) { alloc (aSize); }
98
99	~Bstr () { setNull(); }
100
101	Bstr &operator = (const Bstr &that) { safe_assign (that.bstr); return *this; }
102	Bstr &operator = (CBSTR that) { safe_assign (that); return *this; }
103
104	Bstr &operator = (const Utf8Str &that);
105	Bstr &operator = (const char *that);
106
107	Bstr &setNull()
108	{
109	if (bstr)
110	{
111	::SysFreeString (bstr);
112	bstr = NULL;
113	}
114	return *this;
115	}
116
117	Bstr &setNullIfEmpty()
118	{
119	if (bstr && *bstr == 0)
120	{
121	::SysFreeString (bstr);
122	bstr = NULL;
123	}
124	return *this;
125	}
126
127	/**
128	* Allocates memory for a string capable to store \a aSize - 1 characters;
129	* in other words, aSize includes the terminating zero character. If \a aSize
130	* is zero, or if a memory allocation error occurs, this object will become null.
131	*/
132	Bstr &alloc (size_t aSize)
133	{
134	setNull();
135	if (aSize)
136	{
137	unsigned int size = (unsigned int) aSize; Assert (size == aSize);
138	bstr = ::SysAllocStringLen (NULL, size - 1);
139	if (bstr)
140	bstr [0] = 0;
141	}
142	return *this;
143	}
144
145	int compare (CBSTR str) const
146	{
147	return ::RTUtf16Cmp ((PRTUTF16) bstr, (PRTUTF16) str);
148	}
149
150	int compare (BSTR str) const
151	{
152	return ::RTUtf16Cmp ((PRTUTF16) bstr, (PRTUTF16) str);
153	}
154
155	bool operator == (const Bstr &that) const { return !compare (that.bstr); }
156	bool operator != (const Bstr &that) const { return !!compare (that.bstr); }
157	bool operator == (CBSTR that) const { return !compare (that); }
158	bool operator == (BSTR that) const { return !compare (that); }
159
160	#if defined (VBOX_WITH_XPCOM)
161	bool operator != (const wchar_t *that) const
162	{
163	AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
164	return !!compare ((CBSTR) that);
165	}
166	bool operator == (const wchar_t *that) const
167	{
168	AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
169	return !compare ((CBSTR) that);
170	}
171	#endif
172
173	bool operator != (CBSTR that) const { return !!compare (that); }
174	bool operator != (BSTR that) const { return !!compare (that); }
175	bool operator < (const Bstr &that) const { return compare (that.bstr) < 0; }
176	bool operator < (CBSTR that) const { return compare (that) < 0; }
177	bool operator < (BSTR that) const { return compare (that) < 0; }
178	#if defined (VBOX_WITH_XPCOM)
179	bool operator < (const wchar_t *that) const
180	{
181	AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
182	return compare ((CBSTR) that) < 0;
183	}
184	#endif
185
186	int compareIgnoreCase (CBSTR str) const
187	{
188	return ::RTUtf16LocaleICmp (bstr, str);
189	}
190
191	bool isNull() const { return bstr == NULL; }
192	operator bool() const { return !isNull(); }
193
194	bool isEmpty() const { return isNull() \|\| *bstr == 0; }
195
196	size_t length() const { return isNull() ? 0 : ::RTUtf16Len ((PRTUTF16) bstr); }
197
198	/** Intended to to pass instances as \|CBSTR\| input parameters to methods. */
199	operator CBSTR () const { return bstr; }
200
201	/**
202	* Intended to to pass instances as \|BSTR\| input parameters to methods.
203	* Note that we have to provide this mutable BSTR operator since in MS COM
204	* input BSTR parameters of interface methods are not const.
205	*/
206	operator BSTR () { return bstr; }
207
208	/**
209	* The same as operator CBSTR(), but for situations where the compiler
210	* cannot typecast implicitly (for example, in printf() argument list).
211	*/
212	CBSTR raw() const { return bstr; }
213
214	/**
215	* Returns a non-const raw pointer that allows to modify the string directly.
216	* @warning
217	* Be sure not to modify data beyond the allocated memory! The
218	* guaranteed size of the allocated memory is at least #length()
219	* bytes after creation and after every assignment operation.
220	*/
221	BSTR mutableRaw() { return bstr; }
222
223	/**
224	* Intended to assign copies of instances to \|BSTR\| out parameters from
225	* within the interface method. Transfers the ownership of the duplicated
226	* string to the caller.
227	*/
228	const Bstr &cloneTo (BSTR *pstr) const
229	{
230	if (pstr)
231	{
232	*pstr = NULL;
233	raw_copy (*pstr, bstr);
234	}
235	return *this;
236	}
237
238	/**
239	* Intended to assign instances to \|BSTR\| out parameters from within the
240	* interface method. Transfers the ownership of the original string to the
241	* caller and resets the instance to null.
242	*
243	* As opposed to cloneTo(), this method doesn't create a copy of the
244	* string.
245	*/
246	Bstr &detachTo (BSTR *pstr)
247	{
248	*pstr = bstr;
249	bstr = NULL;
250	return *this;
251	}
252
253	/**
254	* Intended to assign copies of instances to \|char *\| out parameters from
255	* within the interface method. Transfers the ownership of the duplicated
256	* string to the caller.
257	*/
258	const Bstr &cloneTo (char **pstr) const;
259
260	/**
261	* Intended to pass instances as \|BSTR\| out parameters to methods.
262	* Takes the ownership of the returned data.
263	*/
264	BSTR *asOutParam() { setNull(); return &bstr; }
265
266	/**
267	* Static immutable null object. May be used for comparison purposes.
268	*/
269	static const Bstr Null;
270
271	protected:
272
273	void safe_assign (CBSTR str)
274	{
275	if (bstr != str)
276	{
277	setNull();
278	raw_copy (bstr, str);
279	}
280	}
281
282	inline static void raw_copy (BSTR &ls, CBSTR rs)
283	{
284	if (rs)
285	ls = ::SysAllocString ((const OLECHAR *) rs);
286	}
287
288	inline static void raw_copy (BSTR &ls, const char *rs)
289	{
290	if (rs)
291	{
292	PRTUTF16 s = NULL;
293	::RTStrToUtf16 (rs, &s);
294	raw_copy (ls, (BSTR) s);
295	::RTUtf16Free (s);
296	}
297	}
298
299	BSTR bstr;
300
301	friend class Utf8Str; /* to access our raw_copy() */
302	};
303
304	/* symmetric compare operators */
305	inline bool operator== (CBSTR l, const Bstr &r) { return r.operator== (l); }
306	inline bool operator!= (CBSTR l, const Bstr &r) { return r.operator!= (l); }
307	inline bool operator== (BSTR l, const Bstr &r) { return r.operator== (l); }
308	inline bool operator!= (BSTR l, const Bstr &r) { return r.operator!= (l); }
309
310	////////////////////////////////////////////////////////////////////////////////
311
312	/**
313	* Helper class that represents UTF8 (\|char *\|) strings. Useful in
314	* conjunction with Bstr to simplify conversions between UTF16 (\|BSTR\|)
315	* and UTF8.
316	*
317	* This class uses COM/XPCOM-provided memory management routines to allocate
318	* and free string buffers. This makes it possible to:
319	* - use it as a type of member variables of COM/XPCOM components and pass
320	* their values to callers through component methods' output parameters
321	* using the #cloneTo() operation;
322	* - adopt (take ownership of) string buffers returned in output parameters
323	* of COM methods using the #asOutParam() operation and correctly free them
324	* afterwards.
325	*/
326	class Utf8Str
327	{
328	public:
329
330	typedef char *String;
331	typedef const char *ConstString;
332
333	Utf8Str () : str (NULL) {}
334
335	Utf8Str (const Utf8Str &that) : str (NULL) { raw_copy (str, that.str); }
336	Utf8Str (const char *that) : str (NULL) { raw_copy (str, that); }
337
338	Utf8Str (const Bstr &that) : str (NULL) { raw_copy (str, that); }
339	Utf8Str (CBSTR that) : str (NULL) { raw_copy (str, that); }
340
341	/** Shortcut that calls #alloc(aSize) right after object creation. */
342	Utf8Str (size_t aSize) : str (NULL) { alloc(aSize); }
343
344	virtual ~Utf8Str () { setNull(); }
345
346	Utf8Str &operator = (const Utf8Str &that) { safe_assign (that.str); return *this; }
347	Utf8Str &operator = (const char that) { safe_assign (that); return this; }
348
349	Utf8Str &operator = (const Bstr &that)
350	{
351	setNull();
352	raw_copy (str, that);
353	return *this;
354	}
355	Utf8Str &operator = (CBSTR that)
356	{
357	setNull();
358	raw_copy (str, that);
359	return *this;
360	}
361
362	Utf8Str &setNull()
363	{
364	if (str)
365	{
366	#if !defined (VBOX_WITH_XPCOM)
367	::RTStrFree (str);
368	#else
369	nsMemory::Free (str);
370	#endif
371	str = NULL;
372	}
373	return *this;
374	}
375
376	Utf8Str &setNullIfEmpty()
377	{
378	if (str && *str == 0)
379	{
380	#if !defined (VBOX_WITH_XPCOM)
381	::RTStrFree (str);
382	#else
383	nsMemory::Free (str);
384	#endif
385	str = NULL;
386	}
387	return *this;
388	}
389
390	/**
391	* Allocates memory for a string capable to store \a aSize - 1 bytes (not characters!);
392	* in other words, aSize includes the terminating zero character. If \a aSize
393	* is zero, or if a memory allocation error occurs, this object will become null.
394	*/
395	Utf8Str &alloc (size_t aSize)
396	{
397	setNull();
398	if (aSize)
399	{
400	#if !defined (VBOX_WITH_XPCOM)
401	str = (char *) ::RTMemTmpAlloc (aSize);
402	#else
403	str = (char *) nsMemory::Alloc (aSize);
404	#endif
405	if (str)
406	str [0] = 0;
407	}
408	return *this;
409	}
410
411	void append(const Utf8Str &that)
412	{
413	size_t cbThis = length();
414	size_t cbThat = that.length();
415
416	if (cbThat)
417	{
418	size_t cbBoth = cbThis + cbThat + 1;
419
420	// @todo optimize
421	char *pszTemp;
422	#if !defined (VBOX_WITH_XPCOM)
423	pszTemp = (char*)::RTMemTmpAlloc(cbBoth);
424	#else
425	pszTemp = (char*)nsMemory::Alloc(cbBoth);
426	#endif
427	if (str)
428	{
429	memcpy(pszTemp, str, cbThis);
430	setNull();
431	}
432	if (that.str)
433	memcpy(pszTemp + cbThis, that.str, cbThat);
434	pszTemp[cbThis + cbThat] = '\0';
435
436	str = pszTemp;
437	}
438	}
439
440	int compare (const char *s) const
441	{
442	if (str == s)
443	return 0;
444	if (str == NULL)
445	return -1;
446	if (s == NULL)
447	return 1;
448
449	return ::strcmp (str, s);
450	}
451
452	bool operator == (const Utf8Str &that) const { return !compare (that.str); }
453	bool operator != (const Utf8Str &that) const { return !!compare (that.str); }
454	bool operator == (const char *that) const { return !compare (that); }
455	bool operator != (const char *that) const { return !!compare (that); }
456	bool operator < (const Utf8Str &that) const { return compare (that.str) < 0; }
457	bool operator < (const char *that) const { return compare (that) < 0; }
458
459	int compareIgnoreCase(const char *pcsz) const
460	{
461	return ::RTStrICmp(str, pcsz);
462	}
463
464	bool isNull() const { return str == NULL; }
465	operator bool() const { return !isNull(); }
466
467	bool isEmpty() const { return isNull() \|\| *str == 0; }
468
469	size_t length() const { return isNull() ? 0 : ::strlen (str); }
470
471	/** Intended to to pass instances as input (\|char \|) parameters to methods. /
472	operator const char *() const { return str; }
473
474	/** The same as operator const char *(), but for situations where the compiler
475	cannot typecast implicitly (for example, in printf() argument list). */
476	const char *raw() const { return str; }
477
478	/** The same as operator const char *(), but for situations where the compiler
479	cannot typecast implicitly (for example, in printf() argument list). */
480	const char *c_str() const { return str; }
481
482	/**
483	* Returns a non-const raw pointer that allows to modify the string directly.
484	* @warning
485	* Be sure not to modify data beyond the allocated memory! The
486	* guaranteed size of the allocated memory is at least #length()
487	* bytes after creation and after every assignment operation.
488	*/
489	char *mutableRaw() { return str; }
490
491	/**
492	* Intended to assign instances to \|char *\| out parameters from within the
493	* interface method. Transfers the ownership of the duplicated string to the
494	* caller.
495	*/
496	const Utf8Str &cloneTo (char **pstr) const
497	{
498	if (pstr)
499	{
500	*pstr = NULL;
501	raw_copy (*pstr, str);
502	}
503	return *this;
504	}
505
506	/**
507	* Intended to assign instances to \|char *\| out parameters from within the
508	* interface method. Transfers the ownership of the original string to the
509	* caller and resets the instance to null.
510	*
511	* As opposed to cloneTo(), this method doesn't create a copy of the
512	* string.
513	*/
514	Utf8Str &detachTo (char **pstr)
515	{
516	*pstr = str;
517	str = NULL;
518	return *this;
519	}
520
521	/**
522	* Intended to assign instances to \|BSTR\| out parameters from within the
523	* interface method. Transfers the ownership of the duplicated string to the
524	* caller.
525	*/
526	const Utf8Str &cloneTo (BSTR *pstr) const
527	{
528	if (pstr)
529	{
530	*pstr = NULL;
531	Bstr::raw_copy (*pstr, str);
532	}
533	return *this;
534	}
535
536	static const size_t npos;
537
538	/**
539	* Looks for pcszFind in "this" starting at "pos" and returns its position,
540	* counting from the beginning of "this" at 0. Returns npos if not found.
541	*/
542	size_t find(const char *pcszFind, size_t pos = 0) const;
543
544	/**
545	* Returns a substring of "this" as a new Utf8Str. Works exactly like
546	* its equivalent in std::string except that this interprets pos and n
547	* as UTF-8 codepoints instead of bytes. With the default parameters "0"
548	* and "npos", this always copies the entire string.
549	* @param pos Index of first codepoint to copy from "this", counting from 0.
550	* @param n Number of codepoints to copy, starting with the one at "pos".
551	*/
552	Utf8Str substr(size_t pos = 0, size_t n = npos) const;
553
554	/**
555	* Attempts to convert the member string into an unsigned 64-bit integer.
556	* @return IPRT error code.
557	* @param i Output buffer.
558	*/
559	int toInt(uint64_t &i) const;
560
561	/**
562	* Attempts to convert the member string into an unsigned 32-bit integer.
563	* @return IPRT error code.
564	* @param i Output buffer.
565	*/
566	int toInt(uint32_t &i) const;
567
568	/**
569	* Intended to pass instances as out (\|char **\|) parameters to methods.
570	* Takes the ownership of the returned data.
571	*/
572	char **asOutParam() { setNull(); return &str; }
573
574	/**
575	* Static immutable null object. May be used for comparison purposes.
576	*/
577	static const Utf8Str Null;
578
579	protected:
580
581	void safe_assign (const char *s)
582	{
583	if (str != s)
584	{
585	setNull();
586	raw_copy (str, s);
587	}
588	}
589
590	inline static void raw_copy (char &ls, const char rs)
591	{
592	if (rs)
593	#if !defined (VBOX_WITH_XPCOM)
594	::RTStrDupEx (&ls, rs);
595	#else
596	ls = (char *) nsMemory::Clone (rs, strlen (rs) + 1);
597	#endif
598	}
599
600	inline static void raw_copy (char *&ls, CBSTR rs)
601	{
602	if (rs)
603	{
604	#if !defined (VBOX_WITH_XPCOM)
605	::RTUtf16ToUtf8 ((PRTUTF16) rs, &ls);
606	#else
607	char *s = NULL;
608	::RTUtf16ToUtf8 ((PRTUTF16) rs, &s);
609	raw_copy (ls, s);
610	::RTStrFree (s);
611	#endif
612	}
613	}
614
615	char *str;
616
617	friend class Bstr; /* to access our raw_copy() */
618	};
619
620	// symmetric compare operators
621	inline bool operator== (const char *l, const Utf8Str &r) { return r.operator== (l); }
622	inline bool operator!= (const char *l, const Utf8Str &r) { return r.operator!= (l); }
623
624	// work around error C2593 of the stupid MSVC 7.x ambiguity resolver
625	WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP (Bstr)
626	WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP (Utf8Str)
627
628	////////////////////////////////////////////////////////////////////////////////
629
630	// inlined Bstr members that depend on Utf8Str
631
632	inline Bstr::Bstr (const Utf8Str &that) : bstr (NULL) { raw_copy (bstr, that); }
633	inline Bstr::Bstr (const char *that) : bstr (NULL) { raw_copy (bstr, that); }
634
635	inline Bstr &Bstr::operator = (const Utf8Str &that)
636	{
637	setNull();
638	raw_copy (bstr, that);
639	return *this;
640	}
641	inline Bstr &Bstr::operator = (const char *that)
642	{
643	setNull();
644	raw_copy (bstr, that);
645	return *this;
646	}
647
648	inline const Bstr &Bstr::cloneTo (char **pstr) const
649	{
650	if (pstr) {
651	*pstr = NULL;
652	Utf8Str::raw_copy (*pstr, bstr);
653	}
654	return *this;
655	}
656
657	////////////////////////////////////////////////////////////////////////////////
658
659	/**
660	* This class is a printf-like formatter for Utf8Str strings. Its purpose is
661	* to construct Utf8Str objects from a format string and a list of arguments
662	* for the format string.
663	*
664	* The usage of this class is like the following:
665	* <code>
666	* Utf8StrFmt string ("program name = %s", argv[0]);
667	* </code>
668	*/
669	class Utf8StrFmt : public Utf8Str
670	{
671	public:
672
673	/**
674	* Constructs a new string given the format string and the list
675	* of the arguments for the format string.
676	*
677	* @param format printf-like format string (in UTF-8 encoding)
678	* @param ... list of the arguments for the format string
679	*/
680	explicit Utf8StrFmt (const char *format, ...)
681	{
682	va_list args;
683	va_start (args, format);
684	init (format, args);
685	va_end (args);
686	}
687
688	protected:
689
690	Utf8StrFmt() {}
691
692	void init (const char *format, va_list args);
693
694	private:
695
696	static DECLCALLBACK(size_t) strOutput (void pvArg, const char pachChars,
697	size_t cbChars);
698	};
699
700	/**
701	* This class is a vprintf-like formatter for Utf8Str strings. It is
702	* identical to Utf8StrFmt except that its constructor takes a va_list
703	* argument instead of ellipsis.
704	*
705	* Note that a separate class is necessary because va_list is defined as
706	* \|char *\| on most platforms. For this reason, if we had two overloaded
707	* constructors in Utf8StrFmt (one taking ellipsis and another one taking
708	* va_list) then composing a constructor call using exactly two \|char *\|
709	* arguments would cause the compiler to use the va_list overload instead of
710	* the ellipsis one which is obviously wrong. The compiler would choose
711	* va_list because ellipsis has the lowest rank when it comes to resolving
712	* overloads, as opposed to va_list which is an exact match for \|char *\|.
713	*/
714	class Utf8StrFmtVA : public Utf8StrFmt
715	{
716	public:
717
718	/**
719	* Constructs a new string given the format string and the list
720	* of the arguments for the format string.
721	*
722	* @param format printf-like format string (in UTF-8 encoding)
723	* @param args list of arguments for the format string
724	*/
725	Utf8StrFmtVA (const char *format, va_list args) { init (format, args); }
726	};
727
728	/**
729	* The BstrFmt class is a shortcut to <tt>Bstr (Utf8StrFmt (...))</tt>.
730	*/
731	class BstrFmt : public Bstr
732	{
733	public:
734
735	/**
736	* Constructs a new string given the format string and the list of the
737	* arguments for the format string.
738	*
739	* @param aFormat printf-like format string (in UTF-8 encoding).
740	* @param ... List of the arguments for the format string.
741	*/
742	explicit BstrFmt (const char *aFormat, ...)
743	{
744	va_list args;
745	va_start (args, aFormat);
746	raw_copy (bstr, Utf8StrFmtVA (aFormat, args));
747	va_end (args);
748	}
749	};
750
751	/**
752	* The BstrFmtVA class is a shortcut to <tt>Bstr (Utf8StrFmtVA (...))</tt>.
753	*/
754	class BstrFmtVA : public Bstr
755	{
756	public:
757
758	/**
759	* Constructs a new string given the format string and the list of the
760	* arguments for the format string.
761	*
762	* @param aFormat printf-like format string (in UTF-8 encoding).
763	* @param aArgs List of arguments for the format string
764	*/
765	BstrFmtVA (const char *aFormat, va_list aArgs)
766	{
767	raw_copy (bstr, Utf8StrFmtVA (aFormat, aArgs));
768	}
769	};
770
771	} /* namespace com */
772
773	#endif /* ___VBox_com_string_h */

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

source: vbox/trunk/include/VBox/com/string.h@ 17646

Download in other formats: