1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/xpcom/ds/nsSupportsPrimitives.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,850 @@
1.4 +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
1.5 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.6 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.7 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.8 +
1.9 +#include "nsSupportsPrimitives.h"
1.10 +#include "nsMemory.h"
1.11 +#include "prprf.h"
1.12 +
1.13 +using mozilla::fallible_t;
1.14 +
1.15 +/***************************************************************************/
1.16 +
1.17 +NS_IMPL_ISUPPORTS(nsSupportsIDImpl, nsISupportsID, nsISupportsPrimitive)
1.18 +
1.19 +nsSupportsIDImpl::nsSupportsIDImpl()
1.20 + : mData(nullptr)
1.21 +{
1.22 +}
1.23 +
1.24 +NS_IMETHODIMP nsSupportsIDImpl::GetType(uint16_t *aType)
1.25 +{
1.26 + NS_ASSERTION(aType, "Bad pointer");
1.27 + *aType = TYPE_ID;
1.28 +
1.29 + return NS_OK;
1.30 +}
1.31 +
1.32 +NS_IMETHODIMP nsSupportsIDImpl::GetData(nsID **aData)
1.33 +{
1.34 + NS_ASSERTION(aData, "Bad pointer");
1.35 + if(mData)
1.36 + {
1.37 + *aData = (nsID*) nsMemory::Clone(mData, sizeof(nsID));
1.38 + return *aData ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.39 + }
1.40 + *aData = nullptr;
1.41 + return NS_OK;
1.42 +}
1.43 +
1.44 +NS_IMETHODIMP nsSupportsIDImpl::SetData(const nsID *aData)
1.45 +{
1.46 + if(mData)
1.47 + nsMemory::Free(mData);
1.48 + if(aData)
1.49 + mData = (nsID*) nsMemory::Clone(aData, sizeof(nsID));
1.50 + else
1.51 + mData = nullptr;
1.52 + return NS_OK;
1.53 +}
1.54 +
1.55 +NS_IMETHODIMP nsSupportsIDImpl::ToString(char **_retval)
1.56 +{
1.57 + char* result;
1.58 + NS_ASSERTION(_retval, "Bad pointer");
1.59 + if(mData)
1.60 + {
1.61 + result = mData->ToString();
1.62 + }
1.63 + else
1.64 + {
1.65 + static const char nullStr[] = "null";
1.66 + result = (char*) nsMemory::Clone(nullStr, sizeof(nullStr));
1.67 + }
1.68 +
1.69 + *_retval = result;
1.70 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.71 +}
1.72 +
1.73 +/*****************************************************************************
1.74 + * nsSupportsCStringImpl
1.75 + *****************************************************************************/
1.76 +
1.77 +NS_IMPL_ISUPPORTS(nsSupportsCStringImpl, nsISupportsCString,
1.78 + nsISupportsPrimitive)
1.79 +
1.80 +NS_IMETHODIMP nsSupportsCStringImpl::GetType(uint16_t *aType)
1.81 +{
1.82 + NS_ASSERTION(aType, "Bad pointer");
1.83 +
1.84 + *aType = TYPE_CSTRING;
1.85 + return NS_OK;
1.86 +}
1.87 +
1.88 +NS_IMETHODIMP nsSupportsCStringImpl::GetData(nsACString& aData)
1.89 +{
1.90 + aData = mData;
1.91 + return NS_OK;
1.92 +}
1.93 +
1.94 +NS_IMETHODIMP nsSupportsCStringImpl::ToString(char **_retval)
1.95 +{
1.96 + *_retval = ToNewCString(mData);
1.97 +
1.98 + if (!*_retval)
1.99 + return NS_ERROR_OUT_OF_MEMORY;
1.100 +
1.101 + return NS_OK;
1.102 +}
1.103 +
1.104 +NS_IMETHODIMP nsSupportsCStringImpl::SetData(const nsACString& aData)
1.105 +{
1.106 + bool ok = mData.Assign(aData, fallible_t());
1.107 + if (!ok)
1.108 + return NS_ERROR_OUT_OF_MEMORY;
1.109 + return NS_OK;
1.110 +}
1.111 +
1.112 +/*****************************************************************************
1.113 + * nsSupportsStringImpl
1.114 + *****************************************************************************/
1.115 +
1.116 +NS_IMPL_ISUPPORTS(nsSupportsStringImpl, nsISupportsString,
1.117 + nsISupportsPrimitive)
1.118 +
1.119 +NS_IMETHODIMP nsSupportsStringImpl::GetType(uint16_t *aType)
1.120 +{
1.121 + NS_ASSERTION(aType, "Bad pointer");
1.122 +
1.123 + *aType = TYPE_STRING;
1.124 + return NS_OK;
1.125 +}
1.126 +
1.127 +NS_IMETHODIMP nsSupportsStringImpl::GetData(nsAString& aData)
1.128 +{
1.129 + aData = mData;
1.130 + return NS_OK;
1.131 +}
1.132 +
1.133 +NS_IMETHODIMP nsSupportsStringImpl::ToString(char16_t **_retval)
1.134 +{
1.135 + *_retval = ToNewUnicode(mData);
1.136 +
1.137 + if (!*_retval)
1.138 + return NS_ERROR_OUT_OF_MEMORY;
1.139 +
1.140 + return NS_OK;
1.141 +}
1.142 +
1.143 +NS_IMETHODIMP nsSupportsStringImpl::SetData(const nsAString& aData)
1.144 +{
1.145 + bool ok = mData.Assign(aData, fallible_t());
1.146 + if (!ok)
1.147 + return NS_ERROR_OUT_OF_MEMORY;
1.148 + return NS_OK;
1.149 +}
1.150 +
1.151 +/***************************************************************************/
1.152 +
1.153 +NS_IMPL_ISUPPORTS(nsSupportsPRBoolImpl, nsISupportsPRBool,
1.154 + nsISupportsPrimitive)
1.155 +
1.156 +nsSupportsPRBoolImpl::nsSupportsPRBoolImpl()
1.157 + : mData(false)
1.158 +{
1.159 +}
1.160 +
1.161 +NS_IMETHODIMP nsSupportsPRBoolImpl::GetType(uint16_t *aType)
1.162 +{
1.163 + NS_ASSERTION(aType, "Bad pointer");
1.164 + *aType = TYPE_PRBOOL;
1.165 +
1.166 + return NS_OK;
1.167 +}
1.168 +
1.169 +NS_IMETHODIMP nsSupportsPRBoolImpl::GetData(bool *aData)
1.170 +{
1.171 + NS_ASSERTION(aData, "Bad pointer");
1.172 + *aData = mData;
1.173 + return NS_OK;
1.174 +}
1.175 +
1.176 +NS_IMETHODIMP nsSupportsPRBoolImpl::SetData(bool aData)
1.177 +{
1.178 + mData = aData;
1.179 + return NS_OK;
1.180 +}
1.181 +
1.182 +NS_IMETHODIMP nsSupportsPRBoolImpl::ToString(char **_retval)
1.183 +{
1.184 + NS_ASSERTION(_retval, "Bad pointer");
1.185 + const char * str = mData ? "true" : "false";
1.186 + char* result = (char*) nsMemory::Clone(str,
1.187 + (strlen(str)+1)*sizeof(char));
1.188 + *_retval = result;
1.189 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.190 +}
1.191 +
1.192 +/***************************************************************************/
1.193 +
1.194 +NS_IMPL_ISUPPORTS(nsSupportsPRUint8Impl, nsISupportsPRUint8,
1.195 + nsISupportsPrimitive)
1.196 +
1.197 +nsSupportsPRUint8Impl::nsSupportsPRUint8Impl()
1.198 + : mData(0)
1.199 +{
1.200 +}
1.201 +
1.202 +NS_IMETHODIMP nsSupportsPRUint8Impl::GetType(uint16_t *aType)
1.203 +{
1.204 + NS_ASSERTION(aType, "Bad pointer");
1.205 + *aType = TYPE_PRUINT8;
1.206 +
1.207 + return NS_OK;
1.208 +}
1.209 +
1.210 +NS_IMETHODIMP nsSupportsPRUint8Impl::GetData(uint8_t *aData)
1.211 +{
1.212 + NS_ASSERTION(aData, "Bad pointer");
1.213 + *aData = mData;
1.214 + return NS_OK;
1.215 +}
1.216 +
1.217 +NS_IMETHODIMP nsSupportsPRUint8Impl::SetData(uint8_t aData)
1.218 +{
1.219 + mData = aData;
1.220 + return NS_OK;
1.221 +}
1.222 +
1.223 +NS_IMETHODIMP nsSupportsPRUint8Impl::ToString(char **_retval)
1.224 +{
1.225 + NS_ASSERTION(_retval, "Bad pointer");
1.226 + static const int size = 8;
1.227 + char buf[size];
1.228 +
1.229 + PR_snprintf(buf, size, "%u", (uint16_t) mData);
1.230 +
1.231 + char* result = (char*) nsMemory::Clone(buf,
1.232 + (strlen(buf)+1)*sizeof(char));
1.233 + *_retval = result;
1.234 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.235 +}
1.236 +
1.237 +/***************************************************************************/
1.238 +
1.239 +NS_IMPL_ISUPPORTS(nsSupportsPRUint16Impl, nsISupportsPRUint16,
1.240 + nsISupportsPrimitive)
1.241 +
1.242 +nsSupportsPRUint16Impl::nsSupportsPRUint16Impl()
1.243 + : mData(0)
1.244 +{
1.245 +}
1.246 +
1.247 +NS_IMETHODIMP nsSupportsPRUint16Impl::GetType(uint16_t *aType)
1.248 +{
1.249 + NS_ASSERTION(aType, "Bad pointer");
1.250 + *aType = TYPE_PRUINT16;
1.251 +
1.252 + return NS_OK;
1.253 +}
1.254 +
1.255 +NS_IMETHODIMP nsSupportsPRUint16Impl::GetData(uint16_t *aData)
1.256 +{
1.257 + NS_ASSERTION(aData, "Bad pointer");
1.258 + *aData = mData;
1.259 + return NS_OK;
1.260 +}
1.261 +
1.262 +NS_IMETHODIMP nsSupportsPRUint16Impl::SetData(uint16_t aData)
1.263 +{
1.264 + mData = aData;
1.265 + return NS_OK;
1.266 +}
1.267 +
1.268 +NS_IMETHODIMP nsSupportsPRUint16Impl::ToString(char **_retval)
1.269 +{
1.270 + NS_ASSERTION(_retval, "Bad pointer");
1.271 + static const int size = 8;
1.272 + char buf[size];
1.273 +
1.274 + PR_snprintf(buf, size, "%u", (int) mData);
1.275 +
1.276 + char* result = (char*) nsMemory::Clone(buf,
1.277 + (strlen(buf)+1)*sizeof(char));
1.278 + *_retval = result;
1.279 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.280 +}
1.281 +
1.282 +/***************************************************************************/
1.283 +
1.284 +NS_IMPL_ISUPPORTS(nsSupportsPRUint32Impl, nsISupportsPRUint32,
1.285 + nsISupportsPrimitive)
1.286 +
1.287 +nsSupportsPRUint32Impl::nsSupportsPRUint32Impl()
1.288 + : mData(0)
1.289 +{
1.290 +}
1.291 +
1.292 +NS_IMETHODIMP nsSupportsPRUint32Impl::GetType(uint16_t *aType)
1.293 +{
1.294 + NS_ASSERTION(aType, "Bad pointer");
1.295 + *aType = TYPE_PRUINT32;
1.296 +
1.297 + return NS_OK;
1.298 +}
1.299 +
1.300 +NS_IMETHODIMP nsSupportsPRUint32Impl::GetData(uint32_t *aData)
1.301 +{
1.302 + NS_ASSERTION(aData, "Bad pointer");
1.303 + *aData = mData;
1.304 + return NS_OK;
1.305 +}
1.306 +
1.307 +NS_IMETHODIMP nsSupportsPRUint32Impl::SetData(uint32_t aData)
1.308 +{
1.309 + mData = aData;
1.310 + return NS_OK;
1.311 +}
1.312 +
1.313 +NS_IMETHODIMP nsSupportsPRUint32Impl::ToString(char **_retval)
1.314 +{
1.315 + NS_ASSERTION(_retval, "Bad pointer");
1.316 + static const int size = 16;
1.317 + char buf[size];
1.318 +
1.319 + PR_snprintf(buf, size, "%lu", mData);
1.320 +
1.321 + char* result = (char*) nsMemory::Clone(buf,
1.322 + (strlen(buf)+1)*sizeof(char));
1.323 + *_retval = result;
1.324 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.325 +}
1.326 +
1.327 +/***************************************************************************/
1.328 +
1.329 +NS_IMPL_ISUPPORTS(nsSupportsPRUint64Impl, nsISupportsPRUint64,
1.330 + nsISupportsPrimitive)
1.331 +
1.332 +nsSupportsPRUint64Impl::nsSupportsPRUint64Impl()
1.333 + : mData(0)
1.334 +{
1.335 +}
1.336 +
1.337 +NS_IMETHODIMP nsSupportsPRUint64Impl::GetType(uint16_t *aType)
1.338 +{
1.339 + NS_ASSERTION(aType, "Bad pointer");
1.340 + *aType = TYPE_PRUINT64;
1.341 +
1.342 + return NS_OK;
1.343 +}
1.344 +
1.345 +NS_IMETHODIMP nsSupportsPRUint64Impl::GetData(uint64_t *aData)
1.346 +{
1.347 + NS_ASSERTION(aData, "Bad pointer");
1.348 + *aData = mData;
1.349 + return NS_OK;
1.350 +}
1.351 +
1.352 +NS_IMETHODIMP nsSupportsPRUint64Impl::SetData(uint64_t aData)
1.353 +{
1.354 + mData = aData;
1.355 + return NS_OK;
1.356 +}
1.357 +
1.358 +NS_IMETHODIMP nsSupportsPRUint64Impl::ToString(char **_retval)
1.359 +{
1.360 + NS_ASSERTION(_retval, "Bad pointer");
1.361 + static const int size = 32;
1.362 + char buf[size];
1.363 +
1.364 + PR_snprintf(buf, size, "%llu", mData);
1.365 +
1.366 + char* result = (char*) nsMemory::Clone(buf,
1.367 + (strlen(buf)+1)*sizeof(char));
1.368 + *_retval = result;
1.369 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.370 +}
1.371 +
1.372 +/***************************************************************************/
1.373 +
1.374 +NS_IMPL_ISUPPORTS(nsSupportsPRTimeImpl, nsISupportsPRTime,
1.375 + nsISupportsPrimitive)
1.376 +
1.377 +nsSupportsPRTimeImpl::nsSupportsPRTimeImpl()
1.378 + : mData(0)
1.379 +{
1.380 +}
1.381 +
1.382 +NS_IMETHODIMP nsSupportsPRTimeImpl::GetType(uint16_t *aType)
1.383 +{
1.384 + NS_ASSERTION(aType, "Bad pointer");
1.385 + *aType = TYPE_PRTIME;
1.386 +
1.387 + return NS_OK;
1.388 +}
1.389 +
1.390 +NS_IMETHODIMP nsSupportsPRTimeImpl::GetData(PRTime *aData)
1.391 +{
1.392 + NS_ASSERTION(aData, "Bad pointer");
1.393 + *aData = mData;
1.394 + return NS_OK;
1.395 +}
1.396 +
1.397 +NS_IMETHODIMP nsSupportsPRTimeImpl::SetData(PRTime aData)
1.398 +{
1.399 + mData = aData;
1.400 + return NS_OK;
1.401 +}
1.402 +
1.403 +NS_IMETHODIMP nsSupportsPRTimeImpl::ToString(char **_retval)
1.404 +{
1.405 + NS_ASSERTION(_retval, "Bad pointer");
1.406 + static const int size = 32;
1.407 + char buf[size];
1.408 +
1.409 + PR_snprintf(buf, size, "%llu", mData);
1.410 +
1.411 + char* result = (char*) nsMemory::Clone(buf,
1.412 + (strlen(buf)+1)*sizeof(char));
1.413 + *_retval = result;
1.414 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.415 +}
1.416 +
1.417 +/***************************************************************************/
1.418 +
1.419 +NS_IMPL_ISUPPORTS(nsSupportsCharImpl, nsISupportsChar,
1.420 + nsISupportsPrimitive)
1.421 +
1.422 +nsSupportsCharImpl::nsSupportsCharImpl()
1.423 + : mData(0)
1.424 +{
1.425 +}
1.426 +
1.427 +NS_IMETHODIMP nsSupportsCharImpl::GetType(uint16_t *aType)
1.428 +{
1.429 + NS_ASSERTION(aType, "Bad pointer");
1.430 + *aType = TYPE_CHAR;
1.431 +
1.432 + return NS_OK;
1.433 +}
1.434 +
1.435 +NS_IMETHODIMP nsSupportsCharImpl::GetData(char *aData)
1.436 +{
1.437 + NS_ASSERTION(aData, "Bad pointer");
1.438 + *aData = mData;
1.439 + return NS_OK;
1.440 +}
1.441 +
1.442 +NS_IMETHODIMP nsSupportsCharImpl::SetData(char aData)
1.443 +{
1.444 + mData = aData;
1.445 + return NS_OK;
1.446 +}
1.447 +
1.448 +NS_IMETHODIMP nsSupportsCharImpl::ToString(char **_retval)
1.449 +{
1.450 + char* result;
1.451 + NS_ASSERTION(_retval, "Bad pointer");
1.452 +
1.453 + if(nullptr != (result = (char*) nsMemory::Alloc(2*sizeof(char))))
1.454 + {
1.455 + result[0] = mData;
1.456 + result[1] = '\0';
1.457 + }
1.458 + *_retval = result;
1.459 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.460 +}
1.461 +
1.462 +/***************************************************************************/
1.463 +
1.464 +NS_IMPL_ISUPPORTS(nsSupportsPRInt16Impl, nsISupportsPRInt16,
1.465 + nsISupportsPrimitive)
1.466 +
1.467 +nsSupportsPRInt16Impl::nsSupportsPRInt16Impl()
1.468 + : mData(0)
1.469 +{
1.470 +}
1.471 +
1.472 +NS_IMETHODIMP nsSupportsPRInt16Impl::GetType(uint16_t *aType)
1.473 +{
1.474 + NS_ASSERTION(aType, "Bad pointer");
1.475 + *aType = TYPE_PRINT16;
1.476 +
1.477 + return NS_OK;
1.478 +}
1.479 +
1.480 +NS_IMETHODIMP nsSupportsPRInt16Impl::GetData(int16_t *aData)
1.481 +{
1.482 + NS_ASSERTION(aData, "Bad pointer");
1.483 + *aData = mData;
1.484 + return NS_OK;
1.485 +}
1.486 +
1.487 +NS_IMETHODIMP nsSupportsPRInt16Impl::SetData(int16_t aData)
1.488 +{
1.489 + mData = aData;
1.490 + return NS_OK;
1.491 +}
1.492 +
1.493 +NS_IMETHODIMP nsSupportsPRInt16Impl::ToString(char **_retval)
1.494 +{
1.495 + NS_ASSERTION(_retval, "Bad pointer");
1.496 + static const int size = 8;
1.497 + char buf[size];
1.498 +
1.499 + PR_snprintf(buf, size, "%d", mData);
1.500 +
1.501 + char* result = (char*) nsMemory::Clone(buf,
1.502 + (strlen(buf)+1)*sizeof(char));
1.503 + *_retval = result;
1.504 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.505 +}
1.506 +
1.507 +/***************************************************************************/
1.508 +
1.509 +NS_IMPL_ISUPPORTS(nsSupportsPRInt32Impl, nsISupportsPRInt32,
1.510 + nsISupportsPrimitive)
1.511 +
1.512 +nsSupportsPRInt32Impl::nsSupportsPRInt32Impl()
1.513 + : mData(0)
1.514 +{
1.515 +}
1.516 +
1.517 +NS_IMETHODIMP nsSupportsPRInt32Impl::GetType(uint16_t *aType)
1.518 +{
1.519 + NS_ASSERTION(aType, "Bad pointer");
1.520 + *aType = TYPE_PRINT32;
1.521 +
1.522 + return NS_OK;
1.523 +}
1.524 +
1.525 +NS_IMETHODIMP nsSupportsPRInt32Impl::GetData(int32_t *aData)
1.526 +{
1.527 + NS_ASSERTION(aData, "Bad pointer");
1.528 + *aData = mData;
1.529 + return NS_OK;
1.530 +}
1.531 +
1.532 +NS_IMETHODIMP nsSupportsPRInt32Impl::SetData(int32_t aData)
1.533 +{
1.534 + mData = aData;
1.535 + return NS_OK;
1.536 +}
1.537 +
1.538 +NS_IMETHODIMP nsSupportsPRInt32Impl::ToString(char **_retval)
1.539 +{
1.540 + NS_ASSERTION(_retval, "Bad pointer");
1.541 + static const int size = 16;
1.542 + char buf[size];
1.543 +
1.544 + PR_snprintf(buf, size, "%ld", mData);
1.545 +
1.546 + char* result = (char*) nsMemory::Clone(buf,
1.547 + (strlen(buf)+1)*sizeof(char));
1.548 + *_retval = result;
1.549 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.550 +}
1.551 +
1.552 +/***************************************************************************/
1.553 +
1.554 +NS_IMPL_ISUPPORTS(nsSupportsPRInt64Impl, nsISupportsPRInt64,
1.555 + nsISupportsPrimitive)
1.556 +
1.557 +nsSupportsPRInt64Impl::nsSupportsPRInt64Impl()
1.558 + : mData(0)
1.559 +{
1.560 +}
1.561 +
1.562 +NS_IMETHODIMP nsSupportsPRInt64Impl::GetType(uint16_t *aType)
1.563 +{
1.564 + NS_ASSERTION(aType, "Bad pointer");
1.565 + *aType = TYPE_PRINT64;
1.566 +
1.567 + return NS_OK;
1.568 +}
1.569 +
1.570 +NS_IMETHODIMP nsSupportsPRInt64Impl::GetData(int64_t *aData)
1.571 +{
1.572 + NS_ASSERTION(aData, "Bad pointer");
1.573 + *aData = mData;
1.574 + return NS_OK;
1.575 +}
1.576 +
1.577 +NS_IMETHODIMP nsSupportsPRInt64Impl::SetData(int64_t aData)
1.578 +{
1.579 + mData = aData;
1.580 + return NS_OK;
1.581 +}
1.582 +
1.583 +NS_IMETHODIMP nsSupportsPRInt64Impl::ToString(char **_retval)
1.584 +{
1.585 + NS_ASSERTION(_retval, "Bad pointer");
1.586 + static const int size = 32;
1.587 + char buf[size];
1.588 +
1.589 + PR_snprintf(buf, size, "%lld", mData);
1.590 +
1.591 + char* result = (char*) nsMemory::Clone(buf,
1.592 + (strlen(buf)+1)*sizeof(char));
1.593 + *_retval = result;
1.594 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.595 +}
1.596 +
1.597 +/***************************************************************************/
1.598 +
1.599 +NS_IMPL_ISUPPORTS(nsSupportsFloatImpl, nsISupportsFloat,
1.600 + nsISupportsPrimitive)
1.601 +
1.602 +nsSupportsFloatImpl::nsSupportsFloatImpl()
1.603 + : mData(float(0.0))
1.604 +{
1.605 +}
1.606 +
1.607 +NS_IMETHODIMP nsSupportsFloatImpl::GetType(uint16_t *aType)
1.608 +{
1.609 + NS_ASSERTION(aType, "Bad pointer");
1.610 + *aType = TYPE_FLOAT;
1.611 +
1.612 + return NS_OK;
1.613 +}
1.614 +
1.615 +NS_IMETHODIMP nsSupportsFloatImpl::GetData(float *aData)
1.616 +{
1.617 + NS_ASSERTION(aData, "Bad pointer");
1.618 + *aData = mData;
1.619 + return NS_OK;
1.620 +}
1.621 +
1.622 +NS_IMETHODIMP nsSupportsFloatImpl::SetData(float aData)
1.623 +{
1.624 + mData = aData;
1.625 + return NS_OK;
1.626 +}
1.627 +
1.628 +NS_IMETHODIMP nsSupportsFloatImpl::ToString(char **_retval)
1.629 +{
1.630 + NS_ASSERTION(_retval, "Bad pointer");
1.631 + static const int size = 32;
1.632 + char buf[size];
1.633 +
1.634 + PR_snprintf(buf, size, "%f", (double) mData);
1.635 +
1.636 + char* result = (char*) nsMemory::Clone(buf,
1.637 + (strlen(buf)+1)*sizeof(char));
1.638 + *_retval = result;
1.639 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.640 +}
1.641 +
1.642 +/***************************************************************************/
1.643 +
1.644 +NS_IMPL_ISUPPORTS(nsSupportsDoubleImpl, nsISupportsDouble,
1.645 + nsISupportsPrimitive)
1.646 +
1.647 +nsSupportsDoubleImpl::nsSupportsDoubleImpl()
1.648 + : mData(double(0.0))
1.649 +{
1.650 +}
1.651 +
1.652 +NS_IMETHODIMP nsSupportsDoubleImpl::GetType(uint16_t *aType)
1.653 +{
1.654 + NS_ASSERTION(aType, "Bad pointer");
1.655 + *aType = TYPE_DOUBLE;
1.656 +
1.657 + return NS_OK;
1.658 +}
1.659 +
1.660 +NS_IMETHODIMP nsSupportsDoubleImpl::GetData(double *aData)
1.661 +{
1.662 + NS_ASSERTION(aData, "Bad pointer");
1.663 + *aData = mData;
1.664 + return NS_OK;
1.665 +}
1.666 +
1.667 +NS_IMETHODIMP nsSupportsDoubleImpl::SetData(double aData)
1.668 +{
1.669 + mData = aData;
1.670 + return NS_OK;
1.671 +}
1.672 +
1.673 +NS_IMETHODIMP nsSupportsDoubleImpl::ToString(char **_retval)
1.674 +{
1.675 + NS_ASSERTION(_retval, "Bad pointer");
1.676 + static const int size = 32;
1.677 + char buf[size];
1.678 +
1.679 + PR_snprintf(buf, size, "%f", mData);
1.680 +
1.681 + char* result = (char*) nsMemory::Clone(buf,
1.682 + (strlen(buf)+1)*sizeof(char));
1.683 + *_retval = result;
1.684 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.685 +}
1.686 +
1.687 +/***************************************************************************/
1.688 +
1.689 +
1.690 +NS_IMPL_ISUPPORTS(nsSupportsVoidImpl, nsISupportsVoid,
1.691 + nsISupportsPrimitive)
1.692 +
1.693 +nsSupportsVoidImpl::nsSupportsVoidImpl()
1.694 + : mData(nullptr)
1.695 +{
1.696 +}
1.697 +
1.698 +NS_IMETHODIMP nsSupportsVoidImpl::GetType(uint16_t *aType)
1.699 +{
1.700 + NS_ASSERTION(aType, "Bad pointer");
1.701 + *aType = TYPE_VOID;
1.702 +
1.703 + return NS_OK;
1.704 +}
1.705 +
1.706 +NS_IMETHODIMP nsSupportsVoidImpl::GetData(void * *aData)
1.707 +{
1.708 + NS_ASSERTION(aData, "Bad pointer");
1.709 + *aData = mData;
1.710 + return NS_OK;
1.711 +}
1.712 +
1.713 +NS_IMETHODIMP nsSupportsVoidImpl::SetData(void * aData)
1.714 +{
1.715 + mData = aData;
1.716 + return NS_OK;
1.717 +}
1.718 +
1.719 +NS_IMETHODIMP nsSupportsVoidImpl::ToString(char **_retval)
1.720 +{
1.721 + NS_ASSERTION(_retval, "Bad pointer");
1.722 +
1.723 + static const char str[] = "[raw data]";
1.724 + char* result = (char*) nsMemory::Clone(str, sizeof(str));
1.725 + *_retval = result;
1.726 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.727 +}
1.728 +
1.729 +/***************************************************************************/
1.730 +
1.731 +
1.732 +NS_IMPL_ISUPPORTS(nsSupportsInterfacePointerImpl,
1.733 + nsISupportsInterfacePointer,
1.734 + nsISupportsPrimitive)
1.735 +
1.736 +nsSupportsInterfacePointerImpl::nsSupportsInterfacePointerImpl()
1.737 + : mIID(nullptr)
1.738 +{
1.739 +}
1.740 +
1.741 +nsSupportsInterfacePointerImpl::~nsSupportsInterfacePointerImpl()
1.742 +{
1.743 + if (mIID) {
1.744 + nsMemory::Free(mIID);
1.745 + }
1.746 +}
1.747 +
1.748 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetType(uint16_t *aType)
1.749 +{
1.750 + NS_ASSERTION(aType, "Bad pointer");
1.751 + *aType = TYPE_INTERFACE_POINTER;
1.752 +
1.753 + return NS_OK;
1.754 +}
1.755 +
1.756 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetData(nsISupports **aData)
1.757 +{
1.758 + NS_ASSERTION(aData,"Bad pointer");
1.759 +
1.760 + *aData = mData;
1.761 + NS_IF_ADDREF(*aData);
1.762 +
1.763 + return NS_OK;
1.764 +}
1.765 +
1.766 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetData(nsISupports * aData)
1.767 +{
1.768 + mData = aData;
1.769 +
1.770 + return NS_OK;
1.771 +}
1.772 +
1.773 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::GetDataIID(nsID **aIID)
1.774 +{
1.775 + NS_ASSERTION(aIID,"Bad pointer");
1.776 +
1.777 + if(mIID)
1.778 + {
1.779 + *aIID = (nsID*) nsMemory::Clone(mIID, sizeof(nsID));
1.780 + return *aIID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.781 + }
1.782 + *aIID = nullptr;
1.783 + return NS_OK;
1.784 +}
1.785 +
1.786 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::SetDataIID(const nsID *aIID)
1.787 +{
1.788 + if(mIID)
1.789 + nsMemory::Free(mIID);
1.790 + if(aIID)
1.791 + mIID = (nsID*) nsMemory::Clone(aIID, sizeof(nsID));
1.792 + else
1.793 + mIID = nullptr;
1.794 +
1.795 + return NS_OK;
1.796 +}
1.797 +
1.798 +NS_IMETHODIMP nsSupportsInterfacePointerImpl::ToString(char **_retval)
1.799 +{
1.800 + NS_ASSERTION(_retval, "Bad pointer");
1.801 +
1.802 + static const char str[] = "[interface pointer]";
1.803 +
1.804 + // jband sez: think about asking nsIInterfaceInfoManager whether
1.805 + // the interface has a known human-readable name
1.806 + char* result = (char*) nsMemory::Clone(str, sizeof(str));
1.807 + *_retval = result;
1.808 + return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
1.809 +}
1.810 +
1.811 +/***************************************************************************/
1.812 +
1.813 +NS_IMPL_ISUPPORTS(nsSupportsDependentCString,nsISupportsCString,nsISupportsPrimitive)
1.814 +
1.815 +nsSupportsDependentCString::nsSupportsDependentCString(const char* aStr)
1.816 + : mData(aStr)
1.817 +{ }
1.818 +
1.819 +NS_IMETHODIMP
1.820 +nsSupportsDependentCString::GetType(uint16_t *aType)
1.821 +{
1.822 + if (NS_WARN_IF(!aType))
1.823 + return NS_ERROR_INVALID_ARG;
1.824 +
1.825 + *aType = TYPE_CSTRING;
1.826 + return NS_OK;
1.827 +}
1.828 +
1.829 +NS_IMETHODIMP
1.830 +nsSupportsDependentCString::GetData(nsACString& aData)
1.831 +{
1.832 + aData = mData;
1.833 + return NS_OK;
1.834 +}
1.835 +
1.836 +NS_IMETHODIMP
1.837 +nsSupportsDependentCString::ToString(char **_retval)
1.838 +{
1.839 + if (NS_WARN_IF(!_retval))
1.840 + return NS_ERROR_INVALID_ARG;
1.841 +
1.842 + *_retval = ToNewCString(mData);
1.843 + if (!*_retval)
1.844 + return NS_ERROR_OUT_OF_MEMORY;
1.845 +
1.846 + return NS_OK;
1.847 +}
1.848 +
1.849 +NS_IMETHODIMP
1.850 +nsSupportsDependentCString::SetData(const nsACString& aData)
1.851 +{
1.852 + return NS_ERROR_NOT_IMPLEMENTED;
1.853 +}
