From bdfaeac28d4354a1910df84e9b7813d89990558e Mon Sep 17 00:00:00 2001 From: "scc%netscape.com" Date: Thu, 30 Mar 2000 22:53:41 +0000 Subject: [PATCH] incremental changes. We're getting closer. These files are not yet part of the build. git-svn-id: svn://10.0.0.236/trunk@64636 18797224-902f-48f8-a5cc-f745e15eee43 --- mozilla/string/public/nsAReadableString.h | 67 ++++- mozilla/string/public/nsAWritableString.h | 240 ++++++++++++++---- mozilla/string/public/nsSharedString.h | 7 +- mozilla/xpcom/ds/nsAReadableString.h | 67 ++++- mozilla/xpcom/ds/nsAWritableString.h | 240 ++++++++++++++---- mozilla/xpcom/ds/nsSharedString.h | 7 +- .../xpcom/string/public/nsAReadableString.h | 67 ++++- .../xpcom/string/public/nsAWritableString.h | 240 ++++++++++++++---- mozilla/xpcom/string/public/nsSharedString.h | 7 +- 9 files changed, 777 insertions(+), 165 deletions(-) diff --git a/mozilla/string/public/nsAReadableString.h b/mozilla/string/public/nsAReadableString.h index 78b82b66cbe..75ccda0e951 100644 --- a/mozilla/string/public/nsAReadableString.h +++ b/mozilla/string/public/nsAReadableString.h @@ -232,7 +232,11 @@ class basic_nsAReadableString */ { public: - typedef nsReadingIterator ConstIterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsReadingIterator const_iterator; + virtual ~basic_nsAReadableString() { } @@ -615,7 +619,10 @@ class basic_nsLiteralString : mStart(aLiteral), mEnd(mStart + aLength) { - // nothing else to do here + // This is an annoying hack. Callers should be fixed to use the other + // constructor if they don't really know the length. + if ( aLength == PRUint32(-1) ) + mEnd = mStart + nsCharTraits::length(mStart); } virtual PRUint32 Length() const; @@ -658,6 +665,59 @@ basic_nsLiteralString::Length() const + // + // nsLiteralChar, nsLiteralPRUnichar + // + +template +class basic_nsLiteralChar + : public basic_nsAReadableString + { + protected: + virtual const CharT* GetReadableFragment( nsReadableFragment&, nsFragmentRequest, PRUint32 ) const; + + public: + + basic_nsLiteralChar( CharT aChar ) + : mChar(aChar) + { + // nothing else to do here + } + + virtual + PRUint32 + Length() const + { + return 1; + } + + private: + CharT mChar; + }; + +template +const CharT* +basic_nsLiteralChar::GetReadableFragment( nsReadableFragment& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const + { + switch ( aRequest ) + { + case kFirstFragment: + case kLastFragment: + case kFragmentAt: + aFragment.mEnd = (aFragment.mStart = &mChar) + 1; + return aFragment.mStart + aOffset; + + case kPrevFragment: + case kNextFragment: + default: + return 0; + } + } + + + + + // // nsPromiseConcatenation @@ -1107,5 +1167,8 @@ typedef basic_nsLiteralString nsLiteralCString; #define NS_LITERAL_STRING(s) nsLiteralString(s, sizeof(s)/sizeof(wchar_t)) #define NS_LITERAL_CSTRING(s) nsLiteralCString(s, sizeof(s)) +typedef basic_nsLiteralChar nsLiteralChar; +typedef basic_nsLiteralChar nsLiteralPRUnichar; + #endif // !defined(_nsAReadableString_h__) diff --git a/mozilla/string/public/nsAWritableString.h b/mozilla/string/public/nsAWritableString.h index 33aed4f8962..2201a181e48 100644 --- a/mozilla/string/public/nsAWritableString.h +++ b/mozilla/string/public/nsAWritableString.h @@ -200,7 +200,10 @@ class basic_nsAWritableString // friend class nsWritingIterator; public: - typedef nsWritingIterator Iterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsWritingIterator iterator; virtual CharT* GetWritableFragment( nsWritableFragment&, nsFragmentRequest, PRUint32 = 0 ) = 0; @@ -255,49 +258,84 @@ class basic_nsAWritableString - virtual void Assign( const basic_nsAReadableString& rhs ); - // virtual void AssignChar( CharT ) = 0; + // + // |operator=()|, |Assign()| + // + + basic_nsAWritableString& operator=( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator=( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator=( CharT aChar ) { do_AssignFromElement(aChar); return *this; } + + void Assign( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); } +// void Assign( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AssignFromIterators(aStart, aEnd); } + void Assign( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); } + void Assign( const CharT* aPtr, PRUint32 aLength ) { do_AssignFromElementPtrLength(aPtr, aLength); } + void Assign( CharT aChar ) { do_AssignFromElement(aChar); } + + + + // + // |operator+=()|, |Append()| + // + + basic_nsAWritableString& operator+=( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator+=( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator+=( CharT aChar ) { do_AppendFromElement(aChar); return *this; } + + void Append( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); } +// void Append( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AppendFromIterators(aStart, aEnd); } + void Append( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); } + void Append( const CharT* aPtr, PRUint32 aLength ) { do_AppendFromElementPtrLength(aPtr, aLength); } + void Append( CharT aChar ) { do_AppendFromElement(aChar); } + + + + // + // |Insert()| + // Note: I would really like to move the |atPosition| parameter to the front of the argument list + // + + void Insert( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { do_InsertFromReadable(aReadable, atPosition); } +// void Insert( const nsReadingIterator& aStart, const nsReadingIterator& aEnd, PRUint32 atPosition ) { do_InsertFromIterators(aStart, aEnd, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition ) { do_InsertFromElementPtr(aPtr, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); } + void Insert( CharT aChar, PRUint32 atPosition ) { do_InsertFromElement(aChar, atPosition); } - virtual void Append( const basic_nsAReadableString& ); - virtual void AppendChar( CharT ); - virtual void Insert( const basic_nsAReadableString&, PRUint32 atPosition ); - // virtual void InsertChar( CharT, PRUint32 atPosition ) = 0; virtual void Cut( PRUint32 cutStart, PRUint32 cutLength ); - virtual void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); - basic_nsAWritableString& - operator+=( const basic_nsAReadableString& rhs ) - { - Append(rhs); - return *this; - } + void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); + - basic_nsAWritableString& - operator+=( const basic_nsLiteralString& rhs ) - { - Append(rhs); - return *this; - } + protected: + virtual void do_AssignFromReadable( const basic_nsAReadableString& ); +// virtual void do_AssignFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AssignFromElementPtr( const CharT* ); + virtual void do_AssignFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AssignFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsAReadableString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_AppendFromReadable( const basic_nsAReadableString& ); +// virtual void do_AppendFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AppendFromElementPtr( const CharT* ); + virtual void do_AppendFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AppendFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsLiteralString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_InsertFromReadable( const basic_nsAReadableString&, PRUint32 ); +// virtual void do_InsertFromIterators( nsReadingIterator, nsReadingIterator, PRUint32 ); + virtual void do_InsertFromElementPtr( const CharT*, PRUint32 ); + virtual void do_InsertFromElementPtrLength( const CharT*, PRUint32, PRUint32 ); + virtual void do_InsertFromElement( CharT, PRUint32 ); }; + + + // + // |nsWritingIterator|s + // + template inline void @@ -326,53 +364,144 @@ operator==( const nsWritingIterator& lhs, const nsWritingIterator& return lhs.operator->() == rhs.operator->(); } -template -inline -PRBool -operator!=( const nsWritingIterator& lhs, const nsWritingIterator& rhs ) - { - return lhs.operator->() != rhs.operator->(); - } + // + // |Assign()| + // + template void -basic_nsAWritableString::Assign( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromReadable( const basic_nsAReadableString& rhs ) { SetLength(rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting()); } +#if 0 template void -basic_nsAWritableString::Append( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) + { + SetLength(distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting()); + } +#endif + +template +void +basic_nsAWritableString::do_AssignFromElementPtr( const CharT* aPtr ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr)); + } + +template +void +basic_nsAWritableString::do_AssignFromElementPtrLength( const CharT* aPtr, PRUint32 aLength ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr, aLength)); + } + +template +void +basic_nsAWritableString::do_AssignFromElement( CharT aChar ) + { + do_AssignFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Append()| + // + +template +void +basic_nsAWritableString::do_AppendFromReadable( const basic_nsAReadableString& rhs ) { PRUint32 oldLength = Length(); SetLength(oldLength + rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting(oldLength)); } +#if 0 template void -basic_nsAWritableString::AppendChar( CharT aChar ) +basic_nsAWritableString::do_AppendFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { - SetLength(Length()+1); - *EndWriting(1) = aChar; + PRUint32 oldLength = Length(); + SetLength(oldLength + distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting(oldLength)); + } +#endif + +template +void +basic_nsAWritableString::do_AppendFromElementPtr( const CharT* aChar ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar)); } template void -basic_nsAWritableString::Insert( const basic_nsAReadableString& aReadable, PRUint32 aPosition ) +basic_nsAWritableString::do_AppendFromElementPtrLength( const CharT* aChar, PRUint32 aLength ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar, aLength)); + } + +template +void +basic_nsAWritableString::do_AppendFromElement( CharT aChar ) + { + do_AppendFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Insert()| + // + +template +void +basic_nsAWritableString::do_InsertFromReadable( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { PRUint32 oldLength = Length(); SetLength(oldLength + aReadable.Length()); - if ( aPosition < oldLength ) - copy_string_backward(BeginReading(aPosition), BeginReading(oldLength), EndWriting()); + if ( atPosition < oldLength ) + copy_string_backward(BeginReading(atPosition), BeginReading(oldLength), EndWriting()); else - aPosition = oldLength; - copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(aPosition)); + atPosition = oldLength; + copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(atPosition)); } +template +void +basic_nsAWritableString::do_InsertFromElementPtr( const CharT* aPtr, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElementPtrLength( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr, aLength), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElement( CharT aChar, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralChar(aChar), atPosition); + } + + + + // + // |Cut()| + // + template void basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) @@ -381,6 +510,12 @@ basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) SetLength(Length()-cutLength); } + + + // + // |Replace()| + // + template void basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& aReplacement ) @@ -405,8 +540,11 @@ basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, copy_string(aReplacement.BeginReading(), aReplacement.EndReading(), BeginWriting(cutStart)); } -// operator>> -// getline (maybe) + + + // + // Types + // typedef basic_nsAWritableString nsAWritableString; typedef basic_nsAWritableString nsAWritableCString; diff --git a/mozilla/string/public/nsSharedString.h b/mozilla/string/public/nsSharedString.h index e0af7352591..8195c86d414 100644 --- a/mozilla/string/public/nsSharedString.h +++ b/mozilla/string/public/nsSharedString.h @@ -69,7 +69,10 @@ class basic_nsSharedString { nsrefcnt result = --mRefCount; if ( !mRefCount ) - delete this; + { + delete this; + // BULLSHIT ALERT: need to make |delete| match |new| + } return result; } @@ -109,7 +112,7 @@ class nsSharedStringPtr // ... private: - basic_nsSharedString* mPtr; + basic_nsSharedString* mRawPtr; }; diff --git a/mozilla/xpcom/ds/nsAReadableString.h b/mozilla/xpcom/ds/nsAReadableString.h index 78b82b66cbe..75ccda0e951 100644 --- a/mozilla/xpcom/ds/nsAReadableString.h +++ b/mozilla/xpcom/ds/nsAReadableString.h @@ -232,7 +232,11 @@ class basic_nsAReadableString */ { public: - typedef nsReadingIterator ConstIterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsReadingIterator const_iterator; + virtual ~basic_nsAReadableString() { } @@ -615,7 +619,10 @@ class basic_nsLiteralString : mStart(aLiteral), mEnd(mStart + aLength) { - // nothing else to do here + // This is an annoying hack. Callers should be fixed to use the other + // constructor if they don't really know the length. + if ( aLength == PRUint32(-1) ) + mEnd = mStart + nsCharTraits::length(mStart); } virtual PRUint32 Length() const; @@ -658,6 +665,59 @@ basic_nsLiteralString::Length() const + // + // nsLiteralChar, nsLiteralPRUnichar + // + +template +class basic_nsLiteralChar + : public basic_nsAReadableString + { + protected: + virtual const CharT* GetReadableFragment( nsReadableFragment&, nsFragmentRequest, PRUint32 ) const; + + public: + + basic_nsLiteralChar( CharT aChar ) + : mChar(aChar) + { + // nothing else to do here + } + + virtual + PRUint32 + Length() const + { + return 1; + } + + private: + CharT mChar; + }; + +template +const CharT* +basic_nsLiteralChar::GetReadableFragment( nsReadableFragment& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const + { + switch ( aRequest ) + { + case kFirstFragment: + case kLastFragment: + case kFragmentAt: + aFragment.mEnd = (aFragment.mStart = &mChar) + 1; + return aFragment.mStart + aOffset; + + case kPrevFragment: + case kNextFragment: + default: + return 0; + } + } + + + + + // // nsPromiseConcatenation @@ -1107,5 +1167,8 @@ typedef basic_nsLiteralString nsLiteralCString; #define NS_LITERAL_STRING(s) nsLiteralString(s, sizeof(s)/sizeof(wchar_t)) #define NS_LITERAL_CSTRING(s) nsLiteralCString(s, sizeof(s)) +typedef basic_nsLiteralChar nsLiteralChar; +typedef basic_nsLiteralChar nsLiteralPRUnichar; + #endif // !defined(_nsAReadableString_h__) diff --git a/mozilla/xpcom/ds/nsAWritableString.h b/mozilla/xpcom/ds/nsAWritableString.h index 33aed4f8962..2201a181e48 100644 --- a/mozilla/xpcom/ds/nsAWritableString.h +++ b/mozilla/xpcom/ds/nsAWritableString.h @@ -200,7 +200,10 @@ class basic_nsAWritableString // friend class nsWritingIterator; public: - typedef nsWritingIterator Iterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsWritingIterator iterator; virtual CharT* GetWritableFragment( nsWritableFragment&, nsFragmentRequest, PRUint32 = 0 ) = 0; @@ -255,49 +258,84 @@ class basic_nsAWritableString - virtual void Assign( const basic_nsAReadableString& rhs ); - // virtual void AssignChar( CharT ) = 0; + // + // |operator=()|, |Assign()| + // + + basic_nsAWritableString& operator=( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator=( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator=( CharT aChar ) { do_AssignFromElement(aChar); return *this; } + + void Assign( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); } +// void Assign( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AssignFromIterators(aStart, aEnd); } + void Assign( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); } + void Assign( const CharT* aPtr, PRUint32 aLength ) { do_AssignFromElementPtrLength(aPtr, aLength); } + void Assign( CharT aChar ) { do_AssignFromElement(aChar); } + + + + // + // |operator+=()|, |Append()| + // + + basic_nsAWritableString& operator+=( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator+=( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator+=( CharT aChar ) { do_AppendFromElement(aChar); return *this; } + + void Append( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); } +// void Append( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AppendFromIterators(aStart, aEnd); } + void Append( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); } + void Append( const CharT* aPtr, PRUint32 aLength ) { do_AppendFromElementPtrLength(aPtr, aLength); } + void Append( CharT aChar ) { do_AppendFromElement(aChar); } + + + + // + // |Insert()| + // Note: I would really like to move the |atPosition| parameter to the front of the argument list + // + + void Insert( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { do_InsertFromReadable(aReadable, atPosition); } +// void Insert( const nsReadingIterator& aStart, const nsReadingIterator& aEnd, PRUint32 atPosition ) { do_InsertFromIterators(aStart, aEnd, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition ) { do_InsertFromElementPtr(aPtr, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); } + void Insert( CharT aChar, PRUint32 atPosition ) { do_InsertFromElement(aChar, atPosition); } - virtual void Append( const basic_nsAReadableString& ); - virtual void AppendChar( CharT ); - virtual void Insert( const basic_nsAReadableString&, PRUint32 atPosition ); - // virtual void InsertChar( CharT, PRUint32 atPosition ) = 0; virtual void Cut( PRUint32 cutStart, PRUint32 cutLength ); - virtual void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); - basic_nsAWritableString& - operator+=( const basic_nsAReadableString& rhs ) - { - Append(rhs); - return *this; - } + void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); + - basic_nsAWritableString& - operator+=( const basic_nsLiteralString& rhs ) - { - Append(rhs); - return *this; - } + protected: + virtual void do_AssignFromReadable( const basic_nsAReadableString& ); +// virtual void do_AssignFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AssignFromElementPtr( const CharT* ); + virtual void do_AssignFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AssignFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsAReadableString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_AppendFromReadable( const basic_nsAReadableString& ); +// virtual void do_AppendFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AppendFromElementPtr( const CharT* ); + virtual void do_AppendFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AppendFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsLiteralString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_InsertFromReadable( const basic_nsAReadableString&, PRUint32 ); +// virtual void do_InsertFromIterators( nsReadingIterator, nsReadingIterator, PRUint32 ); + virtual void do_InsertFromElementPtr( const CharT*, PRUint32 ); + virtual void do_InsertFromElementPtrLength( const CharT*, PRUint32, PRUint32 ); + virtual void do_InsertFromElement( CharT, PRUint32 ); }; + + + // + // |nsWritingIterator|s + // + template inline void @@ -326,53 +364,144 @@ operator==( const nsWritingIterator& lhs, const nsWritingIterator& return lhs.operator->() == rhs.operator->(); } -template -inline -PRBool -operator!=( const nsWritingIterator& lhs, const nsWritingIterator& rhs ) - { - return lhs.operator->() != rhs.operator->(); - } + // + // |Assign()| + // + template void -basic_nsAWritableString::Assign( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromReadable( const basic_nsAReadableString& rhs ) { SetLength(rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting()); } +#if 0 template void -basic_nsAWritableString::Append( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) + { + SetLength(distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting()); + } +#endif + +template +void +basic_nsAWritableString::do_AssignFromElementPtr( const CharT* aPtr ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr)); + } + +template +void +basic_nsAWritableString::do_AssignFromElementPtrLength( const CharT* aPtr, PRUint32 aLength ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr, aLength)); + } + +template +void +basic_nsAWritableString::do_AssignFromElement( CharT aChar ) + { + do_AssignFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Append()| + // + +template +void +basic_nsAWritableString::do_AppendFromReadable( const basic_nsAReadableString& rhs ) { PRUint32 oldLength = Length(); SetLength(oldLength + rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting(oldLength)); } +#if 0 template void -basic_nsAWritableString::AppendChar( CharT aChar ) +basic_nsAWritableString::do_AppendFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { - SetLength(Length()+1); - *EndWriting(1) = aChar; + PRUint32 oldLength = Length(); + SetLength(oldLength + distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting(oldLength)); + } +#endif + +template +void +basic_nsAWritableString::do_AppendFromElementPtr( const CharT* aChar ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar)); } template void -basic_nsAWritableString::Insert( const basic_nsAReadableString& aReadable, PRUint32 aPosition ) +basic_nsAWritableString::do_AppendFromElementPtrLength( const CharT* aChar, PRUint32 aLength ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar, aLength)); + } + +template +void +basic_nsAWritableString::do_AppendFromElement( CharT aChar ) + { + do_AppendFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Insert()| + // + +template +void +basic_nsAWritableString::do_InsertFromReadable( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { PRUint32 oldLength = Length(); SetLength(oldLength + aReadable.Length()); - if ( aPosition < oldLength ) - copy_string_backward(BeginReading(aPosition), BeginReading(oldLength), EndWriting()); + if ( atPosition < oldLength ) + copy_string_backward(BeginReading(atPosition), BeginReading(oldLength), EndWriting()); else - aPosition = oldLength; - copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(aPosition)); + atPosition = oldLength; + copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(atPosition)); } +template +void +basic_nsAWritableString::do_InsertFromElementPtr( const CharT* aPtr, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElementPtrLength( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr, aLength), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElement( CharT aChar, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralChar(aChar), atPosition); + } + + + + // + // |Cut()| + // + template void basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) @@ -381,6 +510,12 @@ basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) SetLength(Length()-cutLength); } + + + // + // |Replace()| + // + template void basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& aReplacement ) @@ -405,8 +540,11 @@ basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, copy_string(aReplacement.BeginReading(), aReplacement.EndReading(), BeginWriting(cutStart)); } -// operator>> -// getline (maybe) + + + // + // Types + // typedef basic_nsAWritableString nsAWritableString; typedef basic_nsAWritableString nsAWritableCString; diff --git a/mozilla/xpcom/ds/nsSharedString.h b/mozilla/xpcom/ds/nsSharedString.h index e0af7352591..8195c86d414 100644 --- a/mozilla/xpcom/ds/nsSharedString.h +++ b/mozilla/xpcom/ds/nsSharedString.h @@ -69,7 +69,10 @@ class basic_nsSharedString { nsrefcnt result = --mRefCount; if ( !mRefCount ) - delete this; + { + delete this; + // BULLSHIT ALERT: need to make |delete| match |new| + } return result; } @@ -109,7 +112,7 @@ class nsSharedStringPtr // ... private: - basic_nsSharedString* mPtr; + basic_nsSharedString* mRawPtr; }; diff --git a/mozilla/xpcom/string/public/nsAReadableString.h b/mozilla/xpcom/string/public/nsAReadableString.h index 78b82b66cbe..75ccda0e951 100644 --- a/mozilla/xpcom/string/public/nsAReadableString.h +++ b/mozilla/xpcom/string/public/nsAReadableString.h @@ -232,7 +232,11 @@ class basic_nsAReadableString */ { public: - typedef nsReadingIterator ConstIterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsReadingIterator const_iterator; + virtual ~basic_nsAReadableString() { } @@ -615,7 +619,10 @@ class basic_nsLiteralString : mStart(aLiteral), mEnd(mStart + aLength) { - // nothing else to do here + // This is an annoying hack. Callers should be fixed to use the other + // constructor if they don't really know the length. + if ( aLength == PRUint32(-1) ) + mEnd = mStart + nsCharTraits::length(mStart); } virtual PRUint32 Length() const; @@ -658,6 +665,59 @@ basic_nsLiteralString::Length() const + // + // nsLiteralChar, nsLiteralPRUnichar + // + +template +class basic_nsLiteralChar + : public basic_nsAReadableString + { + protected: + virtual const CharT* GetReadableFragment( nsReadableFragment&, nsFragmentRequest, PRUint32 ) const; + + public: + + basic_nsLiteralChar( CharT aChar ) + : mChar(aChar) + { + // nothing else to do here + } + + virtual + PRUint32 + Length() const + { + return 1; + } + + private: + CharT mChar; + }; + +template +const CharT* +basic_nsLiteralChar::GetReadableFragment( nsReadableFragment& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const + { + switch ( aRequest ) + { + case kFirstFragment: + case kLastFragment: + case kFragmentAt: + aFragment.mEnd = (aFragment.mStart = &mChar) + 1; + return aFragment.mStart + aOffset; + + case kPrevFragment: + case kNextFragment: + default: + return 0; + } + } + + + + + // // nsPromiseConcatenation @@ -1107,5 +1167,8 @@ typedef basic_nsLiteralString nsLiteralCString; #define NS_LITERAL_STRING(s) nsLiteralString(s, sizeof(s)/sizeof(wchar_t)) #define NS_LITERAL_CSTRING(s) nsLiteralCString(s, sizeof(s)) +typedef basic_nsLiteralChar nsLiteralChar; +typedef basic_nsLiteralChar nsLiteralPRUnichar; + #endif // !defined(_nsAReadableString_h__) diff --git a/mozilla/xpcom/string/public/nsAWritableString.h b/mozilla/xpcom/string/public/nsAWritableString.h index 33aed4f8962..2201a181e48 100644 --- a/mozilla/xpcom/string/public/nsAWritableString.h +++ b/mozilla/xpcom/string/public/nsAWritableString.h @@ -200,7 +200,10 @@ class basic_nsAWritableString // friend class nsWritingIterator; public: - typedef nsWritingIterator Iterator; + typedef PRUint32 size_type; + typedef PRUint32 index_type; + + typedef nsWritingIterator iterator; virtual CharT* GetWritableFragment( nsWritableFragment&, nsFragmentRequest, PRUint32 = 0 ) = 0; @@ -255,49 +258,84 @@ class basic_nsAWritableString - virtual void Assign( const basic_nsAReadableString& rhs ); - // virtual void AssignChar( CharT ) = 0; + // + // |operator=()|, |Assign()| + // + + basic_nsAWritableString& operator=( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator=( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator=( CharT aChar ) { do_AssignFromElement(aChar); return *this; } + + void Assign( const basic_nsAReadableString& aReadable ) { do_AssignFromReadable(aReadable); } +// void Assign( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AssignFromIterators(aStart, aEnd); } + void Assign( const CharT* aPtr ) { do_AssignFromElementPtr(aPtr); } + void Assign( const CharT* aPtr, PRUint32 aLength ) { do_AssignFromElementPtrLength(aPtr, aLength); } + void Assign( CharT aChar ) { do_AssignFromElement(aChar); } + + + + // + // |operator+=()|, |Append()| + // + + basic_nsAWritableString& operator+=( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); return *this; } + basic_nsAWritableString& operator+=( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); return *this; } + basic_nsAWritableString& operator+=( CharT aChar ) { do_AppendFromElement(aChar); return *this; } + + void Append( const basic_nsAReadableString& aReadable ) { do_AppendFromReadable(aReadable); } +// void Append( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { do_AppendFromIterators(aStart, aEnd); } + void Append( const CharT* aPtr ) { do_AppendFromElementPtr(aPtr); } + void Append( const CharT* aPtr, PRUint32 aLength ) { do_AppendFromElementPtrLength(aPtr, aLength); } + void Append( CharT aChar ) { do_AppendFromElement(aChar); } + + + + // + // |Insert()| + // Note: I would really like to move the |atPosition| parameter to the front of the argument list + // + + void Insert( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { do_InsertFromReadable(aReadable, atPosition); } +// void Insert( const nsReadingIterator& aStart, const nsReadingIterator& aEnd, PRUint32 atPosition ) { do_InsertFromIterators(aStart, aEnd, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition ) { do_InsertFromElementPtr(aPtr, atPosition); } + void Insert( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); } + void Insert( CharT aChar, PRUint32 atPosition ) { do_InsertFromElement(aChar, atPosition); } - virtual void Append( const basic_nsAReadableString& ); - virtual void AppendChar( CharT ); - virtual void Insert( const basic_nsAReadableString&, PRUint32 atPosition ); - // virtual void InsertChar( CharT, PRUint32 atPosition ) = 0; virtual void Cut( PRUint32 cutStart, PRUint32 cutLength ); - virtual void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); - basic_nsAWritableString& - operator+=( const basic_nsAReadableString& rhs ) - { - Append(rhs); - return *this; - } + void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& ); + - basic_nsAWritableString& - operator+=( const basic_nsLiteralString& rhs ) - { - Append(rhs); - return *this; - } + protected: + virtual void do_AssignFromReadable( const basic_nsAReadableString& ); +// virtual void do_AssignFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AssignFromElementPtr( const CharT* ); + virtual void do_AssignFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AssignFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsAReadableString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_AppendFromReadable( const basic_nsAReadableString& ); +// virtual void do_AppendFromIterators( nsReadingIterator, nsReadingIterator ); + virtual void do_AppendFromElementPtr( const CharT* ); + virtual void do_AppendFromElementPtrLength( const CharT*, PRUint32 ); + virtual void do_AppendFromElement( CharT ); - basic_nsAWritableString& - operator=( const basic_nsLiteralString& rhs ) - { - Assign(rhs); - return *this; - } + virtual void do_InsertFromReadable( const basic_nsAReadableString&, PRUint32 ); +// virtual void do_InsertFromIterators( nsReadingIterator, nsReadingIterator, PRUint32 ); + virtual void do_InsertFromElementPtr( const CharT*, PRUint32 ); + virtual void do_InsertFromElementPtrLength( const CharT*, PRUint32, PRUint32 ); + virtual void do_InsertFromElement( CharT, PRUint32 ); }; + + + // + // |nsWritingIterator|s + // + template inline void @@ -326,53 +364,144 @@ operator==( const nsWritingIterator& lhs, const nsWritingIterator& return lhs.operator->() == rhs.operator->(); } -template -inline -PRBool -operator!=( const nsWritingIterator& lhs, const nsWritingIterator& rhs ) - { - return lhs.operator->() != rhs.operator->(); - } + // + // |Assign()| + // + template void -basic_nsAWritableString::Assign( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromReadable( const basic_nsAReadableString& rhs ) { SetLength(rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting()); } +#if 0 template void -basic_nsAWritableString::Append( const basic_nsAReadableString& rhs ) +basic_nsAWritableString::do_AssignFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) + { + SetLength(distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting()); + } +#endif + +template +void +basic_nsAWritableString::do_AssignFromElementPtr( const CharT* aPtr ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr)); + } + +template +void +basic_nsAWritableString::do_AssignFromElementPtrLength( const CharT* aPtr, PRUint32 aLength ) + { + do_AssignFromReadable(basic_nsLiteralString(aPtr, aLength)); + } + +template +void +basic_nsAWritableString::do_AssignFromElement( CharT aChar ) + { + do_AssignFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Append()| + // + +template +void +basic_nsAWritableString::do_AppendFromReadable( const basic_nsAReadableString& rhs ) { PRUint32 oldLength = Length(); SetLength(oldLength + rhs.Length()); copy_string(rhs.BeginReading(), rhs.EndReading(), BeginWriting(oldLength)); } +#if 0 template void -basic_nsAWritableString::AppendChar( CharT aChar ) +basic_nsAWritableString::do_AppendFromIterators( const nsReadingIterator& aStart, const nsReadingIterator& aEnd ) { - SetLength(Length()+1); - *EndWriting(1) = aChar; + PRUint32 oldLength = Length(); + SetLength(oldLength + distance(aStart, aEnd)); + copy_string(aStart, aEnd, BeginWriting(oldLength)); + } +#endif + +template +void +basic_nsAWritableString::do_AppendFromElementPtr( const CharT* aChar ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar)); } template void -basic_nsAWritableString::Insert( const basic_nsAReadableString& aReadable, PRUint32 aPosition ) +basic_nsAWritableString::do_AppendFromElementPtrLength( const CharT* aChar, PRUint32 aLength ) + { + do_AppendFromReadable(basic_nsLiteralString(aChar, aLength)); + } + +template +void +basic_nsAWritableString::do_AppendFromElement( CharT aChar ) + { + do_AppendFromReadable(basic_nsLiteralChar(aChar)); + } + + + + // + // |Insert()| + // + +template +void +basic_nsAWritableString::do_InsertFromReadable( const basic_nsAReadableString& aReadable, PRUint32 atPosition ) { PRUint32 oldLength = Length(); SetLength(oldLength + aReadable.Length()); - if ( aPosition < oldLength ) - copy_string_backward(BeginReading(aPosition), BeginReading(oldLength), EndWriting()); + if ( atPosition < oldLength ) + copy_string_backward(BeginReading(atPosition), BeginReading(oldLength), EndWriting()); else - aPosition = oldLength; - copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(aPosition)); + atPosition = oldLength; + copy_string(aReadable.BeginReading(), aReadable.EndReading(), BeginWriting(atPosition)); } +template +void +basic_nsAWritableString::do_InsertFromElementPtr( const CharT* aPtr, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElementPtrLength( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength ) + { + do_InsertFromReadable(basic_nsLiteralString(aPtr, aLength), atPosition); + } + +template +void +basic_nsAWritableString::do_InsertFromElement( CharT aChar, PRUint32 atPosition ) + { + do_InsertFromReadable(basic_nsLiteralChar(aChar), atPosition); + } + + + + // + // |Cut()| + // + template void basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) @@ -381,6 +510,12 @@ basic_nsAWritableString::Cut( PRUint32 cutStart, PRUint32 cutLength ) SetLength(Length()-cutLength); } + + + // + // |Replace()| + // + template void basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString& aReplacement ) @@ -405,8 +540,11 @@ basic_nsAWritableString::Replace( PRUint32 cutStart, PRUint32 cutLength, copy_string(aReplacement.BeginReading(), aReplacement.EndReading(), BeginWriting(cutStart)); } -// operator>> -// getline (maybe) + + + // + // Types + // typedef basic_nsAWritableString nsAWritableString; typedef basic_nsAWritableString nsAWritableCString; diff --git a/mozilla/xpcom/string/public/nsSharedString.h b/mozilla/xpcom/string/public/nsSharedString.h index e0af7352591..8195c86d414 100644 --- a/mozilla/xpcom/string/public/nsSharedString.h +++ b/mozilla/xpcom/string/public/nsSharedString.h @@ -69,7 +69,10 @@ class basic_nsSharedString { nsrefcnt result = --mRefCount; if ( !mRefCount ) - delete this; + { + delete this; + // BULLSHIT ALERT: need to make |delete| match |new| + } return result; } @@ -109,7 +112,7 @@ class nsSharedStringPtr // ... private: - basic_nsSharedString* mPtr; + basic_nsSharedString* mRawPtr; };