nsVariant.cpp@ 66250

Last change on this file since 66250 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.0 KB

Line
1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 --
2	*
3	* *** BEGIN LICENSE BLOCK ***
4	* Version: MPL 1.1/GPL 2.0/LGPL 2.1
5	*
6	* The contents of this file are subject to the Mozilla Public License Version
7	* 1.1 (the "License"); you may not use this file except in compliance with
8	* the License. You may obtain a copy of the License at
9	* http://www.mozilla.org/MPL/
10	*
11	* Software distributed under the License is distributed on an "AS IS" basis,
12	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13	* for the specific language governing rights and limitations under the
14	* License.
15	*
16	* The Original Code is mozilla.org code.
17	*
18	* The Initial Developer of the Original Code is
19	* Netscape Communications Corporation.
20	* Portions created by the Initial Developer are Copyright (C) 1998
21	* the Initial Developer. All Rights Reserved.
22	*
23	* Contributor(s):
24	* John Bandhauer <jband@netscape.com>
25	*
26	* Alternatively, the contents of this file may be used under the terms of
27	* either of the GNU General Public License Version 2 or later (the "GPL"),
28	* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29	* in which case the provisions of the GPL or the LGPL are applicable instead
30	* of those above. If you wish to allow use of your version of this file only
31	* under the terms of either the GPL or the LGPL, and not to allow others to
32	* use your version of this file under the terms of the MPL, indicate your
33	* decision by deleting the provisions above and replace them with the notice
34	* and other provisions required by the GPL or the LGPL. If you do not delete
35	* the provisions above, a recipient may use your version of this file under
36	* the terms of any one of the MPL, the GPL or the LGPL.
37	*
38	* *** END LICENSE BLOCK *** */
39
40	/* The long avoided variant support for xpcom. */
41
42	#include "nsVariant.h"
43	#include "nsString.h"
44	#include "prprf.h"
45	#include "prdtoa.h"
46	#include <math.h>
47	#include "nsCRT.h"
48
49	/***************************************************************************/
50	// Helpers for static convert functions...
51
52	static nsresult String2Double(const char* aString, double* retval)
53	{
54	char* next;
55	double value = PR_strtod(aString, &next);
56	if(next == aString)
57	return NS_ERROR_CANNOT_CONVERT_DATA;
58	*retval = value;
59	return NS_OK;
60	}
61
62	static nsresult AString2Double(const nsAString& aString, double* retval)
63	{
64	char* pChars = ToNewCString(aString);
65	if(!pChars)
66	return NS_ERROR_OUT_OF_MEMORY;
67	nsresult rv = String2Double(pChars, retval);
68	nsMemory::Free(pChars);
69	return rv;
70	}
71
72	static nsresult AUTF8String2Double(const nsAUTF8String& aString, double* retval)
73	{
74	return String2Double(PromiseFlatUTF8String(aString).get(), retval);
75	}
76
77	static nsresult ACString2Double(const nsACString& aString, double* retval)
78	{
79	return String2Double(PromiseFlatCString(aString).get(), retval);
80	}
81
82	// Fills outVariant with double, PRUint32, or PRInt32.
83	// Returns NS_OK, an error code, or a non-NS_OK success code
84	static nsresult ToManageableNumber(const nsDiscriminatedUnion& inData,
85	nsDiscriminatedUnion* outData)
86	{
87	nsresult rv;
88
89	switch(inData.mType)
90	{
91	// This group results in a PRInt32...
92
93	#define CASE__NUMBER_INT32(type_, member_) \
94	case nsIDataType :: type_ : \
95	outData->u.mInt32Value = inData.u. member_ ; \
96	outData->mType = nsIDataType::VTYPE_INT32; \
97	return NS_OK;
98
99	CASE__NUMBER_INT32(VTYPE_INT8, mInt8Value)
100	CASE__NUMBER_INT32(VTYPE_INT16, mInt16Value)
101	CASE__NUMBER_INT32(VTYPE_INT32, mInt32Value)
102	CASE__NUMBER_INT32(VTYPE_UINT8, mUint8Value)
103	CASE__NUMBER_INT32(VTYPE_UINT16, mUint16Value)
104	CASE__NUMBER_INT32(VTYPE_BOOL, mBoolValue)
105	CASE__NUMBER_INT32(VTYPE_CHAR, mCharValue)
106	CASE__NUMBER_INT32(VTYPE_WCHAR, mWCharValue)
107
108	#undef CASE__NUMBER_INT32
109
110	// This group results in a PRUint32...
111
112	case nsIDataType::VTYPE_UINT32:
113	outData->u.mInt32Value = inData.u.mUint32Value;
114	outData->mType = nsIDataType::VTYPE_INT32;
115	return NS_OK;
116
117	// This group results in a double...
118
119	case nsIDataType::VTYPE_INT64:
120	case nsIDataType::VTYPE_UINT64:
121	// XXX Need boundary checking here.
122	// We may need to return NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA
123	LL_L2D(outData->u.mDoubleValue, inData.u.mInt64Value);
124	outData->mType = nsIDataType::VTYPE_DOUBLE;
125	return NS_OK;
126	case nsIDataType::VTYPE_FLOAT:
127	outData->u.mDoubleValue = inData.u.mFloatValue;
128	outData->mType = nsIDataType::VTYPE_DOUBLE;
129	return NS_OK;
130	case nsIDataType::VTYPE_DOUBLE:
131	outData->u.mDoubleValue = inData.u.mDoubleValue;
132	outData->mType = nsIDataType::VTYPE_DOUBLE;
133	return NS_OK;
134	case nsIDataType::VTYPE_CHAR_STR:
135	case nsIDataType::VTYPE_STRING_SIZE_IS:
136	rv = String2Double(inData.u.str.mStringValue, &outData->u.mDoubleValue);
137	if(NS_FAILED(rv))
138	return rv;
139	outData->mType = nsIDataType::VTYPE_DOUBLE;
140	return NS_OK;
141	case nsIDataType::VTYPE_DOMSTRING:
142	case nsIDataType::VTYPE_ASTRING:
143	rv = AString2Double(*inData.u.mAStringValue, &outData->u.mDoubleValue);
144	if(NS_FAILED(rv))
145	return rv;
146	outData->mType = nsIDataType::VTYPE_DOUBLE;
147	return NS_OK;
148	case nsIDataType::VTYPE_UTF8STRING:
149	rv = AUTF8String2Double(*inData.u.mUTF8StringValue,
150	&outData->u.mDoubleValue);
151	if(NS_FAILED(rv))
152	return rv;
153	outData->mType = nsIDataType::VTYPE_DOUBLE;
154	return NS_OK;
155	case nsIDataType::VTYPE_CSTRING:
156	rv = ACString2Double(*inData.u.mCStringValue,
157	&outData->u.mDoubleValue);
158	if(NS_FAILED(rv))
159	return rv;
160	outData->mType = nsIDataType::VTYPE_DOUBLE;
161	return NS_OK;
162	case nsIDataType::VTYPE_WCHAR_STR:
163	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
164	rv = AString2Double(nsDependentString(inData.u.wstr.mWStringValue),
165	&outData->u.mDoubleValue);
166	if(NS_FAILED(rv))
167	return rv;
168	outData->mType = nsIDataType::VTYPE_DOUBLE;
169	return NS_OK;
170
171	// This group fails...
172
173	case nsIDataType::VTYPE_VOID:
174	case nsIDataType::VTYPE_ID:
175	case nsIDataType::VTYPE_INTERFACE:
176	case nsIDataType::VTYPE_INTERFACE_IS:
177	case nsIDataType::VTYPE_ARRAY:
178	case nsIDataType::VTYPE_EMPTY_ARRAY:
179	case nsIDataType::VTYPE_EMPTY:
180	default:
181	return NS_ERROR_CANNOT_CONVERT_DATA;
182	}
183	}
184
185	/***************************************************************************/
186	// Array helpers...
187
188	static void FreeArray(nsDiscriminatedUnion* data)
189	{
190	NS_ASSERTION(data->mType == nsIDataType::VTYPE_ARRAY, "bad FreeArray call");
191	NS_ASSERTION(data->u.array.mArrayValue, "bad array");
192	NS_ASSERTION(data->u.array.mArrayCount, "bad array count");
193
194	#define CASE__FREE_ARRAY_PTR(type_, ctype_) \
195	case nsIDataType:: type_ : \
196	{ \
197	ctype_ p = (ctype_ ) data->u.array.mArrayValue; \
198	for(PRUint32 i = data->u.array.mArrayCount; i > 0; p++, i--) \
199	if(*p) \
200	nsMemory::Free((char)p); \
201	break; \
202	}
203
204	#define CASE__FREE_ARRAY_IFACE(type_, ctype_) \
205	case nsIDataType:: type_ : \
206	{ \
207	ctype_ p = (ctype_ ) data->u.array.mArrayValue; \
208	for(PRUint32 i = data->u.array.mArrayCount; i > 0; p++, i--) \
209	if(*p) \
210	(*p)->Release(); \
211	break; \
212	}
213
214	switch(data->u.array.mArrayType)
215	{
216	case nsIDataType::VTYPE_INT8:
217	case nsIDataType::VTYPE_INT16:
218	case nsIDataType::VTYPE_INT32:
219	case nsIDataType::VTYPE_INT64:
220	case nsIDataType::VTYPE_UINT8:
221	case nsIDataType::VTYPE_UINT16:
222	case nsIDataType::VTYPE_UINT32:
223	case nsIDataType::VTYPE_UINT64:
224	case nsIDataType::VTYPE_FLOAT:
225	case nsIDataType::VTYPE_DOUBLE:
226	case nsIDataType::VTYPE_BOOL:
227	case nsIDataType::VTYPE_CHAR:
228	case nsIDataType::VTYPE_WCHAR:
229	break;
230
231	// XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
232	CASE__FREE_ARRAY_PTR(VTYPE_ID, nsID)
233	CASE__FREE_ARRAY_PTR(VTYPE_CHAR_STR, char)
234	CASE__FREE_ARRAY_PTR(VTYPE_WCHAR_STR, PRUnichar)
235	CASE__FREE_ARRAY_IFACE(VTYPE_INTERFACE, nsISupports)
236	CASE__FREE_ARRAY_IFACE(VTYPE_INTERFACE_IS, nsISupports)
237
238	// The rest are illegal.
239	case nsIDataType::VTYPE_VOID:
240	case nsIDataType::VTYPE_ASTRING:
241	case nsIDataType::VTYPE_DOMSTRING:
242	case nsIDataType::VTYPE_UTF8STRING:
243	case nsIDataType::VTYPE_CSTRING:
244	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
245	case nsIDataType::VTYPE_STRING_SIZE_IS:
246	case nsIDataType::VTYPE_ARRAY:
247	case nsIDataType::VTYPE_EMPTY_ARRAY:
248	case nsIDataType::VTYPE_EMPTY:
249	default:
250	NS_ERROR("bad type in array!");
251	break;
252	}
253
254	// Free the array memory.
255	nsMemory::Free((char*)data->u.array.mArrayValue);
256
257	#undef CASE__FREE_ARRAY_PTR
258	#undef CASE__FREE_ARRAY_IFACE
259	}
260
261	static nsresult CloneArray(PRUint16 inType, const nsIID* inIID,
262	PRUint32 inCount, void* inValue,
263	PRUint16* outType, nsIID* outIID,
264	PRUint32* outCount, void** outValue)
265	{
266	NS_ASSERTION(inCount, "bad param");
267	NS_ASSERTION(inValue, "bad param");
268	NS_ASSERTION(outType, "bad param");
269	NS_ASSERTION(outCount, "bad param");
270	NS_ASSERTION(outValue, "bad param");
271
272	PRUint32 allocatedValueCount = 0;
273	nsresult rv = NS_OK;
274	PRUint32 i;
275
276	// First we figure out the size of the elements for the new u.array.
277
278	size_t elementSize;
279	size_t allocSize;
280
281	switch(inType)
282	{
283	case nsIDataType::VTYPE_INT8:
284	elementSize = sizeof(PRInt8);
285	break;
286	case nsIDataType::VTYPE_INT16:
287	elementSize = sizeof(PRInt16);
288	break;
289	case nsIDataType::VTYPE_INT32:
290	elementSize = sizeof(PRInt32);
291	break;
292	case nsIDataType::VTYPE_INT64:
293	elementSize = sizeof(PRInt64);
294	break;
295	case nsIDataType::VTYPE_UINT8:
296	elementSize = sizeof(PRUint8);
297	break;
298	case nsIDataType::VTYPE_UINT16:
299	elementSize = sizeof(PRUint16);
300	break;
301	case nsIDataType::VTYPE_UINT32:
302	elementSize = sizeof(PRUint32);
303	break;
304	case nsIDataType::VTYPE_UINT64:
305	elementSize = sizeof(PRUint64);
306	break;
307	case nsIDataType::VTYPE_FLOAT:
308	elementSize = sizeof(float);
309	break;
310	case nsIDataType::VTYPE_DOUBLE:
311	elementSize = sizeof(double);
312	break;
313	case nsIDataType::VTYPE_BOOL:
314	elementSize = sizeof(PRBool);
315	break;
316	case nsIDataType::VTYPE_CHAR:
317	elementSize = sizeof(char);
318	break;
319	case nsIDataType::VTYPE_WCHAR:
320	elementSize = sizeof(PRUnichar);
321	break;
322
323	// XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
324	case nsIDataType::VTYPE_ID:
325	case nsIDataType::VTYPE_CHAR_STR:
326	case nsIDataType::VTYPE_WCHAR_STR:
327	case nsIDataType::VTYPE_INTERFACE:
328	case nsIDataType::VTYPE_INTERFACE_IS:
329	elementSize = sizeof(void*);
330	break;
331
332	// The rest are illegal.
333	case nsIDataType::VTYPE_ASTRING:
334	case nsIDataType::VTYPE_DOMSTRING:
335	case nsIDataType::VTYPE_UTF8STRING:
336	case nsIDataType::VTYPE_CSTRING:
337	case nsIDataType::VTYPE_STRING_SIZE_IS:
338	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
339	case nsIDataType::VTYPE_VOID:
340	case nsIDataType::VTYPE_ARRAY:
341	case nsIDataType::VTYPE_EMPTY_ARRAY:
342	case nsIDataType::VTYPE_EMPTY:
343	default:
344	NS_ERROR("bad type in array!");
345	return NS_ERROR_CANNOT_CONVERT_DATA;
346	}
347
348
349	// Alloc the u.array.
350
351	allocSize = inCount * elementSize;
352	*outValue = nsMemory::Alloc(allocSize);
353	if(!*outValue)
354	return NS_ERROR_OUT_OF_MEMORY;
355
356	// Clone the elements.
357
358	switch(inType)
359	{
360	case nsIDataType::VTYPE_INT8:
361	case nsIDataType::VTYPE_INT16:
362	case nsIDataType::VTYPE_INT32:
363	case nsIDataType::VTYPE_INT64:
364	case nsIDataType::VTYPE_UINT8:
365	case nsIDataType::VTYPE_UINT16:
366	case nsIDataType::VTYPE_UINT32:
367	case nsIDataType::VTYPE_UINT64:
368	case nsIDataType::VTYPE_FLOAT:
369	case nsIDataType::VTYPE_DOUBLE:
370	case nsIDataType::VTYPE_BOOL:
371	case nsIDataType::VTYPE_CHAR:
372	case nsIDataType::VTYPE_WCHAR:
373	memcpy(*outValue, inValue, allocSize);
374	break;
375
376	case nsIDataType::VTYPE_INTERFACE_IS:
377	if(outIID)
378	outIID = inIID;
379	// fall through...
380	case nsIDataType::VTYPE_INTERFACE:
381	{
382	memcpy(*outValue, inValue, allocSize);
383
384	nsISupports p = (nsISupports) *outValue;
385	for(i = inCount; i > 0; p++, i--)
386	if(*p)
387	(*p)->AddRef();
388	break;
389	}
390
391	// XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
392	case nsIDataType::VTYPE_ID:
393	{
394	nsID inp = (nsID) inValue;
395	nsID outp = (nsID) *outValue;
396	for(i = inCount; i > 0; i--)
397	{
398	nsID* idp = *(inp++);
399	if(idp)
400	{
401	if(nsnull == ((outp++) = (nsID)
402	nsMemory::Clone((char*)idp, sizeof(nsID))))
403	goto bad;
404	}
405	else
406	*(outp++) = nsnull;
407	allocatedValueCount++;
408	}
409	break;
410	}
411
412	case nsIDataType::VTYPE_CHAR_STR:
413	{
414	char inp = (char) inValue;
415	char outp = (char) *outValue;
416	for(i = inCount; i > 0; i--)
417	{
418	char* str = *(inp++);
419	if(str)
420	{
421	if(nsnull == ((outp++) = (char)
422	nsMemory::Clone(str, (strlen(str)+1)*sizeof(char))))
423	goto bad;
424	}
425	else
426	*(outp++) = nsnull;
427	allocatedValueCount++;
428	}
429	break;
430	}
431
432	case nsIDataType::VTYPE_WCHAR_STR:
433	{
434	PRUnichar inp = (PRUnichar) inValue;
435	PRUnichar outp = (PRUnichar) *outValue;
436	for(i = inCount; i > 0; i--)
437	{
438	PRUnichar* str = *(inp++);
439	if(str)
440	{
441	if(nsnull == ((outp++) = (PRUnichar)
442	nsMemory::Clone(str,
443	(nsCRT::strlen(str)+1)*sizeof(PRUnichar))))
444	goto bad;
445	}
446	else
447	*(outp++) = nsnull;
448	allocatedValueCount++;
449	}
450	break;
451	}
452
453	// The rest are illegal.
454	case nsIDataType::VTYPE_VOID:
455	case nsIDataType::VTYPE_ARRAY:
456	case nsIDataType::VTYPE_EMPTY_ARRAY:
457	case nsIDataType::VTYPE_EMPTY:
458	case nsIDataType::VTYPE_ASTRING:
459	case nsIDataType::VTYPE_DOMSTRING:
460	case nsIDataType::VTYPE_UTF8STRING:
461	case nsIDataType::VTYPE_CSTRING:
462	case nsIDataType::VTYPE_STRING_SIZE_IS:
463	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
464	default:
465	NS_ERROR("bad type in array!");
466	return NS_ERROR_CANNOT_CONVERT_DATA;
467	}
468
469	*outType = inType;
470	*outCount = inCount;
471	return NS_OK;
472
473	bad:
474	if(*outValue)
475	{
476	char p = (char) *outValue;
477	for(i = allocatedValueCount; i > 0; p++, i--)
478	if(*p)
479	nsMemory::Free(*p);
480	nsMemory::Free((char)outValue);
481	*outValue = nsnull;
482	}
483	return rv;
484	}
485
486	/***************************************************************************/
487
488	#define TRIVIAL_DATA_CONVERTER(type_, data_, member_, retval_) \
489	if(data_.mType == nsIDataType :: type_) { \
490	*retval_ = data_.u.member_; \
491	return NS_OK; \
492	}
493
494	#define NUMERIC_CONVERSION_METHOD_BEGIN(type_, Ctype_, name_) \
495	/* static */ nsresult \
496	nsVariant::ConvertTo##name_ (const nsDiscriminatedUnion& data, \
497	Ctype_ *_retval) \
498	{ \
499	TRIVIAL_DATA_CONVERTER(type_, data, m##name_##Value, _retval) \
500	nsDiscriminatedUnion tempData; \
501	nsVariant::Initialize(&tempData); \
502	nsresult rv = ToManageableNumber(data, &tempData); \
503	/* */ \
504	/* NOTE: rv may indicate a success code that we want to preserve */ \
505	/* For the final return. So all the return cases below should return */ \
506	/* this rv when indicating success. */ \
507	/* */ \
508	if(NS_FAILED(rv)) \
509	return rv; \
510	switch(tempData.mType) \
511	{
512
513	#define CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(Ctype_) \
514	case nsIDataType::VTYPE_INT32: \
515	*_retval = ( Ctype_ ) tempData.u.mInt32Value; \
516	return rv;
517
518	#define CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(Ctype_, min_, max_) \
519	case nsIDataType::VTYPE_INT32: \
520	{ \
521	PRInt32 value = tempData.u.mInt32Value; \
522	if(value < min_ \|\| value > max_) \
523	return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
524	*_retval = ( Ctype_ ) value; \
525	return rv; \
526	}
527
528	#define CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(Ctype_) \
529	case nsIDataType::VTYPE_UINT32: \
530	*_retval = ( Ctype_ ) tempData.u.mUint32Value; \
531	return rv;
532
533	#define CASE__NUMERIC_CONVERSION_UINT32_MAX(Ctype_, max_) \
534	case nsIDataType::VTYPE_UINT32: \
535	{ \
536	PRUint32 value = tempData.u.mUint32Value; \
537	if(value > max_) \
538	return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
539	*_retval = ( Ctype_ ) value; \
540	return rv; \
541	}
542
543	#define CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(Ctype_) \
544	case nsIDataType::VTYPE_DOUBLE: \
545	*_retval = ( Ctype_ ) tempData.u.mDoubleValue; \
546	return rv;
547
548	#define CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX(Ctype_, min_, max_) \
549	case nsIDataType::VTYPE_DOUBLE: \
550	{ \
551	double value = tempData.u.mDoubleValue; \
552	if(value < min_ \|\| value > max_) \
553	return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
554	*_retval = ( Ctype_ ) value; \
555	return rv; \
556	}
557
558	#define CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(Ctype_, min_, max_) \
559	case nsIDataType::VTYPE_DOUBLE: \
560	{ \
561	double value = tempData.u.mDoubleValue; \
562	if(value < min_ \|\| value > max_) \
563	return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
564	*_retval = ( Ctype_ ) value; \
565	return (0.0 == fmod(value,1.0)) ? \
566	rv : NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA; \
567	}
568
569	#define CASES__NUMERIC_CONVERSION_NORMAL(Ctype_, min_, max_) \
570	CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(Ctype_, min_, max_) \
571	CASE__NUMERIC_CONVERSION_UINT32_MAX(Ctype_, max_) \
572	CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(Ctype_, min_, max_)
573
574	#define NUMERIC_CONVERSION_METHOD_END \
575	default: \
576	NS_ERROR("bad type returned from ToManageableNumber"); \
577	return NS_ERROR_CANNOT_CONVERT_DATA; \
578	} \
579	}
580
581	#define NUMERIC_CONVERSION_METHOD_NORMAL(type_, Ctype_, name_, min_, max_) \
582	NUMERIC_CONVERSION_METHOD_BEGIN(type_, Ctype_, name_) \
583	CASES__NUMERIC_CONVERSION_NORMAL(Ctype_, min_, max_) \
584	NUMERIC_CONVERSION_METHOD_END
585
586	/***************************************************************************/
587	// These expand into full public methods...
588
589	NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_INT8, PRUint8, Int8, (-127-1), 127)
590	NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_INT16, PRInt16, Int16, (-32767-1), 32767)
591
592	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_INT32, PRInt32, Int32)
593	CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(PRInt32)
594	CASE__NUMERIC_CONVERSION_UINT32_MAX(PRInt32, 2147483647)
595	CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(PRInt32, (-2147483647-1), 2147483647)
596	NUMERIC_CONVERSION_METHOD_END
597
598	NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_UINT8, PRUint8, Uint8, 0, 255)
599	NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_UINT16, PRUint16, Uint16, 0, 65535)
600
601	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_UINT32, PRUint32, Uint32)
602	CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(PRUint32, 0, 2147483647)
603	CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(PRUint32)
604	CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(PRUint32, 0, 4294967295U)
605	NUMERIC_CONVERSION_METHOD_END
606
607	// XXX toFloat convertions need to be fixed!
608	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_FLOAT, float, Float)
609	CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(float)
610	CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(float)
611	CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(float)
612	NUMERIC_CONVERSION_METHOD_END
613
614	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_DOUBLE, double, Double)
615	CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(double)
616	CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(double)
617	CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(double)
618	NUMERIC_CONVERSION_METHOD_END
619
620	// XXX toChar convertions need to be fixed!
621	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_CHAR, char, Char)
622	CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(char)
623	CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(char)
624	CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(char)
625	NUMERIC_CONVERSION_METHOD_END
626
627	// XXX toWChar convertions need to be fixed!
628	NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_WCHAR, PRUnichar, WChar)
629	CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(PRUnichar)
630	CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(PRUnichar)
631	CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(PRUnichar)
632	NUMERIC_CONVERSION_METHOD_END
633
634	#undef NUMERIC_CONVERSION_METHOD_BEGIN
635	#undef CASE__NUMERIC_CONVERSION_INT32_JUST_CAST
636	#undef CASE__NUMERIC_CONVERSION_INT32_MIN_MAX
637	#undef CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST
638	#undef CASE__NUMERIC_CONVERSION_UINT32_MIN_MAX
639	#undef CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST
640	#undef CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX
641	#undef CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT
642	#undef CASES__NUMERIC_CONVERSION_NORMAL
643	#undef NUMERIC_CONVERSION_METHOD_END
644	#undef NUMERIC_CONVERSION_METHOD_NORMAL
645
646	/***************************************************************************/
647
648	// Just leverage a numeric converter for bool (but restrict the values).
649	// XXX Is this really what we want to do?
650
651	/* static */ nsresult
652	nsVariant::ConvertToBool(const nsDiscriminatedUnion& data, PRBool *_retval)
653	{
654	TRIVIAL_DATA_CONVERTER(VTYPE_BOOL, data, mBoolValue, _retval)
655
656	double val;
657	nsresult rv = nsVariant::ConvertToDouble(data, &val);
658	if(NS_FAILED(rv))
659	return rv;
660	*_retval = 0.0 != val;
661	return rv;
662	}
663
664	/***************************************************************************/
665
666	/* static */ nsresult
667	nsVariant::ConvertToInt64(const nsDiscriminatedUnion& data, PRInt64 *_retval)
668	{
669	TRIVIAL_DATA_CONVERTER(VTYPE_INT64, data, mInt64Value, _retval)
670	TRIVIAL_DATA_CONVERTER(VTYPE_UINT64, data, mUint64Value, _retval)
671
672	nsDiscriminatedUnion tempData;
673	nsVariant::Initialize(&tempData);
674	nsresult rv = ToManageableNumber(data, &tempData);
675	if(NS_FAILED(rv))
676	return rv;
677	switch(tempData.mType)
678	{
679	case nsIDataType::VTYPE_INT32:
680	LL_I2L(*_retval, tempData.u.mInt32Value);
681	return rv;
682	case nsIDataType::VTYPE_UINT32:
683	LL_UI2L(*_retval, tempData.u.mUint32Value);
684	return rv;
685	case nsIDataType::VTYPE_DOUBLE:
686	// XXX should check for data loss here!
687	LL_D2L(*_retval, tempData.u.mDoubleValue);
688	return rv;
689	default:
690	NS_ERROR("bad type returned from ToManageableNumber");
691	return NS_ERROR_CANNOT_CONVERT_DATA;
692	}
693	}
694
695	/* static */ nsresult
696	nsVariant::ConvertToUint64(const nsDiscriminatedUnion& data, PRUint64 *_retval)
697	{
698	return nsVariant::ConvertToInt64(data, (PRInt64 *)_retval);
699	}
700
701	/***************************************************************************/
702
703	static PRBool String2ID(const nsDiscriminatedUnion& data, nsID* pid)
704	{
705	nsAutoString tempString;
706	nsAString* pString;
707
708	switch(data.mType)
709	{
710	case nsIDataType::VTYPE_CHAR_STR:
711	case nsIDataType::VTYPE_STRING_SIZE_IS:
712	return pid->Parse(data.u.str.mStringValue);
713	case nsIDataType::VTYPE_CSTRING:
714	return pid->Parse(PromiseFlatCString(*data.u.mCStringValue).get());
715	case nsIDataType::VTYPE_UTF8STRING:
716	return pid->Parse(PromiseFlatUTF8String(*data.u.mUTF8StringValue).get());
717	case nsIDataType::VTYPE_ASTRING:
718	case nsIDataType::VTYPE_DOMSTRING:
719	pString = data.u.mAStringValue;
720	break;
721	case nsIDataType::VTYPE_WCHAR_STR:
722	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
723	tempString.Assign(data.u.wstr.mWStringValue);
724	pString = &tempString;
725	break;
726	default:
727	NS_ERROR("bad type in call to String2ID");
728	return PR_FALSE;
729	}
730
731	char* pChars = ToNewCString(*pString);
732	if(!pChars)
733	return PR_FALSE;
734	PRBool result = pid->Parse(pChars);
735	nsMemory::Free(pChars);
736	return result;
737	}
738
739	/* static */ nsresult
740	nsVariant::ConvertToID(const nsDiscriminatedUnion& data, nsID * _retval)
741	{
742	nsID id;
743
744	switch(data.mType)
745	{
746	case nsIDataType::VTYPE_ID:
747	*_retval = data.u.mIDValue;
748	return NS_OK;
749	case nsIDataType::VTYPE_INTERFACE:
750	*_retval = NS_GET_IID(nsISupports);
751	return NS_OK;
752	case nsIDataType::VTYPE_INTERFACE_IS:
753	*_retval = data.u.iface.mInterfaceID;
754	return NS_OK;
755	case nsIDataType::VTYPE_ASTRING:
756	case nsIDataType::VTYPE_DOMSTRING:
757	case nsIDataType::VTYPE_UTF8STRING:
758	case nsIDataType::VTYPE_CSTRING:
759	case nsIDataType::VTYPE_CHAR_STR:
760	case nsIDataType::VTYPE_WCHAR_STR:
761	case nsIDataType::VTYPE_STRING_SIZE_IS:
762	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
763	if(!String2ID(data, &id))
764	return NS_ERROR_CANNOT_CONVERT_DATA;
765	*_retval = id;
766	return NS_OK;
767	default:
768	return NS_ERROR_CANNOT_CONVERT_DATA;
769	}
770	}
771
772	/***************************************************************************/
773
774	static nsresult ToString(const nsDiscriminatedUnion& data,
775	nsACString & outString)
776	{
777	char* ptr;
778
779	switch(data.mType)
780	{
781	// all the stuff we don't handle...
782	case nsIDataType::VTYPE_ASTRING:
783	case nsIDataType::VTYPE_DOMSTRING:
784	case nsIDataType::VTYPE_UTF8STRING:
785	case nsIDataType::VTYPE_CSTRING:
786	case nsIDataType::VTYPE_CHAR_STR:
787	case nsIDataType::VTYPE_WCHAR_STR:
788	case nsIDataType::VTYPE_STRING_SIZE_IS:
789	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
790	case nsIDataType::VTYPE_WCHAR:
791	NS_ERROR("ToString being called for a string type - screwy logic!");
792	// fall through...
793
794	// XXX We might want stringified versions of these... ???
795
796	case nsIDataType::VTYPE_VOID:
797	case nsIDataType::VTYPE_EMPTY_ARRAY:
798	case nsIDataType::VTYPE_EMPTY:
799	case nsIDataType::VTYPE_ARRAY:
800	case nsIDataType::VTYPE_INTERFACE:
801	case nsIDataType::VTYPE_INTERFACE_IS:
802	default:
803	return NS_ERROR_CANNOT_CONVERT_DATA;
804
805	// nsID has its own text formater.
806
807	case nsIDataType::VTYPE_ID:
808	ptr = data.u.mIDValue.ToString();
809	if(!ptr)
810	return NS_ERROR_OUT_OF_MEMORY;
811	outString.Assign(ptr);
812	nsMemory::Free(ptr);
813	return NS_OK;
814
815	// the rest can be PR_smprintf'd and use common code.
816
817	#define CASE__SMPRINTF_NUMBER(type_, format_, cast_, member_) \
818	case nsIDataType :: type_ : \
819	ptr = PR_smprintf( format_ , (cast_) data.u. member_ ); \
820	break;
821
822	CASE__SMPRINTF_NUMBER(VTYPE_INT8, "%d", int, mInt8Value)
823	CASE__SMPRINTF_NUMBER(VTYPE_INT16, "%d", int, mInt16Value)
824	CASE__SMPRINTF_NUMBER(VTYPE_INT32, "%d", int, mInt32Value)
825	CASE__SMPRINTF_NUMBER(VTYPE_INT64, "%lld", PRInt64, mInt64Value)
826
827	CASE__SMPRINTF_NUMBER(VTYPE_UINT8, "%u", unsigned, mUint8Value)
828	CASE__SMPRINTF_NUMBER(VTYPE_UINT16, "%u", unsigned, mUint16Value)
829	CASE__SMPRINTF_NUMBER(VTYPE_UINT32, "%u", unsigned, mUint32Value)
830	CASE__SMPRINTF_NUMBER(VTYPE_UINT64, "%llu", PRInt64, mUint64Value)
831
832	CASE__SMPRINTF_NUMBER(VTYPE_FLOAT, "%f", float, mFloatValue)
833	CASE__SMPRINTF_NUMBER(VTYPE_DOUBLE, "%f", double, mDoubleValue)
834
835	// XXX Would we rather print "true" / "false" ?
836	CASE__SMPRINTF_NUMBER(VTYPE_BOOL, "%d", int, mBoolValue)
837
838	CASE__SMPRINTF_NUMBER(VTYPE_CHAR, "%c", char, mCharValue)
839
840	#undef CASE__SMPRINTF_NUMBER
841	}
842
843	if(!ptr)
844	return NS_ERROR_OUT_OF_MEMORY;
845	outString.Assign(ptr);
846	PR_smprintf_free(ptr);
847	return NS_OK;
848	}
849
850	/* static */ nsresult
851	nsVariant::ConvertToAString(const nsDiscriminatedUnion& data,
852	nsAString & _retval)
853	{
854	switch(data.mType)
855	{
856	case nsIDataType::VTYPE_ASTRING:
857	case nsIDataType::VTYPE_DOMSTRING:
858	_retval.Assign(*data.u.mAStringValue);
859	return NS_OK;
860	case nsIDataType::VTYPE_CSTRING:
861	CopyASCIItoUCS2(*data.u.mCStringValue, _retval);
862	return NS_OK;
863	case nsIDataType::VTYPE_UTF8STRING:
864	CopyUTF8toUTF16(*data.u.mUTF8StringValue, _retval);
865	return NS_OK;
866	case nsIDataType::VTYPE_CHAR_STR:
867	CopyASCIItoUTF16(data.u.str.mStringValue, _retval);
868	return NS_OK;
869	case nsIDataType::VTYPE_WCHAR_STR:
870	_retval.Assign(data.u.wstr.mWStringValue);
871	return NS_OK;
872	case nsIDataType::VTYPE_STRING_SIZE_IS:
873	CopyASCIItoUCS2(nsDependentCString(data.u.str.mStringValue,
874	data.u.str.mStringLength),
875	_retval);
876	return NS_OK;
877	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
878	_retval.Assign(data.u.wstr.mWStringValue, data.u.wstr.mWStringLength);
879	return NS_OK;
880	case nsIDataType::VTYPE_WCHAR:
881	_retval.Assign(data.u.mWCharValue);
882	return NS_OK;
883	default:
884	{
885	nsCAutoString tempCString;
886	nsresult rv = ToString(data, tempCString);
887	if(NS_FAILED(rv))
888	return rv;
889	CopyASCIItoUTF16(tempCString, _retval);
890	return NS_OK;
891	}
892	}
893	}
894
895	/* static */ nsresult
896	nsVariant::ConvertToACString(const nsDiscriminatedUnion& data,
897	nsACString & _retval)
898	{
899	switch(data.mType)
900	{
901	case nsIDataType::VTYPE_ASTRING:
902	case nsIDataType::VTYPE_DOMSTRING:
903	CopyUCS2toASCII(*data.u.mAStringValue, _retval);
904	return NS_OK;
905	case nsIDataType::VTYPE_CSTRING:
906	_retval.Assign(*data.u.mCStringValue);
907	return NS_OK;
908	case nsIDataType::VTYPE_UTF8STRING:
909	// XXX This is an extra copy that should be avoided
910	// once Jag lands support for UTF8String and associated
911	// conversion methods.
912	CopyUCS2toASCII(NS_ConvertUTF8toUCS2(*data.u.mUTF8StringValue),
913	_retval);
914	return NS_OK;
915	case nsIDataType::VTYPE_CHAR_STR:
916	_retval.Assign(*data.u.str.mStringValue);
917	return NS_OK;
918	case nsIDataType::VTYPE_WCHAR_STR:
919	CopyUCS2toASCII(nsDependentString(data.u.wstr.mWStringValue),
920	_retval);
921	return NS_OK;
922	case nsIDataType::VTYPE_STRING_SIZE_IS:
923	_retval.Assign(data.u.str.mStringValue, data.u.str.mStringLength);
924	return NS_OK;
925	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
926	CopyUCS2toASCII(nsDependentString(data.u.wstr.mWStringValue,
927	data.u.wstr.mWStringLength), _retval);
928	return NS_OK;
929	case nsIDataType::VTYPE_WCHAR:
930	{
931	const PRUnichar* str = &data.u.mWCharValue;
932	CopyUCS2toASCII(Substring(str, str + 1), _retval);
933	return NS_OK;
934	}
935	default:
936	return ToString(data, _retval);
937	}
938	}
939
940	/* static */ nsresult
941	nsVariant::ConvertToAUTF8String(const nsDiscriminatedUnion& data,
942	nsAUTF8String & _retval)
943	{
944	switch(data.mType)
945	{
946	case nsIDataType::VTYPE_ASTRING:
947	case nsIDataType::VTYPE_DOMSTRING:
948	CopyUTF16toUTF8(*data.u.mAStringValue, _retval);
949	return NS_OK;
950	case nsIDataType::VTYPE_CSTRING:
951	// XXX Extra copy, can be removed if we're sure CSTRING can
952	// only contain ASCII.
953	CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(*data.u.mCStringValue),
954	_retval);
955	return NS_OK;
956	case nsIDataType::VTYPE_UTF8STRING:
957	_retval.Assign(*data.u.mUTF8StringValue);
958	return NS_OK;
959	case nsIDataType::VTYPE_CHAR_STR:
960	// XXX Extra copy, can be removed if we're sure CHAR_STR can
961	// only contain ASCII.
962	CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(data.u.str.mStringValue),
963	_retval);
964	return NS_OK;
965	case nsIDataType::VTYPE_WCHAR_STR:
966	CopyUTF16toUTF8(data.u.wstr.mWStringValue, _retval);
967	return NS_OK;
968	case nsIDataType::VTYPE_STRING_SIZE_IS:
969	// XXX Extra copy, can be removed if we're sure CHAR_STR can
970	// only contain ASCII.
971	CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(
972	nsDependentCString(data.u.str.mStringValue,
973	data.u.str.mStringLength)), _retval);
974	return NS_OK;
975	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
976	CopyUTF16toUTF8(nsDependentString(data.u.wstr.mWStringValue,
977	data.u.wstr.mWStringLength),
978	_retval);
979	return NS_OK;
980	case nsIDataType::VTYPE_WCHAR:
981	{
982	const PRUnichar* str = &data.u.mWCharValue;
983	CopyUTF16toUTF8(Substring(str, str + 1), _retval);
984	return NS_OK;
985	}
986	default:
987	{
988	nsCAutoString tempCString;
989	nsresult rv = ToString(data, tempCString);
990	if(NS_FAILED(rv))
991	return rv;
992	// XXX Extra copy, can be removed if we're sure tempCString can
993	// only contain ASCII.
994	CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(tempCString), _retval);
995	return NS_OK;
996	}
997	}
998	}
999
1000	/* static */ nsresult
1001	nsVariant::ConvertToString(const nsDiscriminatedUnion& data, char **_retval)
1002	{
1003	PRUint32 ignored;
1004	return nsVariant::ConvertToStringWithSize(data, &ignored, _retval);
1005	}
1006
1007	/* static */ nsresult
1008	nsVariant::ConvertToWString(const nsDiscriminatedUnion& data, PRUnichar **_retval)
1009	{
1010	PRUint32 ignored;
1011	return nsVariant::ConvertToWStringWithSize(data, &ignored, _retval);
1012	}
1013
1014	/* static */ nsresult
1015	nsVariant::ConvertToStringWithSize(const nsDiscriminatedUnion& data,
1016	PRUint32 size, char *str)
1017	{
1018	nsAutoString tempString;
1019	nsCAutoString tempCString;
1020	nsresult rv;
1021
1022	switch(data.mType)
1023	{
1024	case nsIDataType::VTYPE_ASTRING:
1025	case nsIDataType::VTYPE_DOMSTRING:
1026	*size = data.u.mAStringValue->Length();
1027	str = ToNewCString(data.u.mAStringValue);
1028	break;
1029	case nsIDataType::VTYPE_CSTRING:
1030	*size = data.u.mCStringValue->Length();
1031	str = ToNewCString(data.u.mCStringValue);
1032	break;
1033	case nsIDataType::VTYPE_UTF8STRING:
1034	{
1035	// XXX This is doing 1 extra copy. Need to fix this
1036	// when Jag lands UTF8String
1037	// we want:
1038	// size = data.mUTF8StringValue->Length();
1039	// str = ToNewCString(data.mUTF8StringValue);
1040	// But this will have to do for now.
1041	NS_ConvertUTF8toUCS2 tempString(*data.u.mUTF8StringValue);
1042	*size = tempString.Length();
1043	*str = ToNewCString(tempString);
1044	break;
1045	}
1046	case nsIDataType::VTYPE_CHAR_STR:
1047	{
1048	nsDependentCString cString(data.u.str.mStringValue);
1049	*size = cString.Length();
1050	*str = ToNewCString(cString);
1051	break;
1052	}
1053	case nsIDataType::VTYPE_WCHAR_STR:
1054	{
1055	nsDependentString string(data.u.wstr.mWStringValue);
1056	*size = string.Length();
1057	*str = ToNewCString(string);
1058	break;
1059	}
1060	case nsIDataType::VTYPE_STRING_SIZE_IS:
1061	{
1062	nsDependentCString cString(data.u.str.mStringValue,
1063	data.u.str.mStringLength);
1064	*size = cString.Length();
1065	*str = ToNewCString(cString);
1066	break;
1067	}
1068	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
1069	{
1070	nsDependentString string(data.u.wstr.mWStringValue,
1071	data.u.wstr.mWStringLength);
1072	*size = string.Length();
1073	*str = ToNewCString(string);
1074	break;
1075	}
1076	case nsIDataType::VTYPE_WCHAR:
1077	tempString.Assign(data.u.mWCharValue);
1078	*size = tempString.Length();
1079	*str = ToNewCString(tempString);
1080	break;
1081	default:
1082	rv = ToString(data, tempCString);
1083	if(NS_FAILED(rv))
1084	return rv;
1085	*size = tempCString.Length();
1086	*str = ToNewCString(tempCString);
1087	break;
1088	}
1089
1090	return *str ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1091	}
1092	/* static */ nsresult
1093	nsVariant::ConvertToWStringWithSize(const nsDiscriminatedUnion& data,
1094	PRUint32 size, PRUnichar *str)
1095	{
1096	nsAutoString tempString;
1097	nsCAutoString tempCString;
1098	nsresult rv;
1099
1100	switch(data.mType)
1101	{
1102	case nsIDataType::VTYPE_ASTRING:
1103	case nsIDataType::VTYPE_DOMSTRING:
1104	*size = data.u.mAStringValue->Length();
1105	str = ToNewUnicode(data.u.mAStringValue);
1106	break;
1107	case nsIDataType::VTYPE_CSTRING:
1108	*size = data.u.mCStringValue->Length();
1109	str = ToNewUnicode(data.u.mCStringValue);
1110	break;
1111	case nsIDataType::VTYPE_UTF8STRING:
1112	{
1113	str = UTF8ToNewUnicode(data.u.mUTF8StringValue, size);
1114	break;
1115	}
1116	case nsIDataType::VTYPE_CHAR_STR:
1117	{
1118	nsDependentCString cString(data.u.str.mStringValue);
1119	*size = cString.Length();
1120	*str = ToNewUnicode(cString);
1121	break;
1122	}
1123	case nsIDataType::VTYPE_WCHAR_STR:
1124	{
1125	nsDependentString string(data.u.wstr.mWStringValue);
1126	*size = string.Length();
1127	*str = ToNewUnicode(string);
1128	break;
1129	}
1130	case nsIDataType::VTYPE_STRING_SIZE_IS:
1131	{
1132	nsDependentCString cString(data.u.str.mStringValue,
1133	data.u.str.mStringLength);
1134	*size = cString.Length();
1135	*str = ToNewUnicode(cString);
1136	break;
1137	}
1138	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
1139	{
1140	nsDependentString string(data.u.wstr.mWStringValue,
1141	data.u.wstr.mWStringLength);
1142	*size = string.Length();
1143	*str = ToNewUnicode(string);
1144	break;
1145	}
1146	case nsIDataType::VTYPE_WCHAR:
1147	tempString.Assign(data.u.mWCharValue);
1148	*size = tempString.Length();
1149	*str = ToNewUnicode(tempString);
1150	break;
1151	default:
1152	rv = ToString(data, tempCString);
1153	if(NS_FAILED(rv))
1154	return rv;
1155	*size = tempCString.Length();
1156	*str = ToNewUnicode(tempCString);
1157	break;
1158	}
1159
1160	return *str ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1161	}
1162
1163	/* static */ nsresult
1164	nsVariant::ConvertToISupports(const nsDiscriminatedUnion& data,
1165	nsISupports **_retval)
1166	{
1167	switch(data.mType)
1168	{
1169	case nsIDataType::VTYPE_INTERFACE:
1170	case nsIDataType::VTYPE_INTERFACE_IS:
1171	if (data.u.iface.mInterfaceValue) {
1172	return data.u.iface.mInterfaceValue->
1173	QueryInterface(NS_GET_IID(nsISupports), (void**)_retval);
1174	} else {
1175	*_retval = nsnull;
1176	return NS_OK;
1177	}
1178	default:
1179	return NS_ERROR_CANNOT_CONVERT_DATA;
1180	}
1181	}
1182
1183	/* static */ nsresult
1184	nsVariant::ConvertToInterface(const nsDiscriminatedUnion& data, nsIID * *iid,
1185	void * *iface)
1186	{
1187	const nsIID* piid;
1188
1189	switch(data.mType)
1190	{
1191	case nsIDataType::VTYPE_INTERFACE:
1192	piid = &NS_GET_IID(nsISupports);
1193	break;
1194	case nsIDataType::VTYPE_INTERFACE_IS:
1195	piid = &data.u.iface.mInterfaceID;
1196	break;
1197	default:
1198	return NS_ERROR_CANNOT_CONVERT_DATA;
1199	}
1200
1201	iid = (nsIID) nsMemory::Clone(piid, sizeof(nsIID));
1202	if(!*iid)
1203	return NS_ERROR_OUT_OF_MEMORY;
1204
1205	if (data.u.iface.mInterfaceValue) {
1206	return data.u.iface.mInterfaceValue->QueryInterface(*piid, iface);
1207	}
1208
1209	*iface = nsnull;
1210	return NS_OK;
1211	}
1212
1213	/* static */ nsresult
1214	nsVariant::ConvertToArray(const nsDiscriminatedUnion& data, PRUint16 *type,
1215	nsIID* iid, PRUint32 count, void *ptr)
1216	{
1217	// XXX perhaps we'd like to add support for converting each of the various
1218	// types into an array containing one element of that type. We can leverage
1219	// CloneArray to do this if we want to support this.
1220
1221	if(data.mType == nsIDataType::VTYPE_ARRAY)
1222	return CloneArray(data.u.array.mArrayType, &data.u.array.mArrayInterfaceID,
1223	data.u.array.mArrayCount, data.u.array.mArrayValue,
1224	type, iid, count, ptr);
1225	return NS_ERROR_CANNOT_CONVERT_DATA;
1226	}
1227
1228	/***************************************************************************/
1229	// static setter functions...
1230
1231	#define DATA_SETTER_PROLOGUE(data_) \
1232	nsVariant::Cleanup(data_);
1233
1234	#define DATA_SETTER_EPILOGUE(data_, type_) \
1235	data_->mType = nsIDataType :: type_; \
1236	return NS_OK;
1237
1238	#define DATA_SETTER(data_, type_, member_, value_) \
1239	DATA_SETTER_PROLOGUE(data_) \
1240	data_->u.member_ = value_; \
1241	DATA_SETTER_EPILOGUE(data_, type_)
1242
1243	#define DATA_SETTER_WITH_CAST(data_, type_, member_, cast_, value_) \
1244	DATA_SETTER_PROLOGUE(data_) \
1245	data_->u.member_ = cast_ value_; \
1246	DATA_SETTER_EPILOGUE(data_, type_)
1247
1248
1249	/********************************************/
1250
1251	#define CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) \
1252	{ \
1253
1254	#define CASE__SET_FROM_VARIANT_VTYPE__GETTER(member_, name_) \
1255	rv = aValue->GetAs##name_ (&(data->u. member_ ));
1256
1257	#define CASE__SET_FROM_VARIANT_VTYPE__GETTER_CAST(cast_, member_, name_) \
1258	rv = aValue->GetAs##name_ ( cast_ &(data->u. member_ ));
1259
1260	#define CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_) \
1261	if(NS_SUCCEEDED(rv)) \
1262	{ \
1263	data->mType = nsIDataType :: type_ ; \
1264	} \
1265	break; \
1266	}
1267
1268	#define CASE__SET_FROM_VARIANT_TYPE(type_, member_, name_) \
1269	case nsIDataType :: type_ : \
1270	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) \
1271	CASE__SET_FROM_VARIANT_VTYPE__GETTER(member_, name_) \
1272	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_)
1273
1274	#define CASE__SET_FROM_VARIANT_VTYPE_CAST(type_, cast_, member_, name_) \
1275	case nsIDataType :: type_ : \
1276	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) \
1277	CASE__SET_FROM_VARIANT_VTYPE__GETTER_CAST(cast_, member_, name_) \
1278	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_)
1279
1280
1281	/* static */ nsresult
1282	nsVariant::SetFromVariant(nsDiscriminatedUnion* data, nsIVariant* aValue)
1283	{
1284	PRUint16 type;
1285	nsresult rv;
1286
1287	nsVariant::Cleanup(data);
1288
1289	rv = aValue->GetDataType(&type);
1290	if(NS_FAILED(rv))
1291	return rv;
1292
1293	switch(type)
1294	{
1295	CASE__SET_FROM_VARIANT_VTYPE_CAST(VTYPE_INT8, (PRUint8*), mInt8Value,
1296	Int8)
1297	CASE__SET_FROM_VARIANT_TYPE(VTYPE_INT16, mInt16Value, Int16)
1298	CASE__SET_FROM_VARIANT_TYPE(VTYPE_INT32, mInt32Value, Int32)
1299	CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT8, mUint8Value, Uint8)
1300	CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT16, mUint16Value, Uint16)
1301	CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT32, mUint32Value, Uint32)
1302	CASE__SET_FROM_VARIANT_TYPE(VTYPE_FLOAT, mFloatValue, Float)
1303	CASE__SET_FROM_VARIANT_TYPE(VTYPE_DOUBLE, mDoubleValue, Double)
1304	CASE__SET_FROM_VARIANT_TYPE(VTYPE_BOOL , mBoolValue, Bool)
1305	CASE__SET_FROM_VARIANT_TYPE(VTYPE_CHAR, mCharValue, Char)
1306	CASE__SET_FROM_VARIANT_TYPE(VTYPE_WCHAR, mWCharValue, WChar)
1307	CASE__SET_FROM_VARIANT_TYPE(VTYPE_ID, mIDValue, ID)
1308
1309	case nsIDataType::VTYPE_ASTRING:
1310	case nsIDataType::VTYPE_DOMSTRING:
1311	case nsIDataType::VTYPE_WCHAR_STR:
1312	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
1313	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_ASTRING);
1314	data->u.mAStringValue = new nsString();
1315	if(!data->u.mAStringValue)
1316	return NS_ERROR_OUT_OF_MEMORY;
1317	rv = aValue->GetAsAString(*data->u.mAStringValue);
1318	if(NS_FAILED(rv))
1319	delete data->u.mAStringValue;
1320	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ASTRING)
1321
1322	case nsIDataType::VTYPE_CSTRING:
1323	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_CSTRING);
1324	data->u.mCStringValue = new nsCString();
1325	if(!data->u.mCStringValue)
1326	return NS_ERROR_OUT_OF_MEMORY;
1327	rv = aValue->GetAsACString(*data->u.mCStringValue);
1328	if(NS_FAILED(rv))
1329	delete data->u.mCStringValue;
1330	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_CSTRING)
1331
1332	case nsIDataType::VTYPE_UTF8STRING:
1333	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_UTF8STRING);
1334	data->u.mUTF8StringValue = new nsUTF8String();
1335	if(!data->u.mUTF8StringValue)
1336	return NS_ERROR_OUT_OF_MEMORY;
1337	rv = aValue->GetAsAUTF8String(*data->u.mUTF8StringValue);
1338	if(NS_FAILED(rv))
1339	delete data->u.mUTF8StringValue;
1340	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_UTF8STRING)
1341
1342	case nsIDataType::VTYPE_CHAR_STR:
1343	case nsIDataType::VTYPE_STRING_SIZE_IS:
1344	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_STRING_SIZE_IS);
1345	rv = aValue->GetAsStringWithSize(&data->u.str.mStringLength,
1346	&data->u.str.mStringValue);
1347	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_STRING_SIZE_IS)
1348
1349	case nsIDataType::VTYPE_INTERFACE:
1350	case nsIDataType::VTYPE_INTERFACE_IS:
1351	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_INTERFACE_IS);
1352	// XXX This iid handling is ugly!
1353	nsIID* iid;
1354	rv = aValue->GetAsInterface(&iid, (void**)&data->u.iface.mInterfaceValue);
1355	if(NS_SUCCEEDED(rv))
1356	{
1357	data->u.iface.mInterfaceID = *iid;
1358	nsMemory::Free((char*)iid);
1359	}
1360	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_INTERFACE_IS)
1361
1362	case nsIDataType::VTYPE_ARRAY:
1363	CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_ARRAY);
1364	rv = aValue->GetAsArray(&data->u.array.mArrayType,
1365	&data->u.array.mArrayInterfaceID,
1366	&data->u.array.mArrayCount,
1367	&data->u.array.mArrayValue);
1368	CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ARRAY)
1369
1370	case nsIDataType::VTYPE_VOID:
1371	rv = nsVariant::SetToVoid(data);
1372	break;
1373	case nsIDataType::VTYPE_EMPTY_ARRAY:
1374	rv = nsVariant::SetToEmptyArray(data);
1375	break;
1376	case nsIDataType::VTYPE_EMPTY:
1377	rv = nsVariant::SetToEmpty(data);
1378	break;
1379	default:
1380	NS_ERROR("bad type in variant!");
1381	rv = NS_ERROR_FAILURE;
1382	break;
1383	}
1384	return rv;
1385	}
1386
1387	/* static */ nsresult
1388	nsVariant::SetFromInt8(nsDiscriminatedUnion* data, PRUint8 aValue)
1389	{
1390	DATA_SETTER_WITH_CAST(data, VTYPE_INT8, mInt8Value, (PRUint8), aValue)
1391	}
1392	/* static */ nsresult
1393	nsVariant::SetFromInt16(nsDiscriminatedUnion* data, PRInt16 aValue)
1394	{
1395	DATA_SETTER(data, VTYPE_INT16, mInt16Value, aValue)
1396	}
1397	/* static */ nsresult
1398	nsVariant::SetFromInt32(nsDiscriminatedUnion* data, PRInt32 aValue)
1399	{
1400	DATA_SETTER(data, VTYPE_INT32, mInt32Value, aValue)
1401	}
1402	/* static */ nsresult
1403	nsVariant::SetFromInt64(nsDiscriminatedUnion* data, PRInt64 aValue)
1404	{
1405	DATA_SETTER(data, VTYPE_INT64, mInt64Value, aValue)
1406	}
1407	/* static */ nsresult
1408	nsVariant::SetFromUint8(nsDiscriminatedUnion* data, PRUint8 aValue)
1409	{
1410	DATA_SETTER(data, VTYPE_UINT8, mUint8Value, aValue)
1411	}
1412	/* static */ nsresult
1413	nsVariant::SetFromUint16(nsDiscriminatedUnion* data, PRUint16 aValue)
1414	{
1415	DATA_SETTER(data, VTYPE_UINT16, mUint16Value, aValue)
1416	}
1417	/* static */ nsresult
1418	nsVariant::SetFromUint32(nsDiscriminatedUnion* data, PRUint32 aValue)
1419	{
1420	DATA_SETTER(data, VTYPE_UINT32, mUint32Value, aValue)
1421	}
1422	/* static */ nsresult
1423	nsVariant::SetFromUint64(nsDiscriminatedUnion* data, PRUint64 aValue)
1424	{
1425	DATA_SETTER(data, VTYPE_UINT64, mUint64Value, aValue)
1426	}
1427	/* static */ nsresult
1428	nsVariant::SetFromFloat(nsDiscriminatedUnion* data, float aValue)
1429	{
1430	DATA_SETTER(data, VTYPE_FLOAT, mFloatValue, aValue)
1431	}
1432	/* static */ nsresult
1433	nsVariant::SetFromDouble(nsDiscriminatedUnion* data, double aValue)
1434	{
1435	DATA_SETTER(data, VTYPE_DOUBLE, mDoubleValue, aValue)
1436	}
1437	/* static */ nsresult
1438	nsVariant::SetFromBool(nsDiscriminatedUnion* data, PRBool aValue)
1439	{
1440	DATA_SETTER(data, VTYPE_BOOL, mBoolValue, aValue)
1441	}
1442	/* static */ nsresult
1443	nsVariant::SetFromChar(nsDiscriminatedUnion* data, char aValue)
1444	{
1445	DATA_SETTER(data, VTYPE_CHAR, mCharValue, aValue)
1446	}
1447	/* static */ nsresult
1448	nsVariant::SetFromWChar(nsDiscriminatedUnion* data, PRUnichar aValue)
1449	{
1450	DATA_SETTER(data, VTYPE_WCHAR, mWCharValue, aValue)
1451	}
1452	/* static */ nsresult
1453	nsVariant::SetFromID(nsDiscriminatedUnion* data, const nsID & aValue)
1454	{
1455	DATA_SETTER(data, VTYPE_ID, mIDValue, aValue)
1456	}
1457	/* static */ nsresult
1458	nsVariant::SetFromAString(nsDiscriminatedUnion* data, const nsAString & aValue)
1459	{
1460	DATA_SETTER_PROLOGUE(data);
1461	if(!(data->u.mAStringValue = new nsString(aValue)))
1462	return NS_ERROR_OUT_OF_MEMORY;
1463	DATA_SETTER_EPILOGUE(data, VTYPE_ASTRING);
1464	}
1465
1466	/* static */ nsresult
1467	nsVariant::SetFromACString(nsDiscriminatedUnion* data,
1468	const nsACString & aValue)
1469	{
1470	DATA_SETTER_PROLOGUE(data);
1471	if(!(data->u.mCStringValue = new nsCString(aValue)))
1472	return NS_ERROR_OUT_OF_MEMORY;
1473	DATA_SETTER_EPILOGUE(data, VTYPE_CSTRING);
1474	}
1475
1476	/* static */ nsresult
1477	nsVariant::SetFromAUTF8String(nsDiscriminatedUnion* data,
1478	const nsAUTF8String & aValue)
1479	{
1480	DATA_SETTER_PROLOGUE(data);
1481	if(!(data->u.mUTF8StringValue = new nsUTF8String(aValue)))
1482	return NS_ERROR_OUT_OF_MEMORY;
1483	DATA_SETTER_EPILOGUE(data, VTYPE_UTF8STRING);
1484	}
1485
1486	/* static */ nsresult
1487	nsVariant::SetFromString(nsDiscriminatedUnion* data, const char *aValue)
1488	{
1489	DATA_SETTER_PROLOGUE(data);
1490	if(!aValue)
1491	return NS_ERROR_NULL_POINTER;
1492	return SetFromStringWithSize(data, strlen(aValue), aValue);
1493	}
1494	/* static */ nsresult
1495	nsVariant::SetFromWString(nsDiscriminatedUnion* data, const PRUnichar *aValue)
1496	{
1497	DATA_SETTER_PROLOGUE(data);
1498	if(!aValue)
1499	return NS_ERROR_NULL_POINTER;
1500	return SetFromWStringWithSize(data, nsCRT::strlen(aValue), aValue);
1501	}
1502	/* static */ nsresult
1503	nsVariant::SetFromISupports(nsDiscriminatedUnion* data, nsISupports *aValue)
1504	{
1505	return SetFromInterface(data, NS_GET_IID(nsISupports), aValue);
1506	}
1507	/* static */ nsresult
1508	nsVariant::SetFromInterface(nsDiscriminatedUnion* data, const nsIID& iid,
1509	nsISupports *aValue)
1510	{
1511	DATA_SETTER_PROLOGUE(data);
1512	NS_IF_ADDREF(aValue);
1513	data->u.iface.mInterfaceValue = aValue;
1514	data->u.iface.mInterfaceID = iid;
1515	DATA_SETTER_EPILOGUE(data, VTYPE_INTERFACE_IS);
1516	}
1517	/* static */ nsresult
1518	nsVariant::SetFromArray(nsDiscriminatedUnion* data, PRUint16 type,
1519	const nsIID* iid, PRUint32 count, void * aValue)
1520	{
1521	DATA_SETTER_PROLOGUE(data);
1522	if(!aValue \|\| !count)
1523	return NS_ERROR_NULL_POINTER;
1524
1525	nsresult rv = CloneArray(type, iid, count, aValue,
1526	&data->u.array.mArrayType,
1527	&data->u.array.mArrayInterfaceID,
1528	&data->u.array.mArrayCount,
1529	&data->u.array.mArrayValue);
1530	if(NS_FAILED(rv))
1531	return rv;
1532	DATA_SETTER_EPILOGUE(data, VTYPE_ARRAY);
1533	}
1534	/* static */ nsresult
1535	nsVariant::SetFromStringWithSize(nsDiscriminatedUnion* data, PRUint32 size, const char *aValue)
1536	{
1537	DATA_SETTER_PROLOGUE(data);
1538	if(!aValue)
1539	return NS_ERROR_NULL_POINTER;
1540	if(!(data->u.str.mStringValue =
1541	(char) nsMemory::Clone(aValue, (size+1)sizeof(char))))
1542	return NS_ERROR_OUT_OF_MEMORY;
1543	data->u.str.mStringLength = size;
1544	DATA_SETTER_EPILOGUE(data, VTYPE_STRING_SIZE_IS);
1545	}
1546	/* static */ nsresult
1547	nsVariant::SetFromWStringWithSize(nsDiscriminatedUnion* data, PRUint32 size, const PRUnichar *aValue)
1548	{
1549	DATA_SETTER_PROLOGUE(data);
1550	if(!aValue)
1551	return NS_ERROR_NULL_POINTER;
1552	if(!(data->u.wstr.mWStringValue =
1553	(PRUnichar) nsMemory::Clone(aValue, (size+1)sizeof(PRUnichar))))
1554	return NS_ERROR_OUT_OF_MEMORY;
1555	data->u.wstr.mWStringLength = size;
1556	DATA_SETTER_EPILOGUE(data, VTYPE_WSTRING_SIZE_IS);
1557	}
1558	/* static */ nsresult
1559	nsVariant::SetToVoid(nsDiscriminatedUnion* data)
1560	{
1561	DATA_SETTER_PROLOGUE(data);
1562	DATA_SETTER_EPILOGUE(data, VTYPE_VOID);
1563	}
1564	/* static */ nsresult
1565	nsVariant::SetToEmpty(nsDiscriminatedUnion* data)
1566	{
1567	DATA_SETTER_PROLOGUE(data);
1568	DATA_SETTER_EPILOGUE(data, VTYPE_EMPTY);
1569	}
1570	/* static */ nsresult
1571	nsVariant::SetToEmptyArray(nsDiscriminatedUnion* data)
1572	{
1573	DATA_SETTER_PROLOGUE(data);
1574	DATA_SETTER_EPILOGUE(data, VTYPE_EMPTY_ARRAY);
1575	}
1576
1577	/***************************************************************************/
1578
1579	/* static */ nsresult
1580	nsVariant::Initialize(nsDiscriminatedUnion* data)
1581	{
1582	data->mType = nsIDataType::VTYPE_EMPTY;
1583	return NS_OK;
1584	}
1585
1586	/* static */ nsresult
1587	nsVariant::Cleanup(nsDiscriminatedUnion* data)
1588	{
1589	switch(data->mType)
1590	{
1591	case nsIDataType::VTYPE_INT8:
1592	case nsIDataType::VTYPE_INT16:
1593	case nsIDataType::VTYPE_INT32:
1594	case nsIDataType::VTYPE_INT64:
1595	case nsIDataType::VTYPE_UINT8:
1596	case nsIDataType::VTYPE_UINT16:
1597	case nsIDataType::VTYPE_UINT32:
1598	case nsIDataType::VTYPE_UINT64:
1599	case nsIDataType::VTYPE_FLOAT:
1600	case nsIDataType::VTYPE_DOUBLE:
1601	case nsIDataType::VTYPE_BOOL:
1602	case nsIDataType::VTYPE_CHAR:
1603	case nsIDataType::VTYPE_WCHAR:
1604	case nsIDataType::VTYPE_VOID:
1605	case nsIDataType::VTYPE_ID:
1606	break;
1607	case nsIDataType::VTYPE_ASTRING:
1608	case nsIDataType::VTYPE_DOMSTRING:
1609	delete data->u.mAStringValue;
1610	break;
1611	case nsIDataType::VTYPE_CSTRING:
1612	delete data->u.mCStringValue;
1613	break;
1614	case nsIDataType::VTYPE_UTF8STRING:
1615	delete data->u.mUTF8StringValue;
1616	break;
1617	case nsIDataType::VTYPE_CHAR_STR:
1618	case nsIDataType::VTYPE_STRING_SIZE_IS:
1619	nsMemory::Free((char*)data->u.str.mStringValue);
1620	break;
1621	case nsIDataType::VTYPE_WCHAR_STR:
1622	case nsIDataType::VTYPE_WSTRING_SIZE_IS:
1623	nsMemory::Free((char*)data->u.wstr.mWStringValue);
1624	break;
1625	case nsIDataType::VTYPE_INTERFACE:
1626	case nsIDataType::VTYPE_INTERFACE_IS:
1627	NS_IF_RELEASE(data->u.iface.mInterfaceValue);
1628	break;
1629	case nsIDataType::VTYPE_ARRAY:
1630	FreeArray(data);
1631	break;
1632	case nsIDataType::VTYPE_EMPTY_ARRAY:
1633	case nsIDataType::VTYPE_EMPTY:
1634	break;
1635	default:
1636	NS_ERROR("bad type in variant!");
1637	break;
1638	}
1639
1640	data->mType = nsIDataType::VTYPE_EMPTY;
1641	return NS_OK;
1642	}
1643
1644	/***************************************************************************/
1645	/***************************************************************************/
1646	// members...
1647
1648	NS_IMPL_ISUPPORTS2(nsVariant, nsIVariant, nsIWritableVariant)
1649
1650	nsVariant::nsVariant()
1651	: mWritable(PR_TRUE)
1652	{
1653	nsVariant::Initialize(&mData);
1654
1655	#ifdef DEBUG
1656	{
1657	// Assert that the nsIDataType consts match the values #defined in
1658	// xpt_struct.h. Bad things happen somewhere if they don't.
1659	struct THE_TYPES {PRUint16 a; PRUint16 b;};
1660	static const THE_TYPES array[] = {
1661	{nsIDataType::VTYPE_INT8 , TD_INT8 },
1662	{nsIDataType::VTYPE_INT16 , TD_INT16 },
1663	{nsIDataType::VTYPE_INT32 , TD_INT32 },
1664	{nsIDataType::VTYPE_INT64 , TD_INT64 },
1665	{nsIDataType::VTYPE_UINT8 , TD_UINT8 },
1666	{nsIDataType::VTYPE_UINT16 , TD_UINT16 },
1667	{nsIDataType::VTYPE_UINT32 , TD_UINT32 },
1668	{nsIDataType::VTYPE_UINT64 , TD_UINT64 },
1669	{nsIDataType::VTYPE_FLOAT , TD_FLOAT },
1670	{nsIDataType::VTYPE_DOUBLE , TD_DOUBLE },
1671	{nsIDataType::VTYPE_BOOL , TD_BOOL },
1672	{nsIDataType::VTYPE_CHAR , TD_CHAR },
1673	{nsIDataType::VTYPE_WCHAR , TD_WCHAR },
1674	{nsIDataType::VTYPE_VOID , TD_VOID },
1675	{nsIDataType::VTYPE_ID , TD_PNSIID },
1676	{nsIDataType::VTYPE_DOMSTRING , TD_DOMSTRING },
1677	{nsIDataType::VTYPE_CHAR_STR , TD_PSTRING },
1678	{nsIDataType::VTYPE_WCHAR_STR , TD_PWSTRING },
1679	{nsIDataType::VTYPE_INTERFACE , TD_INTERFACE_TYPE },
1680	{nsIDataType::VTYPE_INTERFACE_IS , TD_INTERFACE_IS_TYPE},
1681	{nsIDataType::VTYPE_ARRAY , TD_ARRAY },
1682	{nsIDataType::VTYPE_STRING_SIZE_IS , TD_PSTRING_SIZE_IS },
1683	{nsIDataType::VTYPE_WSTRING_SIZE_IS , TD_PWSTRING_SIZE_IS },
1684	{nsIDataType::VTYPE_UTF8STRING , TD_UTF8STRING },
1685	{nsIDataType::VTYPE_CSTRING , TD_CSTRING },
1686	{nsIDataType::VTYPE_ASTRING , TD_ASTRING }
1687	};
1688	static const int length = sizeof(array)/sizeof(array[0]);
1689	static PRBool inited = PR_FALSE;
1690	if(!inited)
1691	{
1692	for(int i = 0; i < length; i++)
1693	NS_ASSERTION(array[i].a == array[i].b, "bad const declaration");
1694	inited = PR_TRUE;
1695	}
1696	}
1697	#endif
1698	}
1699
1700	nsVariant::~nsVariant()
1701	{
1702	nsVariant::Cleanup(&mData);
1703	}
1704
1705	// For all the data getters we just forward to the static (and sharable)
1706	// 'ConvertTo' functions.
1707
1708	/* readonly attribute PRUint16 dataType; */
1709	NS_IMETHODIMP nsVariant::GetDataType(PRUint16 *aDataType)
1710	{
1711	*aDataType = mData.mType;
1712	return NS_OK;
1713	}
1714
1715	/* PRUint8 getAsInt8 (); */
1716	NS_IMETHODIMP nsVariant::GetAsInt8(PRUint8 *_retval)
1717	{
1718	return nsVariant::ConvertToInt8(mData, _retval);
1719	}
1720
1721	/* PRInt16 getAsInt16 (); */
1722	NS_IMETHODIMP nsVariant::GetAsInt16(PRInt16 *_retval)
1723	{
1724	return nsVariant::ConvertToInt16(mData, _retval);
1725	}
1726
1727	/* PRInt32 getAsInt32 (); */
1728	NS_IMETHODIMP nsVariant::GetAsInt32(PRInt32 *_retval)
1729	{
1730	return nsVariant::ConvertToInt32(mData, _retval);
1731	}
1732
1733	/* PRInt64 getAsInt64 (); */
1734	NS_IMETHODIMP nsVariant::GetAsInt64(PRInt64 *_retval)
1735	{
1736	return nsVariant::ConvertToInt64(mData, _retval);
1737	}
1738
1739	/* PRUint8 getAsUint8 (); */
1740	NS_IMETHODIMP nsVariant::GetAsUint8(PRUint8 *_retval)
1741	{
1742	return nsVariant::ConvertToUint8(mData, _retval);
1743	}
1744
1745	/* PRUint16 getAsUint16 (); */
1746	NS_IMETHODIMP nsVariant::GetAsUint16(PRUint16 *_retval)
1747	{
1748	return nsVariant::ConvertToUint16(mData, _retval);
1749	}
1750
1751	/* PRUint32 getAsUint32 (); */
1752	NS_IMETHODIMP nsVariant::GetAsUint32(PRUint32 *_retval)
1753	{
1754	return nsVariant::ConvertToUint32(mData, _retval);
1755	}
1756
1757	/* PRUint64 getAsUint64 (); */
1758	NS_IMETHODIMP nsVariant::GetAsUint64(PRUint64 *_retval)
1759	{
1760	return nsVariant::ConvertToUint64(mData, _retval);
1761	}
1762
1763	/* float getAsFloat (); */
1764	NS_IMETHODIMP nsVariant::GetAsFloat(float *_retval)
1765	{
1766	return nsVariant::ConvertToFloat(mData, _retval);
1767	}
1768
1769	/* double getAsDouble (); */
1770	NS_IMETHODIMP nsVariant::GetAsDouble(double *_retval)
1771	{
1772	return nsVariant::ConvertToDouble(mData, _retval);
1773	}
1774
1775	/* PRBool getAsBool (); */
1776	NS_IMETHODIMP nsVariant::GetAsBool(PRBool *_retval)
1777	{
1778	return nsVariant::ConvertToBool(mData, _retval);
1779	}
1780
1781	/* char getAsChar (); */
1782	NS_IMETHODIMP nsVariant::GetAsChar(char *_retval)
1783	{
1784	return nsVariant::ConvertToChar(mData, _retval);
1785	}
1786
1787	/* wchar getAsWChar (); */
1788	NS_IMETHODIMP nsVariant::GetAsWChar(PRUnichar *_retval)
1789	{
1790	return nsVariant::ConvertToWChar(mData, _retval);
1791	}
1792
1793	/* [notxpcom] nsresult getAsID (out nsID retval); */
1794	NS_IMETHODIMP_(nsresult) nsVariant::GetAsID(nsID *retval)
1795	{
1796	return nsVariant::ConvertToID(mData, retval);
1797	}
1798
1799	/* AString getAsAString (); */
1800	NS_IMETHODIMP nsVariant::GetAsAString(nsAString & _retval)
1801	{
1802	return nsVariant::ConvertToAString(mData, _retval);
1803	}
1804
1805	/* DOMString getAsDOMString (); */
1806	NS_IMETHODIMP nsVariant::GetAsDOMString(nsAString & _retval)
1807	{
1808	// A DOMString maps to an AString internally, so we can re-use
1809	// ConvertToAString here.
1810	return nsVariant::ConvertToAString(mData, _retval);
1811	}
1812
1813	/* ACString getAsACString (); */
1814	NS_IMETHODIMP nsVariant::GetAsACString(nsACString & _retval)
1815	{
1816	return nsVariant::ConvertToACString(mData, _retval);
1817	}
1818
1819	/* AUTF8String getAsAUTF8String (); */
1820	NS_IMETHODIMP nsVariant::GetAsAUTF8String(nsAUTF8String & _retval)
1821	{
1822	return nsVariant::ConvertToAUTF8String(mData, _retval);
1823	}
1824
1825	/* string getAsString (); */
1826	NS_IMETHODIMP nsVariant::GetAsString(char **_retval)
1827	{
1828	return nsVariant::ConvertToString(mData, _retval);
1829	}
1830
1831	/* wstring getAsWString (); */
1832	NS_IMETHODIMP nsVariant::GetAsWString(PRUnichar **_retval)
1833	{
1834	return nsVariant::ConvertToWString(mData, _retval);
1835	}
1836
1837	/* nsISupports getAsISupports (); */
1838	NS_IMETHODIMP nsVariant::GetAsISupports(nsISupports **_retval)
1839	{
1840	return nsVariant::ConvertToISupports(mData, _retval);
1841	}
1842
1843	/* void getAsInterface (out nsIIDPtr iid, [iid_is (iid), retval] out nsQIResult iface); */
1844	NS_IMETHODIMP nsVariant::GetAsInterface(nsIID * iid, void *iface)
1845	{
1846	return nsVariant::ConvertToInterface(mData, iid, iface);
1847	}
1848
1849	/* [notxpcom] nsresult getAsArray (out PRUint16 type, out nsIID iid, out PRUint32 count, out voidPtr ptr); */
1850	NS_IMETHODIMP_(nsresult) nsVariant::GetAsArray(PRUint16 type, nsIID iid, PRUint32 count, void *ptr)
1851	{
1852	return nsVariant::ConvertToArray(mData, type, iid, count, ptr);
1853	}
1854
1855	/* void getAsStringWithSize (out PRUint32 size, [size_is (size), retval] out string str); */
1856	NS_IMETHODIMP nsVariant::GetAsStringWithSize(PRUint32 size, char *str)
1857	{
1858	return nsVariant::ConvertToStringWithSize(mData, size, str);
1859	}
1860
1861	/* void getAsWStringWithSize (out PRUint32 size, [size_is (size), retval] out wstring str); */
1862	NS_IMETHODIMP nsVariant::GetAsWStringWithSize(PRUint32 size, PRUnichar *str)
1863	{
1864	return nsVariant::ConvertToWStringWithSize(mData, size, str);
1865	}
1866
1867	/***************************************************************************/
1868
1869	/* attribute PRBool writable; */
1870	NS_IMETHODIMP nsVariant::GetWritable(PRBool *aWritable)
1871	{
1872	*aWritable = mWritable;
1873	return NS_OK;
1874	}
1875	NS_IMETHODIMP nsVariant::SetWritable(PRBool aWritable)
1876	{
1877	if(!mWritable && aWritable)
1878	return NS_ERROR_FAILURE;
1879	mWritable = aWritable;
1880	return NS_OK;
1881	}
1882
1883	/***************************************************************************/
1884
1885	// For all the data setters we just forward to the static (and sharable)
1886	// 'SetFrom' functions.
1887
1888	/* void setAsInt8 (in PRUint8 aValue); */
1889	NS_IMETHODIMP nsVariant::SetAsInt8(PRUint8 aValue)
1890	{
1891	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1892	return nsVariant::SetFromInt8(&mData, aValue);
1893	}
1894
1895	/* void setAsInt16 (in PRInt16 aValue); */
1896	NS_IMETHODIMP nsVariant::SetAsInt16(PRInt16 aValue)
1897	{
1898	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1899	return nsVariant::SetFromInt16(&mData, aValue);
1900	}
1901
1902	/* void setAsInt32 (in PRInt32 aValue); */
1903	NS_IMETHODIMP nsVariant::SetAsInt32(PRInt32 aValue)
1904	{
1905	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1906	return nsVariant::SetFromInt32(&mData, aValue);
1907	}
1908
1909	/* void setAsInt64 (in PRInt64 aValue); */
1910	NS_IMETHODIMP nsVariant::SetAsInt64(PRInt64 aValue)
1911	{
1912	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1913	return nsVariant::SetFromInt64(&mData, aValue);
1914	}
1915
1916	/* void setAsUint8 (in PRUint8 aValue); */
1917	NS_IMETHODIMP nsVariant::SetAsUint8(PRUint8 aValue)
1918	{
1919	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1920	return nsVariant::SetFromUint8(&mData, aValue);
1921	}
1922
1923	/* void setAsUint16 (in PRUint16 aValue); */
1924	NS_IMETHODIMP nsVariant::SetAsUint16(PRUint16 aValue)
1925	{
1926	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1927	return nsVariant::SetFromUint16(&mData, aValue);
1928	}
1929
1930	/* void setAsUint32 (in PRUint32 aValue); */
1931	NS_IMETHODIMP nsVariant::SetAsUint32(PRUint32 aValue)
1932	{
1933	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1934	return nsVariant::SetFromUint32(&mData, aValue);
1935	}
1936
1937	/* void setAsUint64 (in PRUint64 aValue); */
1938	NS_IMETHODIMP nsVariant::SetAsUint64(PRUint64 aValue)
1939	{
1940	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1941	return nsVariant::SetFromUint64(&mData, aValue);
1942	}
1943
1944	/* void setAsFloat (in float aValue); */
1945	NS_IMETHODIMP nsVariant::SetAsFloat(float aValue)
1946	{
1947	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1948	return nsVariant::SetFromFloat(&mData, aValue);
1949	}
1950
1951	/* void setAsDouble (in double aValue); */
1952	NS_IMETHODIMP nsVariant::SetAsDouble(double aValue)
1953	{
1954	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1955	return nsVariant::SetFromDouble(&mData, aValue);
1956	}
1957
1958	/* void setAsBool (in PRBool aValue); */
1959	NS_IMETHODIMP nsVariant::SetAsBool(PRBool aValue)
1960	{
1961	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1962	return nsVariant::SetFromBool(&mData, aValue);
1963	}
1964
1965	/* void setAsChar (in char aValue); */
1966	NS_IMETHODIMP nsVariant::SetAsChar(char aValue)
1967	{
1968	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1969	return nsVariant::SetFromChar(&mData, aValue);
1970	}
1971
1972	/* void setAsWChar (in wchar aValue); */
1973	NS_IMETHODIMP nsVariant::SetAsWChar(PRUnichar aValue)
1974	{
1975	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1976	return nsVariant::SetFromWChar(&mData, aValue);
1977	}
1978
1979	/* void setAsID (in nsIDRef aValue); */
1980	NS_IMETHODIMP nsVariant::SetAsID(const nsID & aValue)
1981	{
1982	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1983	return nsVariant::SetFromID(&mData, aValue);
1984	}
1985
1986	/* void setAsAString (in AString aValue); */
1987	NS_IMETHODIMP nsVariant::SetAsAString(const nsAString & aValue)
1988	{
1989	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1990	return nsVariant::SetFromAString(&mData, aValue);
1991	}
1992
1993	/* void setAsDOMString (in DOMString aValue); */
1994	NS_IMETHODIMP nsVariant::SetAsDOMString(const nsAString & aValue)
1995	{
1996	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
1997
1998	// A DOMString maps to an AString internally, so we can re-use
1999	// SetFromAString here.
2000	return nsVariant::SetFromAString(&mData, aValue);
2001	}
2002
2003	/* void setAsACString (in ACString aValue); */
2004	NS_IMETHODIMP nsVariant::SetAsACString(const nsACString & aValue)
2005	{
2006	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2007	return nsVariant::SetFromACString(&mData, aValue);
2008	}
2009
2010	/* void setAsAUTF8String (in AUTF8String aValue); */
2011	NS_IMETHODIMP nsVariant::SetAsAUTF8String(const nsAUTF8String & aValue)
2012	{
2013	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2014	return nsVariant::SetFromAUTF8String(&mData, aValue);
2015	}
2016
2017	/* void setAsString (in string aValue); */
2018	NS_IMETHODIMP nsVariant::SetAsString(const char *aValue)
2019	{
2020	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2021	return nsVariant::SetFromString(&mData, aValue);
2022	}
2023
2024	/* void setAsWString (in wstring aValue); */
2025	NS_IMETHODIMP nsVariant::SetAsWString(const PRUnichar *aValue)
2026	{
2027	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2028	return nsVariant::SetFromWString(&mData, aValue);
2029	}
2030
2031	/* void setAsISupports (in nsISupports aValue); */
2032	NS_IMETHODIMP nsVariant::SetAsISupports(nsISupports *aValue)
2033	{
2034	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2035	return nsVariant::SetFromISupports(&mData, aValue);
2036	}
2037
2038	/* void setAsInterface (in nsIIDRef iid, [iid_is (iid)] in nsQIResult iface); */
2039	NS_IMETHODIMP nsVariant::SetAsInterface(const nsIID & iid, void * iface)
2040	{
2041	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2042	return nsVariant::SetFromInterface(&mData, iid, (nsISupports*)iface);
2043	}
2044
2045	/* [noscript] void setAsArray (in PRUint16 type, in nsIIDPtr iid, in PRUint32 count, in voidPtr ptr); */
2046	NS_IMETHODIMP nsVariant::SetAsArray(PRUint16 type, const nsIID * iid, PRUint32 count, void * ptr)
2047	{
2048	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2049	return nsVariant::SetFromArray(&mData, type, iid, count, ptr);
2050	}
2051
2052	/* void setAsStringWithSize (in PRUint32 size, [size_is (size)] in string str); */
2053	NS_IMETHODIMP nsVariant::SetAsStringWithSize(PRUint32 size, const char *str)
2054	{
2055	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2056	return nsVariant::SetFromStringWithSize(&mData, size, str);
2057	}
2058
2059	/* void setAsWStringWithSize (in PRUint32 size, [size_is (size)] in wstring str); */
2060	NS_IMETHODIMP nsVariant::SetAsWStringWithSize(PRUint32 size, const PRUnichar *str)
2061	{
2062	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2063	return nsVariant::SetFromWStringWithSize(&mData, size, str);
2064	}
2065
2066	/* void setAsVoid (); */
2067	NS_IMETHODIMP nsVariant::SetAsVoid()
2068	{
2069	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2070	return nsVariant::SetToVoid(&mData);
2071	}
2072
2073	/* void setAsEmpty (); */
2074	NS_IMETHODIMP nsVariant::SetAsEmpty()
2075	{
2076	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2077	return nsVariant::SetToEmpty(&mData);
2078	}
2079
2080	/* void setAsEmptyArray (); */
2081	NS_IMETHODIMP nsVariant::SetAsEmptyArray()
2082	{
2083	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2084	return nsVariant::SetToEmptyArray(&mData);
2085	}
2086
2087	/* void setFromVariant (in nsIVariant aValue); */
2088	NS_IMETHODIMP nsVariant::SetFromVariant(nsIVariant *aValue)
2089	{
2090	if(!mWritable) return NS_ERROR_OBJECT_IS_IMMUTABLE;
2091	return nsVariant::SetFromVariant(&mData, aValue);
2092	}

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

source: vbox/trunk/src/libs/xpcom18a4/xpcom/ds/nsVariant.cpp@ 66250

Download in other formats: