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