The Tor Browser / file comparison

comparison: xpcom/ds/nsSupportsPrimitives.cpp

xpcom/ds/nsSupportsPrimitives.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:d03406839ddf
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "nsSupportsPrimitives.h"
7 #include "nsMemory.h"
8 #include "prprf.h"
9
10 using mozilla::fallible_t;
11
12 /***************************************************************************/
13
14 NS_IMPL_ISUPPORTS(nsSupportsIDImpl, nsISupportsID, nsISupportsPrimitive)
15
16 nsSupportsIDImpl::nsSupportsIDImpl()
17 : mData(nullptr)
18 {
19 }
20
21 NS_IMETHODIMP nsSupportsIDImpl::GetType(uint16_t *aType)
22 {
23 NS_ASSERTION(aType, "Bad pointer");
24 *aType = TYPE_ID;
25
26 return NS_OK;
27 }
28
29 NS_IMETHODIMP nsSupportsIDImpl::GetData(nsID **aData)
30 {
31 NS_ASSERTION(aData, "Bad pointer");
32 if(mData)
33 {
34 *aData = (nsID*) nsMemory::Clone(mData, sizeof(nsID));
35 return *aData ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
36 }
37 *aData = nullptr;
38 return NS_OK;
39 }
40
41 NS_IMETHODIMP nsSupportsIDImpl::SetData(const nsID *aData)
42 {
43 if(mData)
44 nsMemory::Free(mData);
45 if(aData)
46 mData = (nsID*) nsMemory::Clone(aData, sizeof(nsID));
47 else
48 mData = nullptr;
49 return NS_OK;
50 }
51
52 NS_IMETHODIMP nsSupportsIDImpl::ToString(char **_retval)
53 {
54 char* result;
55 NS_ASSERTION(_retval, "Bad pointer");
56 if(mData)
57 {
58 result = mData->ToString();
59 }
60 else
61 {
62 static const char nullStr[] = "null";
63 result = (char*) nsMemory::Clone(nullStr, sizeof(nullStr));
64 }
65
66 *_retval = result;
67 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
68 }
69
70 /*****************************************************************************
71 * nsSupportsCStringImpl
72 *****************************************************************************/
73
74 NS_IMPL_ISUPPORTS(nsSupportsCStringImpl, nsISupportsCString,
75 nsISupportsPrimitive)
76
77 NS_IMETHODIMP nsSupportsCStringImpl::GetType(uint16_t *aType)
78 {
79 NS_ASSERTION(aType, "Bad pointer");
80
81 *aType = TYPE_CSTRING;
82 return NS_OK;
83 }
84
85 NS_IMETHODIMP nsSupportsCStringImpl::GetData(nsACString& aData)
86 {
87 aData = mData;
88 return NS_OK;
89 }
90
91 NS_IMETHODIMP nsSupportsCStringImpl::ToString(char **_retval)
92 {
93 *_retval = ToNewCString(mData);
94
95 if (!*_retval)
96 return NS_ERROR_OUT_OF_MEMORY;
97
98 return NS_OK;
99 }
100
101 NS_IMETHODIMP nsSupportsCStringImpl::SetData(const nsACString& aData)
102 {
103 bool ok = mData.Assign(aData, fallible_t());
104 if (!ok)
105 return NS_ERROR_OUT_OF_MEMORY;
106 return NS_OK;
107 }
108
109 /*****************************************************************************
110 * nsSupportsStringImpl
111 *****************************************************************************/
112
113 NS_IMPL_ISUPPORTS(nsSupportsStringImpl, nsISupportsString,
114 nsISupportsPrimitive)
115
116 NS_IMETHODIMP nsSupportsStringImpl::GetType(uint16_t *aType)
117 {
118 NS_ASSERTION(aType, "Bad pointer");
119
120 *aType = TYPE_STRING;
121 return NS_OK;
122 }
123
124 NS_IMETHODIMP nsSupportsStringImpl::GetData(nsAString& aData)
125 {
126 aData = mData;
127 return NS_OK;
128 }
129
130 NS_IMETHODIMP nsSupportsStringImpl::ToString(char16_t **_retval)
131 {
132 *_retval = ToNewUnicode(mData);
133
134 if (!*_retval)
135 return NS_ERROR_OUT_OF_MEMORY;
136
137 return NS_OK;
138 }
139
140 NS_IMETHODIMP nsSupportsStringImpl::SetData(const nsAString& aData)
141 {
142 bool ok = mData.Assign(aData, fallible_t());
143 if (!ok)
144 return NS_ERROR_OUT_OF_MEMORY;
145 return NS_OK;
146 }
147
148 /***************************************************************************/
149
150 NS_IMPL_ISUPPORTS(nsSupportsPRBoolImpl, nsISupportsPRBool,
151 nsISupportsPrimitive)
152
153 nsSupportsPRBoolImpl::nsSupportsPRBoolImpl()
154 : mData(false)
155 {
156 }
157
158 NS_IMETHODIMP nsSupportsPRBoolImpl::GetType(uint16_t *aType)
159 {
160 NS_ASSERTION(aType, "Bad pointer");
161 *aType = TYPE_PRBOOL;
162
163 return NS_OK;
164 }
165
166 NS_IMETHODIMP nsSupportsPRBoolImpl::GetData(bool *aData)
167 {
168 NS_ASSERTION(aData, "Bad pointer");
169 *aData = mData;
170 return NS_OK;
171 }
172
173 NS_IMETHODIMP nsSupportsPRBoolImpl::SetData(bool aData)
174 {
175 mData = aData;
176 return NS_OK;
177 }
178
179 NS_IMETHODIMP nsSupportsPRBoolImpl::ToString(char **_retval)
180 {
181 NS_ASSERTION(_retval, "Bad pointer");
182 const char * str = mData ? "true" : "false";
183 char* result = (char*) nsMemory::Clone(str,
184 (strlen(str)+1)*sizeof(char));
185 *_retval = result;
186 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
187 }
188
189 /***************************************************************************/
190
191 NS_IMPL_ISUPPORTS(nsSupportsPRUint8Impl, nsISupportsPRUint8,
192 nsISupportsPrimitive)
193
194 nsSupportsPRUint8Impl::nsSupportsPRUint8Impl()
195 : mData(0)
196 {
197 }
198
199 NS_IMETHODIMP nsSupportsPRUint8Impl::GetType(uint16_t *aType)
200 {
201 NS_ASSERTION(aType, "Bad pointer");
202 *aType = TYPE_PRUINT8;
203
204 return NS_OK;
205 }
206
207 NS_IMETHODIMP nsSupportsPRUint8Impl::GetData(uint8_t *aData)
208 {
209 NS_ASSERTION(aData, "Bad pointer");
210 *aData = mData;
211 return NS_OK;
212 }
213
214 NS_IMETHODIMP nsSupportsPRUint8Impl::SetData(uint8_t aData)
215 {
216 mData = aData;
217 return NS_OK;
218 }
219
220 NS_IMETHODIMP nsSupportsPRUint8Impl::ToString(char **_retval)
221 {
222 NS_ASSERTION(_retval, "Bad pointer");
223 static const int size = 8;
224 char buf[size];
225
226 PR_snprintf(buf, size, "%u", (uint16_t) mData);
227
228 char* result = (char*) nsMemory::Clone(buf,
229 (strlen(buf)+1)*sizeof(char));
230 *_retval = result;
231 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
232 }
233
234 /***************************************************************************/
235
236 NS_IMPL_ISUPPORTS(nsSupportsPRUint16Impl, nsISupportsPRUint16,
237 nsISupportsPrimitive)
238
239 nsSupportsPRUint16Impl::nsSupportsPRUint16Impl()
240 : mData(0)
241 {
242 }
243
244 NS_IMETHODIMP nsSupportsPRUint16Impl::GetType(uint16_t *aType)
245 {
246 NS_ASSERTION(aType, "Bad pointer");
247 *aType = TYPE_PRUINT16;
248
249 return NS_OK;
250 }
251
252 NS_IMETHODIMP nsSupportsPRUint16Impl::GetData(uint16_t *aData)
253 {
254 NS_ASSERTION(aData, "Bad pointer");
255 *aData = mData;
256 return NS_OK;
257 }
258
259 NS_IMETHODIMP nsSupportsPRUint16Impl::SetData(uint16_t aData)
260 {
261 mData = aData;
262 return NS_OK;
263 }
264
265 NS_IMETHODIMP nsSupportsPRUint16Impl::ToString(char **_retval)
266 {
267 NS_ASSERTION(_retval, "Bad pointer");
268 static const int size = 8;
269 char buf[size];
270
271 PR_snprintf(buf, size, "%u", (int) mData);
272
273 char* result = (char*) nsMemory::Clone(buf,
274 (strlen(buf)+1)*sizeof(char));
275 *_retval = result;
276 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
277 }
278
279 /***************************************************************************/
280
281 NS_IMPL_ISUPPORTS(nsSupportsPRUint32Impl, nsISupportsPRUint32,
282 nsISupportsPrimitive)
283
284 nsSupportsPRUint32Impl::nsSupportsPRUint32Impl()
285 : mData(0)
286 {
287 }
288
289 NS_IMETHODIMP nsSupportsPRUint32Impl::GetType(uint16_t *aType)
290 {
291 NS_ASSERTION(aType, "Bad pointer");
292 *aType = TYPE_PRUINT32;
293
294 return NS_OK;
295 }
296
297 NS_IMETHODIMP nsSupportsPRUint32Impl::GetData(uint32_t *aData)
298 {
299 NS_ASSERTION(aData, "Bad pointer");
300 *aData = mData;
301 return NS_OK;
302 }
303
304 NS_IMETHODIMP nsSupportsPRUint32Impl::SetData(uint32_t aData)
305 {
306 mData = aData;
307 return NS_OK;
308 }
309
310 NS_IMETHODIMP nsSupportsPRUint32Impl::ToString(char **_retval)
311 {
312 NS_ASSERTION(_retval, "Bad pointer");
313 static const int size = 16;
314 char buf[size];
315
316 PR_snprintf(buf, size, "%lu", mData);
317
318 char* result = (char*) nsMemory::Clone(buf,
319 (strlen(buf)+1)*sizeof(char));
320 *_retval = result;
321 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
322 }
323
324 /***************************************************************************/
325
326 NS_IMPL_ISUPPORTS(nsSupportsPRUint64Impl, nsISupportsPRUint64,
327 nsISupportsPrimitive)
328
329 nsSupportsPRUint64Impl::nsSupportsPRUint64Impl()
330 : mData(0)
331 {
332 }
333
334 NS_IMETHODIMP nsSupportsPRUint64Impl::GetType(uint16_t *aType)
335 {
336 NS_ASSERTION(aType, "Bad pointer");
337 *aType = TYPE_PRUINT64;
338
339 return NS_OK;
340 }
341
342 NS_IMETHODIMP nsSupportsPRUint64Impl::GetData(uint64_t *aData)
343 {
344 NS_ASSERTION(aData, "Bad pointer");
345 *aData = mData;
346 return NS_OK;
347 }
348
349 NS_IMETHODIMP nsSupportsPRUint64Impl::SetData(uint64_t aData)
350 {
351 mData = aData;
352 return NS_OK;
353 }
354
355 NS_IMETHODIMP nsSupportsPRUint64Impl::ToString(char **_retval)
356 {
357 NS_ASSERTION(_retval, "Bad pointer");
358 static const int size = 32;
359 char buf[size];
360
361 PR_snprintf(buf, size, "%llu", mData);
362
363 char* result = (char*) nsMemory::Clone(buf,
364 (strlen(buf)+1)*sizeof(char));
365 *_retval = result;
366 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
367 }
368
369 /***************************************************************************/
370
371 NS_IMPL_ISUPPORTS(nsSupportsPRTimeImpl, nsISupportsPRTime,
372 nsISupportsPrimitive)
373
374 nsSupportsPRTimeImpl::nsSupportsPRTimeImpl()
375 : mData(0)
376 {
377 }
378
379 NS_IMETHODIMP nsSupportsPRTimeImpl::GetType(uint16_t *aType)
380 {
381 NS_ASSERTION(aType, "Bad pointer");
382 *aType = TYPE_PRTIME;
383
384 return NS_OK;
385 }
386
387 NS_IMETHODIMP nsSupportsPRTimeImpl::GetData(PRTime *aData)
388 {
389 NS_ASSERTION(aData, "Bad pointer");
390 *aData = mData;
391 return NS_OK;
392 }
393
394 NS_IMETHODIMP nsSupportsPRTimeImpl::SetData(PRTime aData)
395 {
396 mData = aData;
397 return NS_OK;
398 }
399
400 NS_IMETHODIMP nsSupportsPRTimeImpl::ToString(char **_retval)
401 {
402 NS_ASSERTION(_retval, "Bad pointer");
403 static const int size = 32;
404 char buf[size];
405
406 PR_snprintf(buf, size, "%llu", mData);
407
408 char* result = (char*) nsMemory::Clone(buf,
409 (strlen(buf)+1)*sizeof(char));
410 *_retval = result;
411 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
412 }
413
414 /***************************************************************************/
415
416 NS_IMPL_ISUPPORTS(nsSupportsCharImpl, nsISupportsChar,
417 nsISupportsPrimitive)
418
419 nsSupportsCharImpl::nsSupportsCharImpl()
420 : mData(0)
421 {
422 }
423
424 NS_IMETHODIMP nsSupportsCharImpl::GetType(uint16_t *aType)
425 {
426 NS_ASSERTION(aType, "Bad pointer");
427 *aType = TYPE_CHAR;
428
429 return NS_OK;
430 }
431
432 NS_IMETHODIMP nsSupportsCharImpl::GetData(char *aData)
433 {
434 NS_ASSERTION(aData, "Bad pointer");
435 *aData = mData;
436 return NS_OK;
437 }
438
439 NS_IMETHODIMP nsSupportsCharImpl::SetData(char aData)
440 {
441 mData = aData;
442 return NS_OK;
443 }
444
445 NS_IMETHODIMP nsSupportsCharImpl::ToString(char **_retval)
446 {
447 char* result;
448 NS_ASSERTION(_retval, "Bad pointer");
449
450 if(nullptr != (result = (char*) nsMemory::Alloc(2*sizeof(char))))
451 {
452 result[0] = mData;
453 result[1] = '\0';
454 }
455 *_retval = result;
456 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
457 }
458
459 /***************************************************************************/
460
461 NS_IMPL_ISUPPORTS(nsSupportsPRInt16Impl, nsISupportsPRInt16,
462 nsISupportsPrimitive)
463
464 nsSupportsPRInt16Impl::nsSupportsPRInt16Impl()
465 : mData(0)
466 {
467 }
468
469 NS_IMETHODIMP nsSupportsPRInt16Impl::GetType(uint16_t *aType)
470 {
471 NS_ASSERTION(aType, "Bad pointer");
472 *aType = TYPE_PRINT16;
473
474 return NS_OK;
475 }
476
477 NS_IMETHODIMP nsSupportsPRInt16Impl::GetData(int16_t *aData)
478 {
479 NS_ASSERTION(aData, "Bad pointer");
480 *aData = mData;
481 return NS_OK;
482 }
483
484 NS_IMETHODIMP nsSupportsPRInt16Impl::SetData(int16_t aData)
485 {
486 mData = aData;
487 return NS_OK;
488 }
489
490 NS_IMETHODIMP nsSupportsPRInt16Impl::ToString(char **_retval)
491 {
492 NS_ASSERTION(_retval, "Bad pointer");
493 static const int size = 8;
494 char buf[size];
495
496 PR_snprintf(buf, size, "%d", mData);
497
498 char* result = (char*) nsMemory::Clone(buf,
499 (strlen(buf)+1)*sizeof(char));
500 *_retval = result;
501 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
502 }
503
504 /***************************************************************************/
505
506 NS_IMPL_ISUPPORTS(nsSupportsPRInt32Impl, nsISupportsPRInt32,
507 nsISupportsPrimitive)
508
509 nsSupportsPRInt32Impl::nsSupportsPRInt32Impl()
510 : mData(0)
511 {
512 }
513
514 NS_IMETHODIMP nsSupportsPRInt32Impl::GetType(uint16_t *aType)
515 {
516 NS_ASSERTION(aType, "Bad pointer");
517 *aType = TYPE_PRINT32;
518
519 return NS_OK;
520 }
521
522 NS_IMETHODIMP nsSupportsPRInt32Impl::GetData(int32_t *aData)
523 {
524 NS_ASSERTION(aData, "Bad pointer");
525 *aData = mData;
526 return NS_OK;
527 }
528
529 NS_IMETHODIMP nsSupportsPRInt32Impl::SetData(int32_t aData)
530 {
531 mData = aData;
532 return NS_OK;
533 }
534
535 NS_IMETHODIMP nsSupportsPRInt32Impl::ToString(char **_retval)
536 {
537 NS_ASSERTION(_retval, "Bad pointer");
538 static const int size = 16;
539 char buf[size];
540
541 PR_snprintf(buf, size, "%ld", mData);
542
543 char* result = (char*) nsMemory::Clone(buf,
544 (strlen(buf)+1)*sizeof(char));
545 *_retval = result;
546 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
547 }
548
549 /***************************************************************************/
550
551 NS_IMPL_ISUPPORTS(nsSupportsPRInt64Impl, nsISupportsPRInt64,
552 nsISupportsPrimitive)
553
554 nsSupportsPRInt64Impl::nsSupportsPRInt64Impl()
555 : mData(0)
556 {
557 }
558
559 NS_IMETHODIMP nsSupportsPRInt64Impl::GetType(uint16_t *aType)
560 {
561 NS_ASSERTION(aType, "Bad pointer");
562 *aType = TYPE_PRINT64;
563
564 return NS_OK;
565 }
566
567 NS_IMETHODIMP nsSupportsPRInt64Impl::GetData(int64_t *aData)
568 {
569 NS_ASSERTION(aData, "Bad pointer");
570 *aData = mData;
571 return NS_OK;
572 }
573
574 NS_IMETHODIMP nsSupportsPRInt64Impl::SetData(int64_t aData)
575 {
576 mData = aData;
577 return NS_OK;
578 }
579
580 NS_IMETHODIMP nsSupportsPRInt64Impl::ToString(char **_retval)
581 {
582 NS_ASSERTION(_retval, "Bad pointer");
583 static const int size = 32;
584 char buf[size];
585
586 PR_snprintf(buf, size, "%lld", mData);
587
588 char* result = (char*) nsMemory::Clone(buf,
589 (strlen(buf)+1)*sizeof(char));
590 *_retval = result;
591 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
592 }
593
594 /***************************************************************************/
595
596 NS_IMPL_ISUPPORTS(nsSupportsFloatImpl, nsISupportsFloat,
597 nsISupportsPrimitive)
598
599 nsSupportsFloatImpl::nsSupportsFloatImpl()
600 : mData(float(0.0))
601 {
602 }
603
604 NS_IMETHODIMP nsSupportsFloatImpl::GetType(uint16_t *aType)
605 {
606 NS_ASSERTION(aType, "Bad pointer");
607 *aType = TYPE_FLOAT;
608
609 return NS_OK;
610 }
611
612 NS_IMETHODIMP nsSupportsFloatImpl::GetData(float *aData)
613 {
614 NS_ASSERTION(aData, "Bad pointer");
615 *aData = mData;
616 return NS_OK;
617 }
618
619 NS_IMETHODIMP nsSupportsFloatImpl::SetData(float aData)
620 {
621 mData = aData;
622 return NS_OK;
623 }
624
625 NS_IMETHODIMP nsSupportsFloatImpl::ToString(char **_retval)
626 {
627 NS_ASSERTION(_retval, "Bad pointer");
628 static const int size = 32;
629 char buf[size];
630
631 PR_snprintf(buf, size, "%f", (double) mData);
632
633 char* result = (char*) nsMemory::Clone(buf,
634 (strlen(buf)+1)*sizeof(char));
635 *_retval = result;
636 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
637 }
638
639 /***************************************************************************/
640
641 NS_IMPL_ISUPPORTS(nsSupportsDoubleImpl, nsISupportsDouble,
642 nsISupportsPrimitive)
643
644 nsSupportsDoubleImpl::nsSupportsDoubleImpl()
645 : mData(double(0.0))
646 {
647 }
648
649 NS_IMETHODIMP nsSupportsDoubleImpl::GetType(uint16_t *aType)
650 {
651 NS_ASSERTION(aType, "Bad pointer");
652 *aType = TYPE_DOUBLE;
653
654 return NS_OK;
655 }
656
657 NS_IMETHODIMP nsSupportsDoubleImpl::GetData(double *aData)
658 {
659 NS_ASSERTION(aData, "Bad pointer");
660 *aData = mData;
661 return NS_OK;
662 }
663
664 NS_IMETHODIMP nsSupportsDoubleImpl::SetData(double aData)
665 {
666 mData = aData;
667 return NS_OK;
668 }
669
670 NS_IMETHODIMP nsSupportsDoubleImpl::ToString(char **_retval)
671 {
672 NS_ASSERTION(_retval, "Bad pointer");
673 static const int size = 32;
674 char buf[size];
675
676 PR_snprintf(buf, size, "%f", mData);
677
678 char* result = (char*) nsMemory::Clone(buf,
679 (strlen(buf)+1)*sizeof(char));
680 *_retval = result;
681 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
682 }
683
684 /***************************************************************************/
685
686
687 NS_IMPL_ISUPPORTS(nsSupportsVoidImpl, nsISupportsVoid,
688 nsISupportsPrimitive)
689
690 nsSupportsVoidImpl::nsSupportsVoidImpl()
691 : mData(nullptr)
692 {
693 }
694
695 NS_IMETHODIMP nsSupportsVoidImpl::GetType(uint16_t *aType)
696 {
697 NS_ASSERTION(aType, "Bad pointer");
698 *aType = TYPE_VOID;
699
700 return NS_OK;
701 }
702
703 NS_IMETHODIMP nsSupportsVoidImpl::GetData(void * *aData)
704 {
705 NS_ASSERTION(aData, "Bad pointer");
706 *aData = mData;
707 return NS_OK;
708 }
709
710 NS_IMETHODIMP nsSupportsVoidImpl::SetData(void * aData)
711 {
712 mData = aData;
713 return NS_OK;
714 }
715
716 NS_IMETHODIMP nsSupportsVoidImpl::ToString(char **_retval)
717 {
718 NS_ASSERTION(_retval, "Bad pointer");
719
720 static const char str[] = "[raw data]";
721 char* result = (char*) nsMemory::Clone(str, sizeof(str));
722 *_retval = result;
723 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
724 }
725
726 /***************************************************************************/
727
728
729 NS_IMPL_ISUPPORTS(nsSupportsInterfacePointerImpl,
730 nsISupportsInterfacePointer,
731 nsISupportsPrimitive)
732
733 nsSupportsInterfacePointerImpl::nsSupportsInterfacePointerImpl()
734 : mIID(nullptr)
735 {
736 }
737
738 nsSupportsInterfacePointerImpl::~nsSupportsInterfacePointerImpl()
739 {
740 if (mIID) {
741 nsMemory::Free(mIID);
742 }
743 }
744
745 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetType(uint16_t *aType)
746 {
747 NS_ASSERTION(aType, "Bad pointer");
748 *aType = TYPE_INTERFACE_POINTER;
749
750 return NS_OK;
751 }
752
753 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetData(nsISupports **aData)
754 {
755 NS_ASSERTION(aData,"Bad pointer");
756
757 *aData = mData;
758 NS_IF_ADDREF(*aData);
759
760 return NS_OK;
761 }
762
763 NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetData(nsISupports * aData)
764 {
765 mData = aData;
766
767 return NS_OK;
768 }
769
770 NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetDataIID(nsID **aIID)
771 {
772 NS_ASSERTION(aIID,"Bad pointer");
773
774 if(mIID)
775 {
776 *aIID = (nsID*) nsMemory::Clone(mIID, sizeof(nsID));
777 return *aIID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
778 }
779 *aIID = nullptr;
780 return NS_OK;
781 }
782
783 NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetDataIID(const nsID *aIID)
784 {
785 if(mIID)
786 nsMemory::Free(mIID);
787 if(aIID)
788 mIID = (nsID*) nsMemory::Clone(aIID, sizeof(nsID));
789 else
790 mIID = nullptr;
791
792 return NS_OK;
793 }
794
795 NS_IMETHODIMP nsSupportsInterfacePointerImpl::ToString(char **_retval)
796 {
797 NS_ASSERTION(_retval, "Bad pointer");
798
799 static const char str[] = "[interface pointer]";
800
801 // jband sez: think about asking nsIInterfaceInfoManager whether
802 // the interface has a known human-readable name
803 char* result = (char*) nsMemory::Clone(str, sizeof(str));
804 *_retval = result;
805 return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
806 }
807
808 /***************************************************************************/
809
810 NS_IMPL_ISUPPORTS(nsSupportsDependentCString,nsISupportsCString,nsISupportsPrimitive)
811
812 nsSupportsDependentCString::nsSupportsDependentCString(const char* aStr)
813 : mData(aStr)
814 { }
815
816 NS_IMETHODIMP
817 nsSupportsDependentCString::GetType(uint16_t *aType)
818 {
819 if (NS_WARN_IF(!aType))
820 return NS_ERROR_INVALID_ARG;
821
822 *aType = TYPE_CSTRING;
823 return NS_OK;
824 }
825
826 NS_IMETHODIMP
827 nsSupportsDependentCString::GetData(nsACString& aData)
828 {
829 aData = mData;
830 return NS_OK;
831 }
832
833 NS_IMETHODIMP
834 nsSupportsDependentCString::ToString(char **_retval)
835 {
836 if (NS_WARN_IF(!_retval))
837 return NS_ERROR_INVALID_ARG;
838
839 *_retval = ToNewCString(mData);
840 if (!*_retval)
841 return NS_ERROR_OUT_OF_MEMORY;
842
843 return NS_OK;
844 }
845
846 NS_IMETHODIMP
847 nsSupportsDependentCString::SetData(const nsACString& aData)
848 {
849 return NS_ERROR_NOT_IMPLEMENTED;
850 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial