mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1344615: Remove nsXPCOMStrings.{h,cpp} r=bsmedberg 

These are now dead code.

MozReview-Commit-ID: AClU0Qx3kmN

--HG--
extra : rebase_source : df83cf89292da1519bb26027c11e14923d5c54a0
This commit is contained in:
David Major 2017-03-06 17:52:54 +13:00
Родитель 058a3a25a4
Коммит ed0b8f8653
21 изменённых файлов: 0 добавлений и 1141 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
accessible/atk/AccessibleWrap.cpp
Просмотреть файл

@ -29,7 +29,6 @@
#include "mozilla/ArrayUtils.h"
#include "mozilla/Sprintf.h"
#include "nsXPCOMStrings.h"
#include "nsComponentManagerUtils.h"
#include "nsIPersistentProperties2.h"

1
caps/nsScriptSecurityManager.cpp
Просмотреть файл

@ -64,7 +64,6 @@
#include "nsContentUtils.h"
#include "nsJSUtils.h"
#include "nsILoadInfo.h"
#include "nsXPCOMStrings.h"
// This should be probably defined on some other place... but I couldn't find it
#define WEBAPPS_PERM_NAME "webapps-manage"

1
dom/html/HTMLMediaElement.cpp
Просмотреть файл

@ -32,7 +32,6 @@
#include "nsError.h"
#include "nsNodeInfoManager.h"
#include "nsNetUtil.h"
#include "nsXPCOMStrings.h"
#include "xpcpublic.h"
#include "nsThreadUtils.h"
#include "nsIThreadInternal.h"

1
dom/html/HTMLVideoElement.cpp
Просмотреть файл

@ -13,7 +13,6 @@
#include "nsError.h"
#include "nsNodeInfoManager.h"
#include "plbase64.h"
#include "nsXPCOMStrings.h"
#include "prlock.h"
#include "nsThreadUtils.h"
#include "ImageContainer.h"

1
dom/json/nsJSON.cpp
Просмотреть файл

@ -15,7 +15,6 @@
#include "mozilla/dom/EncodingUtils.h"
#include "nsIUnicodeEncoder.h"
#include "nsIUnicodeDecoder.h"
#include "nsXPCOMStrings.h"
#include "nsNetUtil.h"
#include "nsIURI.h"
#include "nsComponentManagerUtils.h"

1
dom/media/android/AndroidMediaPluginHost.cpp
Просмотреть файл

@ -10,7 +10,6 @@
#include "mozilla/Services.h"
#include "AndroidMediaPluginHost.h"
#include "nsAutoPtr.h"
#include "nsXPCOMStrings.h"
#include "nsISeekableStream.h"
#include "nsIGfxInfo.h"
#include "gfxCrashReporterUtils.h"

1
dom/media/webspeech/recognition/SpeechGrammarList.cpp
Просмотреть файл

