xpcom/ds/nsSupportsPrimitives.cpp

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