зеркало из https://github.com/mozilla/gecko-dev.git
814 строки
23 KiB
C++
814 строки
23 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
|
|
/***********************************************************************
|
|
MODULE NOTES:
|
|
|
|
A. There are two philosophies to building string classes:
|
|
1. Hide the underlying buffer & offer API's allow indirect iteration
|
|
2. Reveal underlying buffer, risk corruption, but gain performance
|
|
|
|
We chose the second option for performance reasons.
|
|
|
|
B Our internal buffer always holds capacity+1 bytes.
|
|
***********************************************************************/
|
|
|
|
|
|
#ifndef _NSSTRING
|
|
#define _NSSTRING
|
|
|
|
|
|
#include "prtypes.h"
|
|
#include "nscore.h"
|
|
#include "nsIAtom.h"
|
|
#include <iostream.h>
|
|
#include <stdio.h>
|
|
class nsISizeOfHandler;
|
|
|
|
class NS_BASE nsString {
|
|
public:
|
|
|
|
/**
|
|
* Default constructor. Note that we actually allocate a small buffer
|
|
* to begin with. This is because the "philosophy" of the string class
|
|
* was to allow developers direct access to the underlying buffer for
|
|
* performance reasons.
|
|
*/
|
|
nsString();
|
|
|
|
/**
|
|
* This constructor accepts an isolatin string
|
|
* @param an ascii is a ptr to a 1-byte cstr
|
|
*/
|
|
nsString(const char* aCString);
|
|
|
|
/**
|
|
* This is our copy constructor
|
|
* @param reference to another nsString
|
|
*/
|
|
nsString(const nsString&);
|
|
|
|
/**
|
|
* Constructor from a unicode string
|
|
* @param anicodestr pts to a unicode string
|
|
*/
|
|
nsString(const PRUnichar* aUnicode);
|
|
|
|
/**
|
|
* Virtual Destructor
|
|
*/
|
|
virtual ~nsString();
|
|
|
|
|
|
/**
|
|
* Retrieve the length of this string
|
|
* @return string length
|
|
*/
|
|
PRInt32 Length() const { return mLength; }
|
|
|
|
|
|
/**
|
|
* Sets the new length of the string.
|
|
* @param aLength is new string length.
|
|
* @return nada
|
|
*/
|
|
void SetLength(PRInt32 aLength);
|
|
|
|
/**
|
|
* This method truncates this string to given length.
|
|
*
|
|
* @param anIndex -- new length of string
|
|
* @return nada
|
|
*/
|
|
void Truncate(PRInt32 anIndex=0);
|
|
|
|
|
|
/**
|
|
* This method gets called when the internal buffer needs
|
|
* to grow to a given size.
|
|
* @param aNewLength -- new capacity of string
|
|
* @return void
|
|
*/
|
|
virtual void EnsureCapacityFor(PRInt32 aNewLength);
|
|
|
|
/**
|
|
*
|
|
* @param
|
|
*/
|
|
virtual void SizeOf(nsISizeOfHandler* aHandler) const;
|
|
|
|
/**
|
|
* Determine whether or not the characters in this
|
|
* string are in sorted order.
|
|
*
|
|
* @return TRUE if ordered.
|
|
*/
|
|
PRBool IsOrdered(void) const;
|
|
|
|
/**********************************************************************
|
|
Accessor methods...
|
|
*********************************************************************/
|
|
|
|
/**
|
|
* Retrieve pointer to internal string value
|
|
* @return PRUnichar* to internal string
|
|
*/
|
|
const PRUnichar* GetUnicode(void) const;
|
|
|
|
/**
|
|
*
|
|
* @param
|
|
* @return
|
|
*/
|
|
operator const PRUnichar*() const;
|
|
|
|
/**
|
|
* Retrieve unicode char at given index
|
|
* @param offset into string
|
|
* @return PRUnichar* to internal string
|
|
*/
|
|
PRUnichar operator()(PRInt32 anIndex) const;
|
|
|
|
/**
|
|
* Retrieve reference to unicode char at given index
|
|
* @param offset into string
|
|
* @return PRUnichar& from internal string
|
|
*/
|
|
PRUnichar& operator[](PRInt32 anIndex) const;
|
|
|
|
/**
|
|
* Retrieve reference to unicode char at given index
|
|
* @param offset into string
|
|
* @return PRUnichar& from internal string
|
|
*/
|
|
PRUnichar& CharAt(PRInt32 anIndex) const;
|
|
|
|
/**
|
|
* Retrieve reference to first unicode char in string
|
|
* @return PRUnichar from internal string
|
|
*/
|
|
PRUnichar& First() const;
|
|
|
|
/**
|
|
* Retrieve reference to last unicode char in string
|
|
* @return PRUnichar from internal string
|
|
*/
|
|
PRUnichar& Last() const;
|
|
|
|
PRBool SetCharAt(PRUnichar aChar,PRInt32 anIndex);
|
|
|
|
|
|
/**********************************************************************
|
|
String creation methods...
|
|
*********************************************************************/
|
|
|
|
/**
|
|
* Create a new string by appending given string to this
|
|
* @param aString -- 2nd string to be appended
|
|
* @return new string
|
|
*/
|
|
nsString operator+(const nsString& aString);
|
|
|
|
/**
|
|
* create a new string by adding this to the given buffer.
|
|
* @param aCString is a ptr to cstring to be added to this
|
|
* @return newly created string
|
|
*/
|
|
nsString operator+(const char* aCString);
|
|
|
|
/**
|
|
* create a new string by adding this to the given char.
|
|
* @param aChar is a char to be added to this
|
|
* @return newly created string
|
|
*/
|
|
nsString operator+(char aChar);
|
|
|
|
/**
|
|
* create a new string by adding this to the given buffer.
|
|
* @param aStr unichar buffer to be added to this
|
|
* @return newly created string
|
|
*/
|
|
nsString operator+(const PRUnichar* aBuffer);
|
|
|
|
/**
|
|
* create a new string by adding this to the given char.
|
|
* @param aChar is a unichar to be added to this
|
|
* @return newly created string
|
|
*/
|
|
nsString operator+(PRUnichar aChar);
|
|
|
|
/**
|
|
* Converts all chars in internal string to lower
|
|
*/
|
|
void ToLowerCase();
|
|
|
|
/**
|
|
* Converts all chars in given string to lower
|
|
*/
|
|
void ToLowerCase(nsString& aString) const;
|
|
|
|
/**
|
|
* Converts all chars in given string to upper
|
|
*/
|
|
void ToUpperCase();
|
|
|
|
/**
|
|
* Converts all chars in given string to UCS2
|
|
* which ensure that the lower 256 chars are correct.
|
|
*/
|
|
void ToUCS2(PRInt32 aStartOffset);
|
|
|
|
/**
|
|
* Converts all chars in internal string to upper
|
|
*/
|
|
void ToUpperCase(nsString& aString) const;
|
|
|
|
/**
|
|
* Creates a duplicate clone (ptr) of this string.
|
|
* @return ptr to clone of this string
|
|
*/
|
|
nsString* ToNewString() const;
|
|
|
|
/**
|
|
* Creates an ascii clone of this string
|
|
* NOTE: This string is allocated with new; YOU MUST deallocate with delete[]!
|
|
* @return ptr to new c-String string
|
|
*/
|
|
char* ToNewCString() const;
|
|
|
|
/**
|
|
* Copies data from internal buffer onto given char* buffer
|
|
* @param aBuf is the buffer where data is stored
|
|
* @param aBuflength is the max # of chars to move to buffer
|
|
* @return ptr to given buffer
|
|
*/
|
|
char* ToCString(char* aBuf,PRInt32 aBufLength) const;
|
|
|
|
/**
|
|
* Copies contents of this onto given string.
|
|
* @param aString to hold copy of this
|
|
* @return nada.
|
|
*/
|
|
void Copy(nsString& aString) const;
|
|
|
|
/**
|
|
* Creates an unichar clone of this string
|
|
* @return ptr to new unichar string
|
|
*/
|
|
PRUnichar* ToNewUnicode() const;
|
|
|
|
/**
|
|
* Perform string to float conversion.
|
|
* @param aErrorCode will contain error if one occurs
|
|
* @return float rep of string value
|
|
*/
|
|
float ToFloat(PRInt32* aErrorCode) const;
|
|
|
|
/**
|
|
* Perform string to int conversion.
|
|
* @param aErrorCode will contain error if one occurs
|
|
* @return int rep of string value
|
|
*/
|
|
PRInt32 ToInteger(PRInt32* aErrorCode,PRInt32 aRadix=10) const;
|
|
|
|
/**********************************************************************
|
|
String manipulation methods...
|
|
*********************************************************************/
|
|
|
|
/**
|
|
* assign given PRUnichar* to this string
|
|
* @param aStr: buffer to be assigned to this
|
|
* @param alength is the length of the given str (or -1)
|
|
if you want me to determine its length
|
|
* @return this
|
|
*/
|
|
nsString& SetString(const PRUnichar* aStr,PRInt32 aLength=-1);
|
|
|
|
/**
|
|
* assign given char* to this string
|
|
* @param aCString: buffer to be assigned to this
|
|
* @param alength is the length of the given str (or -1)
|
|
if you want me to determine its length
|
|
* @return this
|
|
*/
|
|
nsString& SetString(const char* aCString,PRInt32 aLength=-1);
|
|
|
|
/**
|
|
* assign given string to this one
|
|
* @param aString: string to be added to this
|
|
* @return this
|
|
*/
|
|
nsString& operator=(const nsString& aString);
|
|
|
|
/**
|
|
* assign given char* to this string
|
|
* @param aCString: buffer to be assigned to this
|
|
* @return this
|
|
*/
|
|
nsString& operator=(const char* aCString);
|
|
|
|
/**
|
|
* assign given char to this string
|
|
* @param aChar: char to be assignd to this
|
|
* @return this
|
|
*/
|
|
nsString& operator=(char aChar);
|
|
|
|
/**
|
|
* assign given unichar* to this string
|
|
* @param aBuffer: unichar buffer to be assigned to this
|
|
* @return this
|
|
*/
|
|
nsString& operator=(const PRUnichar* aBuffer);
|
|
|
|
/**
|
|
* assign given char to this string
|
|
* @param aChar: char to be assignd to this
|
|
* @return this
|
|
*/
|
|
nsString& operator=(PRUnichar aChar);
|
|
|
|
/**
|
|
* append given string to this string
|
|
* @param aString : string to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& operator+=(const nsString& aString);
|
|
|
|
/**
|
|
* append given buffer to this string
|
|
* @param aCString: buffer to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& operator+=(const char* aCString);
|
|
|
|
/**
|
|
* append given buffer to this string
|
|
* @param aBuffer: buffer to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& operator+=(const PRUnichar* aBuffer);
|
|
|
|
/**
|
|
* append given char to this string
|
|
* @param aChar: char to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& operator+=(PRUnichar aChar);
|
|
|
|
/**
|
|
* append given string to this string
|
|
* @param aString : string to be appended to this
|
|
* @param alength is the length of the given str (or -1)
|
|
if you want me to determine its length
|
|
* @return this
|
|
*/
|
|
nsString& Append(const nsString& aString,PRInt32 aLength=-1);
|
|
|
|
/**
|
|
* append given string to this string
|
|
* @param aString : string to be appended to this
|
|
* @param alength is the length of the given str (or -1)
|
|
if you want me to determine its length
|
|
* @return this
|
|
*/
|
|
nsString& Append(const char* aCString,PRInt32 aLength=-1);
|
|
|
|
/**
|
|
* append given string to this string
|
|
* @param aString : string to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& Append(char aChar);
|
|
|
|
/**
|
|
* append given unichar buffer to this string
|
|
* @param aString : string to be appended to this
|
|
* @param alength is the length of the given str (or -1)
|
|
if you want me to determine its length
|
|
* @return this
|
|
*/
|
|
nsString& Append(const PRUnichar* aBuffer,PRInt32 aLength=-1);
|
|
|
|
/**
|
|
* append given unichar character to this string
|
|
* @param aChar is the char to be appended to this
|
|
* @return this
|
|
*/
|
|
nsString& Append(PRUnichar aChar);
|
|
|
|
/**
|
|
* Append an integer onto this string
|
|
* @param aInteger is the int to be appended
|
|
* @param aRadix specifies 8,10,16
|
|
* @return this
|
|
*/
|
|
nsString& Append(PRInt32 aInteger,PRInt32 aRadix); //radix=8,10 or 16
|
|
|
|
/**
|
|
* Append a float value onto this string
|
|
* @param aFloat is the float to be appended
|
|
* @return this
|
|
*/
|
|
nsString& Append(float aFloat);
|
|
|
|
/*
|
|
* Copies n characters from this string to given string,
|
|
* starting at the leftmost offset.
|
|
*
|
|
*
|
|
* @param aCopy -- Receiving string
|
|
* @param aCount -- number of chars to copy
|
|
* @return number of chars copied
|
|
*/
|
|
PRInt32 Left(nsString& aCopy,PRInt32 aCount) const;
|
|
|
|
/*
|
|
* Copies n characters from this string to given string,
|
|
* starting at the given offset.
|
|
*
|
|
*
|
|
* @param aCopy -- Receiving string
|
|
* @param aCount -- number of chars to copy
|
|
* @param anOffset -- position where copying begins
|
|
* @return number of chars copied
|
|
*/
|
|
PRInt32 Mid(nsString& aCopy,PRInt32 anOffset,PRInt32 aCount) const;
|
|
|
|
/*
|
|
* Copies n characters from this string to given string,
|
|
* starting at rightmost char.
|
|
*
|
|
*
|
|
* @param aCopy -- Receiving string
|
|
* @param aCount -- number of chars to copy
|
|
* @return number of chars copied
|
|
*/
|
|
PRInt32 Right(nsString& aCopy,PRInt32 aCount) const;
|
|
|
|
/*
|
|
* This method inserts n chars from given string into this
|
|
* string at str[anOffset].
|
|
*
|
|
* @param aCopy -- String to be inserted into this
|
|
* @param anOffset -- insertion position within this str
|
|
* @param aCount -- number of chars to be copied from aCopy
|
|
* @return number of chars inserted into this.
|
|
*/
|
|
PRInt32 Insert(const nsString& aCopy,PRInt32 anOffset,PRInt32 aCount=-1);
|
|
|
|
/**
|
|
* Insert a single unicode char into this string at
|
|
* a specified offset.
|
|
*
|
|
* @param aChar char to be inserted into this string
|
|
* @param anOffset is insert pos in str
|
|
* @return the number of chars inserted into this string
|
|
*/
|
|
PRInt32 Insert(PRUnichar aChar,PRInt32 anOffset);
|
|
|
|
/*
|
|
* This method is used to cut characters in this string
|
|
* starting at anOffset, continuing for aCount chars.
|
|
*
|
|
* @param anOffset -- start pos for cut operation
|
|
* @param aCount -- number of chars to be cut
|
|
* @return *this
|
|
*/
|
|
nsString& Cut(PRInt32 anOffset,PRInt32 aCount);
|
|
|
|
/**
|
|
* This method is used to remove all occurances of the
|
|
* characters found in aSet from this string.
|
|
*
|
|
* @param aSet -- characters to be cut from this
|
|
* @return *this
|
|
*/
|
|
nsString& StripChars(const char* aSet);
|
|
|
|
/**
|
|
* This method is used to replace all occurances of the
|
|
* given source char with the given dest char
|
|
*
|
|
* @param
|
|
* @return *this
|
|
*/
|
|
nsString& ReplaceChar(PRUnichar aSourceChar, PRUnichar aDestChar);
|
|
|
|
/**
|
|
* This method strips whitespace throughout the string
|
|
*
|
|
* @return this
|
|
*/
|
|
nsString& StripWhitespace();
|
|
|
|
/**
|
|
* This method trims characters found in aTrimSet from
|
|
* either end of the underlying string.
|
|
*
|
|
* @param aTrimSet -- contains chars to be trimmed from
|
|
* both ends
|
|
* @return this
|
|
*/
|
|
nsString& Trim(const char* aSet,
|
|
PRBool aEliminateLeading=PR_TRUE,
|
|
PRBool aEliminateTrailing=PR_TRUE);
|
|
|
|
/**
|
|
* This method strips whitespace from string.
|
|
* You can control whether whitespace is yanked from
|
|
* start and end of string as well.
|
|
*
|
|
* @param aEliminateLeading controls stripping of leading ws
|
|
* @param aEliminateTrailing controls stripping of trailing ws
|
|
* @return this
|
|
*/
|
|
nsString& CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,
|
|
PRBool aEliminateTrailing=PR_TRUE);
|
|
|
|
/**
|
|
* Determine if given char is a valid space character
|
|
*
|
|
* @param aChar is character to be tested
|
|
* @return TRUE if is valid space char
|
|
*/
|
|
static PRBool IsSpace(PRUnichar ch);
|
|
|
|
/**
|
|
* Determine if given char in valid alpha range
|
|
*
|
|
* @param aChar is character to be tested
|
|
* @return TRUE if in alpha range
|
|
*/
|
|
static PRBool IsAlpha(PRUnichar ch);
|
|
|
|
/**
|
|
* Determine if given char is valid digit
|
|
*
|
|
* @param aChar is character to be tested
|
|
* @return TRUE if char is a valid digit
|
|
*/
|
|
static PRBool IsDigit(PRUnichar ch);
|
|
|
|
/**********************************************************************
|
|
Searching methods...
|
|
*********************************************************************/
|
|
|
|
/**
|
|
* Search for given character within this string.
|
|
* This method does so by using a binary search,
|
|
* so your string HAD BETTER BE ORDERED!
|
|
*
|
|
* @param aChar is the unicode char to be found
|
|
* @return offset in string, or -1 (kNotFound)
|
|
*/
|
|
PRInt32 BinarySearch(PRUnichar aChar) const;
|
|
|
|
/**
|
|
* Search for given substring within this string
|
|
*
|
|
* @param aString is substring to be sought in this
|
|
* @return offset in string, or -1 (kNotFound)
|
|
*/
|
|
PRInt32 Find(const char* aString) const;
|
|
PRInt32 Find(const PRUnichar* aString) const;
|
|
PRInt32 Find(const nsString& aString) const;
|
|
|
|
/**
|
|
* Search for given char within this string
|
|
*
|
|
* @param aChar - char to be found
|
|
* @return offset in string, or -1 (kNotFound)
|
|
*/
|
|
PRInt32 Find(PRUnichar aChar,PRInt32 offset=0) const;
|
|
|
|
/**
|
|
* This method searches this string for the first character
|
|
* found in the given string
|
|
* @param aString contains set of chars to be found
|
|
* @param anOffset tells us where to start searching in this
|
|
* @return -1 if not found, else the offset in this
|
|
*/
|
|
PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const;
|
|
PRInt32 FindCharInSet(nsString& aString,PRInt32 anOffset=0) const;
|
|
|
|
/**
|
|
* This method searches this string for the last character
|
|
* found in the given string
|
|
* @param aString contains set of chars to be found
|
|
* @param anOffset tells us where to start searching in this
|
|
* @return -1 if not found, else the offset in this
|
|
*/
|
|
PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=0) const;
|
|
PRInt32 RFindCharInSet(nsString& aString,PRInt32 anOffset=0) const;
|
|
|
|
|
|
/**
|
|
* This methods scans the string backwards, looking for the given string
|
|
* @param aString is substring to be sought in this
|
|
* @param aIgnoreCase tells us whether or not to do caseless compare
|
|
* @return offset in string, or -1 (kNotFound)
|
|
*/
|
|
PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE) const;
|
|
PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE) const;
|
|
PRInt32 RFind(const nsString& aString,PRBool aIgnoreCase=PR_FALSE) const;
|
|
|
|
/**
|
|
* This methods scans the string backwards, looking for the given char
|
|
* @param char is the char to be sought in this
|
|
* @param aIgnoreCase tells us whether or not to do caseless compare
|
|
* @return offset in string, or -1 (kNotFound)
|
|
*/
|
|
PRInt32 RFind(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE) const;
|
|
|
|
/**********************************************************************
|
|
Comparison methods...
|
|
*********************************************************************/
|
|
|
|
/**
|
|
* Compares a given string type to this string.
|
|
* @update gess 7/27/98
|
|
* @param S is the string to be compared
|
|
* @param aIgnoreCase tells us how to treat case
|
|
* @return -1,0,1
|
|
*/
|
|
virtual PRInt32 Compare(const nsString &aString,PRBool aIgnoreCase=PR_FALSE) const;
|
|
virtual PRInt32 Compare(const char *aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
|
|
virtual PRInt32 Compare(const PRUnichar *aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
|
|
|
|
/**
|
|
* These methods compare a given string type to this one
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE or FALSE
|
|
*/
|
|
PRBool operator==(const nsString &aString) const;
|
|
PRBool operator==(const char *aString) const;
|
|
PRBool operator==(const PRUnichar* aString) const;
|
|
PRBool operator==(PRUnichar* aString) const;
|
|
|
|
/**
|
|
* These methods perform a !compare of a given string type to this
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE
|
|
*/
|
|
PRBool operator!=(const nsString &aString) const;
|
|
PRBool operator!=(const char *aString) const;
|
|
PRBool operator!=(const PRUnichar* aString) const;
|
|
|
|
/**
|
|
* These methods test if a given string is < than this
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE or FALSE
|
|
*/
|
|
PRBool operator<(const nsString &aString) const;
|
|
PRBool operator<(const char *aString) const;
|
|
PRBool operator<(const PRUnichar* aString) const;
|
|
|
|
/**
|
|
* These methods test if a given string is > than this
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE or FALSE
|
|
*/
|
|
PRBool operator>(const nsString &S) const;
|
|
PRBool operator>(const char *aCString) const;
|
|
PRBool operator>(const PRUnichar* aString) const;
|
|
|
|
/**
|
|
* These methods test if a given string is <= than this
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE or FALSE
|
|
*/
|
|
PRBool operator<=(const nsString &S) const;
|
|
PRBool operator<=(const char *aCString) const;
|
|
PRBool operator<=(const PRUnichar* aString) const;
|
|
|
|
/**
|
|
* These methods test if a given string is >= than this
|
|
* @param aString is the string to be compared to this
|
|
* @return TRUE or FALSE
|
|
*/
|
|
PRBool operator>=(const nsString &S) const;
|
|
PRBool operator>=(const char* aCString) const;
|
|
PRBool operator>=(const PRUnichar* aString) const;
|
|
|
|
/**
|
|
* Compare this to given string; note that we compare full strings here.
|
|
* The optional length argument just lets us know how long the given string is.
|
|
* If you provide a length, it is compared to length of this string as an
|
|
* optimization.
|
|
*
|
|
* @param aString -- the string to compare to this
|
|
* @param aLength -- optional length of given string.
|
|
* @return TRUE if equal
|
|
*/
|
|
PRBool Equals(const nsString& aString) const;
|
|
PRBool Equals(const char* aString,PRInt32 aLength=-1) const;
|
|
PRBool Equals(const nsIAtom *aAtom) const;
|
|
|
|
|
|
/**
|
|
* Compares to unichar string ptrs to each other
|
|
* @param s1 is a ptr to a unichar buffer
|
|
* @param s2 is a ptr to a unichar buffer
|
|
* @return TRUE if they match
|
|
*/
|
|
PRBool Equals(const PRUnichar* s1, const PRUnichar* s2) const;
|
|
|
|
/**
|
|
* Compare this to given string; note that we compare full strings here.
|
|
* The optional length argument just lets us know how long the given string is.
|
|
* If you provide a length, it is compared to length of this string as an
|
|
* optimization.
|
|
*
|
|
* @param aString -- the string to compare to this
|
|
* @param aLength -- optional length of given string.
|
|
* @return TRUE if equal
|
|
*/
|
|
PRBool EqualsIgnoreCase(const nsString& aString) const;
|
|
PRBool EqualsIgnoreCase(const char* aString,PRInt32 aLength=-1) const;
|
|
PRBool EqualsIgnoreCase(const nsIAtom *aAtom) const;
|
|
|
|
/**
|
|
* Compares to unichar string ptrs to each other without respect to case
|
|
* @param s1 is a ptr to a unichar buffer
|
|
* @param s2 is a ptr to a unichar buffer
|
|
* @return TRUE if they match
|
|
*/
|
|
PRBool EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const;
|
|
|
|
|
|
static void SelfTest();
|
|
virtual void DebugDump(ostream& aStream) const;
|
|
|
|
protected:
|
|
|
|
typedef PRUnichar chartype;
|
|
|
|
chartype* mStr;
|
|
PRInt32 mLength;
|
|
PRInt32 mCapacity;
|
|
#ifdef NS_DEBUG
|
|
static PRBool mSelfTested;
|
|
#endif
|
|
};
|
|
|
|
ostream& operator<<(ostream& os,nsString& aString);
|
|
extern NS_BASE int fputs(const nsString& aString, FILE* out);
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* A version of nsString which is designed to be used as an automatic
|
|
* variable. It attempts to operate out of a fixed size internal
|
|
* buffer until too much data is added; then a dynamic buffer is
|
|
* allocated and grown as necessary.
|
|
*/
|
|
// XXX template this with a parameter for the size of the buffer?
|
|
class NS_BASE nsAutoString : public nsString {
|
|
public:
|
|
nsAutoString();
|
|
nsAutoString(const nsString& other);
|
|
nsAutoString(const nsAutoString& other);
|
|
nsAutoString(PRUnichar aChar);
|
|
nsAutoString(const char* aCString);
|
|
nsAutoString(const PRUnichar* us, PRInt32 uslen = -1);
|
|
virtual ~nsAutoString();
|
|
|
|
nsAutoString& operator=(const nsString& aString) {nsString::operator=(aString); return *this;}
|
|
nsAutoString& operator=(const nsAutoString& aString) {nsString::operator=(aString); return *this;}
|
|
nsAutoString& operator=(const char* aCString) {nsString::operator=(aCString); return *this;}
|
|
nsAutoString& operator=(char aChar) {nsString::operator=(aChar); return *this;}
|
|
nsAutoString& operator=(const PRUnichar* aBuffer) {nsString::operator=(aBuffer); return *this;}
|
|
nsAutoString& operator=(PRUnichar aChar) {nsString::operator=(aChar); return *this;}
|
|
|
|
virtual void SizeOf(nsISizeOfHandler* aHandler) const;
|
|
|
|
static void SelfTest();
|
|
|
|
protected:
|
|
virtual void EnsureCapacityFor(PRInt32 aNewLength);
|
|
|
|
chartype mBuf[32];
|
|
};
|
|
|
|
ostream& operator<<(ostream& os,nsAutoString& aString);
|
|
|
|
#endif
|
|
|