@ -9,7 +9,6 @@
#include "mozilla/dom/SpeechGrammarListBinding.h"
#include "mozilla/ErrorResult.h"
#include "nsCOMPtr.h"
#include "nsXPCOMStrings.h"
#include "SpeechRecognition.h"
namespace mozilla {

1
intl/locale/windows/nsWin32Locale.cpp
Просмотреть файл

@ -7,7 +7,6 @@
#include "nscore.h"
#include "nsString.h"
#include "nsXPCOMStrings.h"
#include "nsReadableUtils.h"
#include "nsWin32Locale.h"
#include <windows.h>

1
intl/unicharutil/util/nsUnicharUtils.cpp
Просмотреть файл

@ -4,7 +4,6 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsUnicharUtils.h"
#include "nsXPCOMStrings.h"
#include "nsUTF8Utils.h"
#include "nsUnicodeProperties.h"
#include "mozilla/Likely.h"

1
parser/html/nsHtml5TreeOperation.h
Просмотреть файл

@ -7,7 +7,6 @@
#include "nsHtml5DocumentMode.h"
#include "nsHtml5HtmlAttributes.h"
#include "nsXPCOMStrings.h"
#include "mozilla/dom/FromParser.h"
class nsIContent;

1
security/manager/ssl/ContentSignatureVerifier.cpp
Просмотреть файл

@ -22,7 +22,6 @@
#include "nsSecurityHeaderParser.h"
#include "nsStreamUtils.h"
#include "nsWhitespaceTokenizer.h"
#include "nsXPCOMStrings.h"
#include "nssb64.h"
#include "pkix/pkix.h"
#include "pkix/pkixtypes.h"

1
startupcache/StartupCache.cpp
Просмотреть файл

@ -6,7 +6,6 @@
#include "prio.h"
#include "PLDHashTable.h"
#include "nsXPCOMStrings.h"
#include "mozilla/IOInterposer.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/scache/StartupCache.h"

1
toolkit/components/downloads/ApplicationReputation.cpp
Просмотреть файл

@ -48,7 +48,6 @@
#include "nsString.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"
#include "nsXPCOMStrings.h"
#include "nsIContentPolicy.h"
#include "nsILoadInfo.h"

1
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
Просмотреть файл

@ -28,7 +28,6 @@
#include "nsTArray.h"
#include "nsNetCID.h"
#include "nsThreadUtils.h"
#include "nsXPCOMStrings.h"
#include "nsProxyRelease.h"
#include "nsString.h"
#include "mozilla/Atomics.h"

1
widget/android/AndroidBridge.cpp
Просмотреть файл

@ -14,7 +14,6 @@
#include "mozilla/Hal.h"
#include "nsXULAppAPI.h"
#include <prthread.h>
#include "nsXPCOMStrings.h"
#include "AndroidBridge.h"
#include "AndroidJNIWrapper.h"
#include "AndroidBridgeUtilities.h"

1
widget/windows/nsDataObj.cpp
Просмотреть файл

@ -26,7 +26,6 @@
#include "nsNetUtil.h"
#include "mozilla/Services.h"
#include "nsIOutputStream.h"
#include "nsXPCOMStrings.h"
#include "nscore.h"
#include "nsDirectoryServiceDefs.h"
#include "nsITimer.h"

1
xpcom/build/moz.build
Просмотреть файл

@ -53,7 +53,6 @@ UNIFIED_SOURCES += [
'IOInterposer.cpp',
'LateWriteChecks.cpp',
'MainThreadIOLogger.cpp',
'nsXPCOMStrings.cpp',
'Services.cpp',
'XPCOMInit.cpp',
]

366
xpcom/build/nsXPCOMStrings.cpp
Просмотреть файл

@ -1,366 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsString.h"
#include "nsCharTraits.h"
#include "nsXPCOMStrings.h"
#include "nsNativeCharsetUtils.h"
/* ------------------------------------------------------------------------- */
XPCOM_API(nsresult)
NS_StringContainerInit(nsStringContainer& aContainer)
{
NS_ASSERTION(sizeof(nsStringContainer_base) >= sizeof(nsString),
"nsStringContainer is not large enough");
// use placement new to avoid heap allocating nsString object
new (&aContainer) nsString();
return NS_OK;
}
XPCOM_API(nsresult)
NS_StringContainerInit2(nsStringContainer& aContainer,
const char16_t* aData,
uint32_t aDataLength,
uint32_t aFlags)
{
NS_ASSERTION(sizeof(nsStringContainer_base) >= sizeof(nsString),
"nsStringContainer is not large enough");
if (!aData) {
new (&aContainer) nsString();
} else {
if (aDataLength == UINT32_MAX) {
if (NS_WARN_IF(aFlags & NS_STRING_CONTAINER_INIT_SUBSTRING)) {
return NS_ERROR_INVALID_ARG;
}
aDataLength = nsCharTraits<char16_t>::length(aData);
}
if (aFlags & (NS_STRING_CONTAINER_INIT_DEPEND |
NS_STRING_CONTAINER_INIT_ADOPT)) {
uint32_t flags;
if (aFlags & NS_STRING_CONTAINER_INIT_SUBSTRING) {
flags = nsSubstring::F_NONE;
} else {
flags = nsSubstring::F_TERMINATED;
}
if (aFlags & NS_STRING_CONTAINER_INIT_ADOPT) {
flags |= nsSubstring::F_OWNED;
}
new (&aContainer) nsSubstring(const_cast<char16_t*>(aData),
aDataLength, flags);
} else {
new (&aContainer) nsString(aData, aDataLength);
}
}
return NS_OK;
}
XPCOM_API(void)
NS_StringContainerFinish(nsStringContainer& aContainer)
{
// call the nsString dtor
reinterpret_cast<nsString*>(&aContainer)->~nsString();
}
/* ------------------------------------------------------------------------- */
XPCOM_API(uint32_t)
NS_StringGetData(const nsAString& aStr, const char16_t** aData,
bool* aTerminated)
{
if (aTerminated) {
*aTerminated = aStr.IsTerminated();
}
*aData = aStr.BeginReading();
return aStr.Length();
}
XPCOM_API(uint32_t)
NS_StringGetMutableData(nsAString& aStr, uint32_t aDataLength,
char16_t** aData)
{
if (aDataLength != UINT32_MAX) {
aStr.SetLength(aDataLength);
if (aStr.Length() != aDataLength) {
*aData = nullptr;
return 0;
}
}
*aData = aStr.BeginWriting();
return aStr.Length();
}
XPCOM_API(char16_t*)
NS_StringCloneData(const nsAString& aStr)
{
return ToNewUnicode(aStr);
}
XPCOM_API(nsresult)
NS_StringSetData(nsAString& aStr, const char16_t* aData, uint32_t aDataLength)
{
aStr.Assign(aData, aDataLength);
return NS_OK; // XXX report errors
}
XPCOM_API(nsresult)
NS_StringSetDataRange(nsAString& aStr,
uint32_t aCutOffset, uint32_t aCutLength,
const char16_t* aData, uint32_t aDataLength)
{
if (aCutOffset == UINT32_MAX) {
// append case
if (aData) {
aStr.Append(aData, aDataLength);
}
return NS_OK; // XXX report errors
}
if (aCutLength == UINT32_MAX) {
aCutLength = aStr.Length() - aCutOffset;
}
if (aData) {
if (aDataLength == UINT32_MAX) {
aStr.Replace(aCutOffset, aCutLength, nsDependentString(aData));
} else {
aStr.Replace(aCutOffset, aCutLength, Substring(aData, aDataLength));
}
} else {
aStr.Cut(aCutOffset, aCutLength);
}
return NS_OK; // XXX report errors
}
XPCOM_API(nsresult)
NS_StringCopy(nsAString& aDest, const nsAString& aSrc)
{
aDest.Assign(aSrc);
return NS_OK; // XXX report errors
}
XPCOM_API(void)
NS_StringSetIsVoid(nsAString& aStr, const bool aIsVoid)
{
aStr.SetIsVoid(aIsVoid);
}
XPCOM_API(bool)
NS_StringGetIsVoid(const nsAString& aStr)
{
return aStr.IsVoid();
}
/* ------------------------------------------------------------------------- */
XPCOM_API(nsresult)
NS_CStringContainerInit(nsCStringContainer& aContainer)
{
NS_ASSERTION(sizeof(nsStringContainer_base) >= sizeof(nsCString),
"nsCStringContainer is not large enough");
// use placement new to avoid heap allocating nsCString object
new (&aContainer) nsCString();
return NS_OK;
}
XPCOM_API(nsresult)
NS_CStringContainerInit2(nsCStringContainer& aContainer,
const char* aData,
uint32_t aDataLength,
uint32_t aFlags)
{
NS_ASSERTION(sizeof(nsStringContainer_base) >= sizeof(nsCString),
"nsStringContainer is not large enough");
if (!aData) {
new (&aContainer) nsCString();
} else {
if (aDataLength == UINT32_MAX) {
if (NS_WARN_IF(aFlags & NS_CSTRING_CONTAINER_INIT_SUBSTRING)) {
return NS_ERROR_INVALID_ARG;
}
aDataLength = nsCharTraits<char>::length(aData);
}
if (aFlags & (NS_CSTRING_CONTAINER_INIT_DEPEND |
NS_CSTRING_CONTAINER_INIT_ADOPT)) {
uint32_t flags;
if (aFlags & NS_CSTRING_CONTAINER_INIT_SUBSTRING) {
flags = nsCSubstring::F_NONE;
} else {
flags = nsCSubstring::F_TERMINATED;
}
if (aFlags & NS_CSTRING_CONTAINER_INIT_ADOPT) {
flags |= nsCSubstring::F_OWNED;
}
new (&aContainer) nsCSubstring(const_cast<char*>(aData),
aDataLength, flags);
} else {
new (&aContainer) nsCString(aData, aDataLength);
}
}
return NS_OK;
}
XPCOM_API(void)
NS_CStringContainerFinish(nsCStringContainer& aContainer)
{
// call the nsCString dtor
reinterpret_cast<nsCString*>(&aContainer)->~nsCString();
}
/* ------------------------------------------------------------------------- */
XPCOM_API(uint32_t)
NS_CStringGetData(const nsACString& aStr, const char** aData,
bool* aTerminated)
{
if (aTerminated) {
*aTerminated = aStr.IsTerminated();
}
*aData = aStr.BeginReading();
return aStr.Length();
}
XPCOM_API(uint32_t)
NS_CStringGetMutableData(nsACString& aStr, uint32_t aDataLength, char** aData)
{
if (aDataLength != UINT32_MAX) {
aStr.SetLength(aDataLength);
if (aStr.Length() != aDataLength) {
*aData = nullptr;
return 0;
}
}
*aData = aStr.BeginWriting();
return aStr.Length();
}
XPCOM_API(char*)
NS_CStringCloneData(const nsACString& aStr)
{
return ToNewCString(aStr);
}
XPCOM_API(nsresult)
NS_CStringSetData(nsACString& aStr, const char* aData, uint32_t aDataLength)
{
aStr.Assign(aData, aDataLength);
return NS_OK; // XXX report errors
}
XPCOM_API(nsresult)
NS_CStringSetDataRange(nsACString& aStr,
uint32_t aCutOffset, uint32_t aCutLength,
const char* aData, uint32_t aDataLength)
{
if (aCutOffset == UINT32_MAX) {
// append case
if (aData) {
aStr.Append(aData, aDataLength);
}
return NS_OK; // XXX report errors
}
if (aCutLength == UINT32_MAX) {
aCutLength = aStr.Length() - aCutOffset;
}
if (aData) {
if (aDataLength == UINT32_MAX) {
aStr.Replace(aCutOffset, aCutLength, nsDependentCString(aData));
} else {
aStr.Replace(aCutOffset, aCutLength, Substring(aData, aDataLength));
}
} else {
aStr.Cut(aCutOffset, aCutLength);
}
return NS_OK; // XXX report errors
}
XPCOM_API(nsresult)
NS_CStringCopy(nsACString& aDest, const nsACString& aSrc)
{
aDest.Assign(aSrc);
return NS_OK; // XXX report errors
}
XPCOM_API(void)
NS_CStringSetIsVoid(nsACString& aStr, const bool aIsVoid)
{
aStr.SetIsVoid(aIsVoid);
}
XPCOM_API(bool)
NS_CStringGetIsVoid(const nsACString& aStr)
{
return aStr.IsVoid();
}
/* ------------------------------------------------------------------------- */
XPCOM_API(nsresult)
NS_CStringToUTF16(const nsACString& aSrc,
nsCStringEncoding aSrcEncoding,
nsAString& aDest)
{
switch (aSrcEncoding) {
case NS_CSTRING_ENCODING_ASCII:
CopyASCIItoUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_UTF8:
CopyUTF8toUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM:
NS_CopyNativeToUnicode(aSrc, aDest);
break;
default:
return NS_ERROR_NOT_IMPLEMENTED;
}
return NS_OK; // XXX report errors
}
XPCOM_API(nsresult)
NS_UTF16ToCString(const nsAString& aSrc,
nsCStringEncoding aDestEncoding,
nsACString& aDest)
{
switch (aDestEncoding) {
case NS_CSTRING_ENCODING_ASCII:
LossyCopyUTF16toASCII(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_UTF8:
CopyUTF16toUTF8(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM:
NS_CopyUnicodeToNative(aSrc, aDest);
break;
default:
return NS_ERROR_NOT_IMPLEMENTED;
}
return NS_OK; // XXX report errors
}

1
xpcom/string/moz.build
Просмотреть файл

@ -31,7 +31,6 @@ EXPORTS += [
'nsTSubstring.h',
'nsTSubstringTuple.h',
'nsUTF8Utils.h',
'nsXPCOMStrings.h',
'nsXPIDLString.h',
'string-template-def-char.h',
'string-template-def-unichar.h',

9
xpcom/string/nsSubstring.cpp
Просмотреть файл

@ -343,15 +343,6 @@ nsStringBuffer::SizeOfIncludingThisEvenIfShared(mozilla::MallocSizeOf aMallocSiz
#include "nsTSubstring.cpp"
#include "string-template-undef.h"
// Check that internal and external strings have the same size.
// See https://bugzilla.mozilla.org/show_bug.cgi?id=430581
#include "mozilla/Logging.h"
#include "nsXPCOMStrings.h"
static_assert(sizeof(nsStringContainer_base) == sizeof(nsSubstring),
"internal and external strings must have the same size");
// Provide rust bindings to the nsA[C]String types
extern "C" {

748
xpcom/string/nsXPCOMStrings.h
Просмотреть файл

@ -1,748 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsXPCOMStrings_h__
#define nsXPCOMStrings_h__
#include <string.h>
#include "nscore.h"
#include <limits>
/**
* nsXPCOMStrings.h
*
* This file describes a minimal API for working with XPCOM's abstract
* string classes. It divorces the consumer from having any run-time
* dependency on the implementation details of the abstract string types.
*/
#include "nscore.h"
/* The base string types */
class nsAString;
class nsACString;
/* ------------------------------------------------------------------------- */
/**
* nsStringContainer
*
* This is an opaque data type that is large enough to hold the canonical
* implementation of nsAString. The binary structure of this class is an
* implementation detail.
*
* The string data stored in a string container is always single fragment
* and may be null-terminated depending on how it is initialized.
*
* Typically, string containers are allocated on the stack for temporary
* use. However, they can also be malloc'd if necessary. In either case,
* a string container is not useful until it has been initialized with a
* call to NS_StringContainerInit. The following example shows how to use
* a string container to call a function that takes a |nsAString &| out-param.
*
* nsresult GetBlah(nsAString &aBlah);
*
* nsresult MyCode()
* {
* nsresult rv;
*
* nsStringContainer sc;
* rv = NS_StringContainerInit(sc);
* if (NS_FAILED(rv))
* return rv;
*
* rv = GetBlah(sc);
* if (NS_SUCCEEDED(rv))
* {
* const char16_t *data;
* NS_StringGetData(sc, &data);
* //
* // |data| now points to the result of the GetBlah function
* //
* }
*
* NS_StringContainerFinish(sc);
* return rv;
* }
*
* The following example show how to use a string container to pass a string
* parameter to a function taking a |const nsAString &| in-param.
*
* nsresult SetBlah(const nsAString &aBlah);
*
* nsresult MyCode()
* {
* nsresult rv;
*
* nsStringContainer sc;
* rv = NS_StringContainerInit(sc);
* if (NS_FAILED(rv))
* return rv;
*
* const char16_t kData[] = {'x','y','z','\0'};
* rv = NS_StringSetData(sc, kData, sizeof(kData)/2 - 1);
* if (NS_SUCCEEDED(rv))
* rv = SetBlah(sc);
*
* NS_StringContainerFinish(sc);
* return rv;
* }
*/
class nsStringContainer;
/**
* This struct is never used directly. It is designed to have the same
* size as nsString. It can be stack and heap allocated and the internal
* functions cast it to nsString.
* While this practice is a strict aliasing violation, it doesn't seem to
* cause problems since the the struct is only accessed via the casts to
* nsString.
* We use protected instead of private to avoid compiler warnings about
* the members being unused.
*/
struct nsStringContainer_base
{
protected:
void* d1;
uint32_t d2;
uint32_t d3;
};
/**
* Flags that may be OR'd together to pass to NS_StringContainerInit2:
*/
enum
{
/* Data passed into NS_StringContainerInit2 is not copied; instead, the
* string references the passed in data pointer directly. The caller must
* ensure that the data is valid for the lifetime of the string container.
* This flag should not be combined with NS_STRING_CONTAINER_INIT_ADOPT. */
NS_STRING_CONTAINER_INIT_DEPEND = (1 << 1),
/* Data passed into NS_StringContainerInit2 is not copied; instead, the
* string takes ownership over the data pointer. The caller must have
* allocated the data array using the XPCOM memory allocator (nsMemory).
* This flag should not be combined with NS_STRING_CONTAINER_INIT_DEPEND. */
NS_STRING_CONTAINER_INIT_ADOPT = (1 << 2),
/* Data passed into NS_StringContainerInit2 is a substring that is not
* null-terminated. */
NS_STRING_CONTAINER_INIT_SUBSTRING = (1 << 3)
};
/**
* NS_StringContainerInit
*
* @param aContainer string container reference
* @return NS_OK if string container successfully initialized
*
* This function may allocate additional memory for aContainer. When
* aContainer is no longer needed, NS_StringContainerFinish should be called.
*/
XPCOM_API(nsresult) NS_StringContainerInit(nsStringContainer& aContainer);
/**
* NS_StringContainerInit2
*
* @param aContainer string container reference
* @param aData character buffer (may be null)
* @param aDataLength number of characters stored at aData (may pass
* UINT32_MAX if aData is null-terminated)
* @param aFlags flags affecting how the string container is
* initialized. this parameter is ignored when aData
* is null. otherwise, if this parameter is 0, then
* aData is copied into the string.
*
* This function resembles NS_StringContainerInit but provides further
* options that permit more efficient memory usage. When aContainer is
* no longer needed, NS_StringContainerFinish should be called.
*
* NOTE: NS_StringContainerInit2(container, nullptr, 0, 0) is equivalent to
* NS_StringContainerInit(container).
*/
XPCOM_API(nsresult) NS_StringContainerInit2(nsStringContainer& aContainer,
const char16_t* aData = nullptr,
uint32_t aDataLength = UINT32_MAX,
uint32_t aFlags = 0);
/**
* NS_StringContainerFinish
*
* @param aContainer string container reference
*
* This function frees any memory owned by aContainer.
*/
XPCOM_API(void) NS_StringContainerFinish(nsStringContainer& aContainer);
/* ------------------------------------------------------------------------- */
/**
* NS_StringGetData
*
* This function returns a const character pointer to the string's internal
* buffer, the length of the string, and a boolean value indicating whether
* or not the buffer is null-terminated.
*
* @param aStr abstract string reference
* @param aData out param that will hold the address of aStr's
* internal buffer
* @param aTerminated if non-null, this out param will be set to indicate
* whether or not aStr's internal buffer is null-
* terminated
* @return length of aStr's internal buffer
*/
XPCOM_API(uint32_t) NS_StringGetData(const nsAString& aStr,
const char16_t** aData,
bool* aTerminated = nullptr);
/**
* NS_StringGetMutableData
*
* This function provides mutable access to a string's internal buffer. It
* returns a pointer to an array of characters that may be modified. The
* returned pointer remains valid until the string object is passed to some
* other string function.
*
* Optionally, this function may be used to resize the string's internal
* buffer. The aDataLength parameter specifies the requested length of the
* string's internal buffer. By passing some value other than UINT32_MAX,
* the caller can request that the buffer be resized to the specified number of
* characters before returning. The caller is not responsible for writing a
* null-terminator.
*
* @param aStr abstract string reference
* @param aDataLength number of characters to resize the string's internal
* buffer to or UINT32_MAX if no resizing is needed
* @param aData out param that upon return holds the address of aStr's
* internal buffer or null if the function failed
* @return number of characters or zero if the function failed
*
* This function does not necessarily null-terminate aStr after resizing its
* internal buffer. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(uint32_t) NS_StringGetMutableData(nsAString& aStr,
uint32_t aDataLength,
char16_t** aData);
/**
* NS_StringCloneData
*
* This function returns a null-terminated copy of the string's
* internal buffer.
*
* @param aStr abstract string reference
* @return null-terminated copy of the string's internal buffer
* (it must be free'd using using free)
*/
XPCOM_API(char16_t*) NS_StringCloneData(const nsAString& aStr);
/**
* NS_StringSetData
*
* This function copies aData into aStr.
*
* @param aStr abstract string reference
* @param aData character buffer
* @param aDataLength number of characters to copy from source string (pass
* UINT32_MAX to copy until end of aData, designated by
* a null character)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr after copying data
* from aData. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_StringSetData(nsAString& aStr, const char16_t* aData,
uint32_t aDataLength = UINT32_MAX);
/**
* NS_StringSetDataRange
*
* This function copies aData into a section of aStr. As a result it can be
* used to insert new characters into the string.
*
* @param aStr abstract string reference
* @param aCutOffset starting index where the string's existing data
* is to be overwritten (pass UINT32_MAX to cause
* aData to be appended to the end of aStr, in which
* case the value of aCutLength is ignored).
* @param aCutLength number of characters to overwrite starting at
* aCutOffset (pass UINT32_MAX to overwrite until the
* end of aStr).
* @param aData character buffer (pass null to cause this function
* to simply remove the "cut" range)
* @param aDataLength number of characters to copy from source string (pass
* UINT32_MAX to copy until end of aData, designated by
* a null character)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr after copying data
* from aData. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_StringSetDataRange(nsAString& aStr,
uint32_t aCutOffset, uint32_t aCutLength,
const char16_t* aData,
uint32_t aDataLength = UINT32_MAX);
/**
* NS_StringCopy
*
* This function makes aDestStr have the same value as aSrcStr. It is
* provided as an optimization.
*
* @param aDestStr abstract string reference to be modified
* @param aSrcStr abstract string reference containing source string
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aDestStr after copying
* data from aSrcStr. The behavior depends on the implementation of the
* abstract string, aDestStr. If aDestStr is a reference to a
* nsStringContainer, then its data will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_StringCopy(nsAString& aDestStr,
const nsAString& aSrcStr);
/**
* NS_StringAppendData
*
* This function appends data to the existing value of aStr.
*
* @param aStr abstract string reference to be modified
* @param aData character buffer
* @param aDataLength number of characters to append (pass UINT32_MAX to
* append until a null-character is encountered)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr upon completion.
* The behavior depends on the implementation of the abstract string, aStr.
* If aStr is a reference to a nsStringContainer, then its data will be null-
* terminated by this function.
*/
inline NS_HIDDEN_(nsresult)
NS_StringAppendData(nsAString& aStr, const char16_t* aData,
uint32_t aDataLength = UINT32_MAX)
{
return NS_StringSetDataRange(aStr, UINT32_MAX, 0, aData, aDataLength);
}
/**
* NS_StringInsertData
*
* This function inserts data into the existing value of aStr at the specified
* offset.
*
* @param aStr abstract string reference to be modified
* @param aOffset specifies where in the string to insert aData
* @param aData character buffer
* @param aDataLength number of characters to append (pass UINT32_MAX to
* append until a null-character is encountered)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr upon completion.
* The behavior depends on the implementation of the abstract string, aStr.
* If aStr is a reference to a nsStringContainer, then its data will be null-
* terminated by this function.
*/
inline NS_HIDDEN_(nsresult)
NS_StringInsertData(nsAString& aStr, uint32_t aOffset, const char16_t* aData,
uint32_t aDataLength = UINT32_MAX)
{
return NS_StringSetDataRange(aStr, aOffset, 0, aData, aDataLength);
}
/**
* NS_StringCutData
*
* This function shortens the existing value of aStr, by removing characters
* at the specified offset.
*
* @param aStr abstract string reference to be modified
* @param aCutOffset specifies where in the string to insert aData
* @param aCutLength number of characters to remove
* @return NS_OK if function succeeded
*/
inline NS_HIDDEN_(nsresult)
NS_StringCutData(nsAString& aStr, uint32_t aCutOffset, uint32_t aCutLength)
{
return NS_StringSetDataRange(aStr, aCutOffset, aCutLength, nullptr, 0);
}
/**
* NS_StringSetIsVoid
*
* This function marks a string as being a "void string". Any data in the
* string will be lost.
*/
XPCOM_API(void) NS_StringSetIsVoid(nsAString& aStr, const bool aIsVoid);
/**
* NS_StringGetIsVoid
*
* This function provides a way to test if a string is a "void string", as
* marked by NS_StringSetIsVoid.
*/
XPCOM_API(bool) NS_StringGetIsVoid(const nsAString& aStr);
/* ------------------------------------------------------------------------- */
/**
* nsCStringContainer
*
* This is an opaque data type that is large enough to hold the canonical
* implementation of nsACString. The binary structure of this class is an
* implementation detail.
*
* The string data stored in a string container is always single fragment
* and may be null-terminated depending on how it is initialized.
*
* @see nsStringContainer for use cases and further documentation.
*/
class nsCStringContainer;
/**
* Flags that may be OR'd together to pass to NS_StringContainerInit2:
*/
enum
{
/* Data passed into NS_CStringContainerInit2 is not copied; instead, the
* string references the passed in data pointer directly. The caller must
* ensure that the data is valid for the lifetime of the string container.
* This flag should not be combined with NS_CSTRING_CONTAINER_INIT_ADOPT. */
NS_CSTRING_CONTAINER_INIT_DEPEND = (1 << 1),
/* Data passed into NS_CStringContainerInit2 is not copied; instead, the
* string takes ownership over the data pointer. The caller must have
* allocated the data array using the XPCOM memory allocator (nsMemory).
* This flag should not be combined with NS_CSTRING_CONTAINER_INIT_DEPEND. */
NS_CSTRING_CONTAINER_INIT_ADOPT = (1 << 2),
/* Data passed into NS_CStringContainerInit2 is a substring that is not
* null-terminated. */
NS_CSTRING_CONTAINER_INIT_SUBSTRING = (1 << 3)
};
/**
* NS_CStringContainerInit
*
* @param aContainer string container reference
* @return NS_OK if string container successfully initialized
*
* This function may allocate additional memory for aContainer. When
* aContainer is no longer needed, NS_CStringContainerFinish should be called.
*/
XPCOM_API(nsresult) NS_CStringContainerInit(nsCStringContainer& aContainer);
/**
* NS_CStringContainerInit2
*
* @param aContainer string container reference
* @param aData character buffer (may be null)
* @param aDataLength number of characters stored at aData (may pass
* UINT32_MAX if aData is null-terminated)
* @param aFlags flags affecting how the string container is
* initialized. this parameter is ignored when aData
* is null. otherwise, if this parameter is 0, then
* aData is copied into the string.
*
* This function resembles NS_CStringContainerInit but provides further
* options that permit more efficient memory usage. When aContainer is
* no longer needed, NS_CStringContainerFinish should be called.
*
* NOTE: NS_CStringContainerInit2(container, nullptr, 0, 0) is equivalent to
* NS_CStringContainerInit(container).
*/
XPCOM_API(nsresult) NS_CStringContainerInit2(nsCStringContainer& aContainer,
const char* aData = nullptr,
uint32_t aDataLength = UINT32_MAX,
uint32_t aFlags = 0);
/**
* NS_CStringContainerFinish
*
* @param aContainer string container reference
*
* This function frees any memory owned by aContainer.
*/
XPCOM_API(void) NS_CStringContainerFinish(nsCStringContainer& aContainer);
/* ------------------------------------------------------------------------- */
/**
* NS_CStringGetData
*
* This function returns a const character pointer to the string's internal
* buffer, the length of the string, and a boolean value indicating whether
* or not the buffer is null-terminated.
*
* @param aStr abstract string reference
* @param aData out param that will hold the address of aStr's
* internal buffer
* @param aTerminated if non-null, this out param will be set to indicate
* whether or not aStr's internal buffer is null-
* terminated
* @return length of aStr's internal buffer
*/
XPCOM_API(uint32_t) NS_CStringGetData(const nsACString& aStr,
const char** aData,
bool* aTerminated = nullptr);
/**
* NS_CStringGetMutableData
*
* This function provides mutable access to a string's internal buffer. It
* returns a pointer to an array of characters that may be modified. The
* returned pointer remains valid until the string object is passed to some
* other string function.
*
* Optionally, this function may be used to resize the string's internal
* buffer. The aDataLength parameter specifies the requested length of the
* string's internal buffer. By passing some value other than UINT32_MAX,
* the caller can request that the buffer be resized to the specified number of
* characters before returning. The caller is not responsible for writing a
* null-terminator.
*
* @param aStr abstract string reference
* @param aDataLength number of characters to resize the string's internal
* buffer to or UINT32_MAX if no resizing is needed
* @param aData out param that upon return holds the address of aStr's
* internal buffer or null if the function failed
* @return number of characters or zero if the function failed
*
* This function does not necessarily null-terminate aStr after resizing its
* internal buffer. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(uint32_t) NS_CStringGetMutableData(nsACString& aStr,
uint32_t aDataLength,
char** aData);
/**
* NS_CStringCloneData
*
* This function returns a null-terminated copy of the string's
* internal buffer.
*
* @param aStr abstract string reference
* @return null-terminated copy of the string's internal buffer
* (it must be free'd using using free)
*/
XPCOM_API(char*) NS_CStringCloneData(const nsACString& aStr);
/**
* NS_CStringSetData
*
* This function copies aData into aStr.
*
* @param aStr abstract string reference
* @param aData character buffer
* @param aDataLength number of characters to copy from source string (pass
* UINT32_MAX to copy until end of aData, designated by
* a null character)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr after copying data
* from aData. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_CStringSetData(nsACString& aStr, const char* aData,
uint32_t aDataLength = UINT32_MAX);
/**
* NS_CStringSetDataRange
*
* This function copies aData into a section of aStr. As a result it can be
* used to insert new characters into the string.
*
* @param aStr abstract string reference
* @param aCutOffset starting index where the string's existing data
* is to be overwritten (pass UINT32_MAX to cause
* aData to be appended to the end of aStr, in which
* case the value of aCutLength is ignored).
* @param aCutLength number of characters to overwrite starting at
* aCutOffset (pass UINT32_MAX to overwrite until the
* end of aStr).
* @param aData character buffer (pass null to cause this function
* to simply remove the "cut" range)
* @param aDataLength number of characters to copy from source string (pass
* UINT32_MAX to copy until end of aData, designated by
* a null character)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr after copying data
* from aData. The behavior depends on the implementation of the abstract
* string, aStr. If aStr is a reference to a nsStringContainer, then its data
* will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_CStringSetDataRange(nsACString& aStr,
uint32_t aCutOffset,
uint32_t aCutLength,
const char* aData,
uint32_t aDataLength = UINT32_MAX);
/**
* NS_CStringCopy
*
* This function makes aDestStr have the same value as aSrcStr. It is
* provided as an optimization.
*
* @param aDestStr abstract string reference to be modified
* @param aSrcStr abstract string reference containing source string
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aDestStr after copying
* data from aSrcStr. The behavior depends on the implementation of the
* abstract string, aDestStr. If aDestStr is a reference to a
* nsStringContainer, then its data will be null-terminated by this function.
*/
XPCOM_API(nsresult) NS_CStringCopy(nsACString& aDestStr,
const nsACString& aSrcStr);
/**
* NS_CStringAppendData
*
* This function appends data to the existing value of aStr.
*
* @param aStr abstract string reference to be modified
* @param aData character buffer
* @param aDataLength number of characters to append (pass UINT32_MAX to
* append until a null-character is encountered)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr upon completion.
* The behavior depends on the implementation of the abstract string, aStr.
* If aStr is a reference to a nsStringContainer, then its data will be null-
* terminated by this function.
*/
inline NS_HIDDEN_(nsresult)
NS_CStringAppendData(nsACString& aStr, const char* aData,
uint32_t aDataLength = UINT32_MAX)
{
return NS_CStringSetDataRange(aStr, UINT32_MAX, 0, aData, aDataLength);
}
/**
* NS_CStringInsertData
*
* This function inserts data into the existing value of aStr at the specified
* offset.
*
* @param aStr abstract string reference to be modified
* @param aOffset specifies where in the string to insert aData
* @param aData character buffer
* @param aDataLength number of characters to append (pass UINT32_MAX to
* append until a null-character is encountered)
* @return NS_OK if function succeeded
*
* This function does not necessarily null-terminate aStr upon completion.
* The behavior depends on the implementation of the abstract string, aStr.
* If aStr is a reference to a nsStringContainer, then its data will be null-
* terminated by this function.
*/
inline NS_HIDDEN_(nsresult)
NS_CStringInsertData(nsACString& aStr, uint32_t aOffset, const char* aData,
uint32_t aDataLength = UINT32_MAX)
{
return NS_CStringSetDataRange(aStr, aOffset, 0, aData, aDataLength);
}
/**
* NS_CStringCutData
*
* This function shortens the existing value of aStr, by removing characters
* at the specified offset.
*
* @param aStr abstract string reference to be modified
* @param aCutOffset specifies where in the string to insert aData
* @param aCutLength number of characters to remove
* @return NS_OK if function succeeded
*/
inline NS_HIDDEN_(nsresult)
NS_CStringCutData(nsACString& aStr, uint32_t aCutOffset, uint32_t aCutLength)
{
return NS_CStringSetDataRange(aStr, aCutOffset, aCutLength, nullptr, 0);
}
/**
* NS_CStringSetIsVoid
*
* This function marks a string as being a "void string". Any data in the
* string will be lost.
*/
XPCOM_API(void) NS_CStringSetIsVoid(nsACString& aStr, const bool aIsVoid);
/**
* NS_CStringGetIsVoid
*
* This function provides a way to test if a string is a "void string", as
* marked by NS_CStringSetIsVoid.
*/
XPCOM_API(bool) NS_CStringGetIsVoid(const nsACString& aStr);
/* ------------------------------------------------------------------------- */
/**
* Encodings that can be used with the following conversion routines.
*/
enum nsCStringEncoding
{
/* Conversion between ASCII and UTF-16 assumes that all bytes in the source
* string are 7-bit ASCII and can be inflated to UTF-16 by inserting null
* bytes. Reverse conversion is done by truncating every other byte. The
* conversion may result in loss and/or corruption of information if the
* strings do not strictly contain ASCII data. */
NS_CSTRING_ENCODING_ASCII = 0,
/* Conversion between UTF-8 and UTF-16 is non-lossy. */
NS_CSTRING_ENCODING_UTF8 = 1,
/* Conversion from UTF-16 to the native filesystem charset may result in a
* loss of information. No attempt is made to protect against data loss in
* this case. The native filesystem charset applies to strings passed to
* the "Native" method variants on nsIFile. */
NS_CSTRING_ENCODING_NATIVE_FILESYSTEM = 2
};
/**
* NS_CStringToUTF16
*
* This function converts the characters in a nsACString to an array of UTF-16
* characters, in the platform endianness. The result is stored in a nsAString
* object.
*
* @param aSource abstract string reference containing source string
* @param aSrcEncoding character encoding of the source string
* @param aDest abstract string reference to hold the result
*/
XPCOM_API(nsresult) NS_CStringToUTF16(const nsACString& aSource,
nsCStringEncoding aSrcEncoding,
nsAString& aDest);
/**
* NS_UTF16ToCString
*
* This function converts the UTF-16 characters in a nsAString to a single-byte
* encoding. The result is stored in a nsACString object. In some cases this
* conversion may be lossy. In such cases, the conversion may succeed with a
* return code indicating loss of information. The exact behavior is not
* specified at this time.
*
* @param aSource abstract string reference containing source string
* @param aDestEncoding character encoding of the resulting string
* @param aDest abstract string reference to hold the result
*/
XPCOM_API(nsresult) NS_UTF16ToCString(const nsAString& aSource,
nsCStringEncoding aDestEncoding,
nsACString& aDest);
#endif // nsXPCOMStrings_h__