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