1998-04-14 00:24:54 +04:00
|
|
|
/* -*- 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.
|
|
|
|
*/
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
MODULE NOTES:
|
|
|
|
|
1999-08-30 10:55:13 +04:00
|
|
|
See nsStr.h for a more general description of string classes.
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
This version of the nsString class offers many improvements over the
|
|
|
|
original version:
|
|
|
|
1. Wide and narrow chars
|
|
|
|
2. Allocators
|
|
|
|
3. Much smarter autostrings
|
|
|
|
4. Subsumable strings
|
1998-09-04 21:26:37 +04:00
|
|
|
***********************************************************************/
|
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
#ifndef _nsCString_
|
|
|
|
#define _nsCString_
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
#include "nsString2.h"
|
1998-04-14 00:24:54 +04:00
|
|
|
#include "prtypes.h"
|
|
|
|
#include "nscore.h"
|
|
|
|
#include <stdio.h>
|
1999-04-25 07:50:10 +04:00
|
|
|
#include "nsStr.h"
|
1999-07-17 11:26:16 +04:00
|
|
|
#include "nsIAtom.h"
|
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
class NS_COM nsSubsumeCStr;
|
1999-05-06 09:13:08 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
class NS_COM nsCString : public nsStr {
|
1999-05-06 09:13:08 +04:00
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
public:
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/**
|
1999-08-30 10:55:13 +04:00
|
|
|
* Default constructor.
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString(nsIMemoryAgent* anAgent=0);
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This constructor accepts an isolatin string
|
1999-07-17 11:26:16 +04:00
|
|
|
* @param aCString is a ptr to a 1-byte cstr
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString(const char* aCString,PRInt32 aLength=-1,nsIMemoryAgent* anAgent=0);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* This constructor accepts a unichar string
|
|
|
|
* @param aCString is a ptr to a 2-byte cstr
|
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString(const PRUnichar* aString,PRInt32 aLength=-1,nsIMemoryAgent* anAgent=0);
|
1999-07-17 11:26:16 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This is a copy constructor that accepts an nsStr
|
|
|
|
* @param reference to another nsCString
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString(const nsStr&,nsIMemoryAgent* anAgent=0);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* This is our copy constructor
|
|
|
|
* @param reference to another nsCString
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString(const nsCString& aString);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-09 09:11:25 +04:00
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* This constructor takes a subsumestr
|
|
|
|
* @param reference to subsumestr
|
1999-07-09 09:11:25 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString(nsSubsumeCStr& aSubsumeStr);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/**
|
|
|
|
* Destructor
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
virtual ~nsCString();
|
1999-07-09 09:11:25 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-09 10:01:55 +04:00
|
|
|
* Retrieve the length of this string
|
1999-07-09 09:11:25 +04:00
|
|
|
* @return string length
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
inline PRInt32 Length() const { return (PRInt32)mLength; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve the size of this string
|
|
|
|
* @return string length
|
|
|
|
*/
|
1999-08-31 07:04:37 +04:00
|
|
|
virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
|
1999-07-17 11:26:16 +04:00
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/**
|
|
|
|
* Call this method if you want to force a different string capacity
|
|
|
|
* @update gess7/30/98
|
|
|
|
* @param aLength -- contains new length for mStr
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
void SetLength(PRUint32 aLength) {
|
|
|
|
Truncate(aLength);
|
|
|
|
}
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the new length of the string.
|
|
|
|
* @param aLength is new string length.
|
|
|
|
* @return nada
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
void SetCapacity(PRUint32 aLength);
|
1998-09-04 21:26:37 +04:00
|
|
|
/**
|
|
|
|
* This method truncates this string to given length.
|
|
|
|
*
|
|
|
|
* @param anIndex -- new length of string
|
|
|
|
* @return nada
|
|
|
|
*/
|
|
|
|
void Truncate(PRInt32 anIndex=0);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Determine whether or not the characters in this
|
|
|
|
* string are in sorted order.
|
|
|
|
*
|
|
|
|
* @return TRUE if ordered.
|
1999-07-09 10:01:55 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool IsOrdered(void) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
1999-05-29 11:29:46 +04:00
|
|
|
/**
|
|
|
|
* Determine whether or not this string has a length of 0
|
|
|
|
*
|
|
|
|
* @return TRUE if empty.
|
|
|
|
*/
|
|
|
|
PRBool IsEmpty(void) const {
|
|
|
|
return PRBool(0==mLength);
|
|
|
|
}
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/**********************************************************************
|
|
|
|
Accessor methods...
|
|
|
|
*********************************************************************/
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
const char* GetBuffer(void) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/**
|
|
|
|
* Get nth character.
|
|
|
|
*/
|
|
|
|
PRUnichar operator[](PRUint32 anIndex) const;
|
|
|
|
PRUnichar CharAt(PRUint32 anIndex) const;
|
|
|
|
PRUnichar First(void) const;
|
|
|
|
PRUnichar Last(void) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex);
|
1999-03-22 11:29:26 +03:00
|
|
|
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/**********************************************************************
|
|
|
|
String creation methods...
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new string by appending given string to this
|
|
|
|
* @param aString -- 2nd string to be appended
|
|
|
|
* @return new string
|
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsSubsumeCStr operator+(const nsCString& aString);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-08-30 10:55:13 +04:00
|
|
|
* create a new string by adding this to the given char*.
|
1998-11-21 01:11:09 +03:00
|
|
|
* @param aCString is a ptr to cstring to be added to this
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return newly created string
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsSubsumeCStr operator+(const char* aCString);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* create a new string by adding this to the given char.
|
|
|
|
* @param aChar is a char to be added to this
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return newly created string
|
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsSubsumeCStr operator+(PRUnichar aChar);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsSubsumeCStr operator+(char aChar);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/**********************************************************************
|
|
|
|
Lexomorphic transforms...
|
|
|
|
*********************************************************************/
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-01-09 04:09:39 +03:00
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Converts chars in this to lowercase
|
|
|
|
* @update gess 7/27/98
|
1999-01-09 04:09:39 +03:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
void ToLowerCase();
|
|
|
|
|
1999-01-09 04:09:39 +03:00
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Converts chars in this to lowercase, and
|
|
|
|
* stores them in aOut
|
|
|
|
* @update gess 7/27/98
|
|
|
|
* @param aOut is a string to contain result
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
void ToLowerCase(nsCString& aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Converts chars in this to uppercase
|
|
|
|
* @update gess 7/27/98
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
void ToUpperCase();
|
1999-07-09 09:11:25 +04:00
|
|
|
|
1999-07-09 10:01:55 +04:00
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Converts chars in this to lowercase, and
|
|
|
|
* stores them in a given output string
|
|
|
|
* @update gess 7/27/98
|
|
|
|
* @param aOut is a string to contain result
|
1999-07-09 10:01:55 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
void ToUpperCase(nsCString& aString) const;
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* 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
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& StripChars(const char* aSet);
|
1999-09-30 08:03:49 +04:00
|
|
|
nsCString& StripChar(char aChar);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* This method strips whitespace throughout the string
|
|
|
|
*
|
|
|
|
* @return this
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& StripWhitespace();
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* swaps occurence of 1 string for another
|
|
|
|
*
|
|
|
|
* @return this
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& ReplaceChar(PRUnichar aOldChar,PRUnichar aNewChar);
|
|
|
|
nsCString& ReplaceChar(const char* aSet,PRUnichar aNewChar);
|
|
|
|
|
|
|
|
PRInt32 CountChar(PRUnichar aChar);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* 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
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Trim(const char* aSet,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* 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
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& CompressSet(const char* aSet, PRUnichar aChar,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* 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
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**********************************************************************
|
1999-07-17 11:26:16 +04:00
|
|
|
string conversion methods...
|
1998-09-04 21:26:37 +04:00
|
|
|
*********************************************************************/
|
|
|
|
|
1999-07-18 04:03:43 +04:00
|
|
|
operator char*() {return mStr;}
|
|
|
|
operator const char*() const {return (const char*)mStr;}
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/**
|
1999-08-30 10:55:13 +04:00
|
|
|
* This method constructs a new nsCString that is a clone
|
1999-07-17 11:26:16 +04:00
|
|
|
* of this string.
|
|
|
|
*
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString* ToNewString() const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Creates an ISOLatin1 clone of this string
|
1999-08-30 10:55:13 +04:00
|
|
|
* Note that calls to this method should be matched with calls to Recycle().
|
1999-07-17 11:26:16 +04:00
|
|
|
* @return ptr to new isolatin1 string
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
char* ToNewCString() const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Creates a unicode clone of this string
|
1999-08-30 10:55:13 +04:00
|
|
|
* Note that calls to this method should be matched with calls to Recycle().
|
1999-07-17 11:26:16 +04:00
|
|
|
* @return ptr to new unicode string
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRUnichar* ToNewUnicode() const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Copies data from internal buffer onto given char* buffer
|
1999-08-30 10:55:13 +04:00
|
|
|
* NOTE: This only copies as many chars as will fit in given buffer (clips)
|
1999-07-17 11:26:16 +04:00
|
|
|
* @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
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
char* ToCString(char* aBuf,PRUint32 aBufLength,PRUint32 anOffset=0) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Perform string to float conversion.
|
|
|
|
* @param aErrorCode will contain error if one occurs
|
|
|
|
* @return float rep of string value
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
float ToFloat(PRInt32* aErrorCode) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Try to derive the radix from the value contained in this string
|
|
|
|
* @return kRadix10, kRadix16 or kAutoDetect (meaning unknown)
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRUint32 DetermineRadix(void);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-09 10:01:55 +04:00
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Perform string to int conversion.
|
|
|
|
* @param aErrorCode will contain error if one occurs
|
|
|
|
* @return int rep of string value
|
1999-07-09 10:01:55 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=kRadix10) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/**********************************************************************
|
|
|
|
String manipulation methods...
|
|
|
|
*********************************************************************/
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Functionally equivalent to assign or operator=
|
|
|
|
*
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& SetString(const char* aString,PRInt32 aLength=-1) {return Assign(aString,aLength);}
|
|
|
|
nsCString& SetString(const nsStr& aString,PRInt32 aLength=-1) {return Assign(aString,aLength);}
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* assign given string to this string
|
|
|
|
* @param aStr: buffer to be assigned to this
|
1999-07-09 10:01:55 +04:00
|
|
|
* @param alength is the length of the given str (or -1)
|
|
|
|
if you want me to determine its length
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return this
|
|
|
|
*/
|
1999-08-30 10:55:13 +04:00
|
|
|
nsCString& Assign(const nsStr& aString,PRInt32 aCount=-1);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Assign(const char* aString,PRInt32 aCount=-1);
|
1999-08-30 10:55:13 +04:00
|
|
|
nsCString& Assign(const PRUnichar* aString,PRInt32 aCount=-1);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Assign(PRUnichar aChar);
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& Assign(char aChar);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* here come a bunch of assignment operators...
|
|
|
|
* @param aString: string to be added to this
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return this
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& operator=(const nsCString& aString) {return Assign(aString);}
|
1999-08-30 10:55:13 +04:00
|
|
|
nsCString& operator=(const nsStr& aString) {return Assign(aString);}
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& operator=(PRUnichar aChar) {return Assign(aChar);}
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& operator=(char aChar) {return Assign(aChar);}
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& operator=(const char* aCString) {return Assign(aCString);}
|
1999-08-30 10:55:13 +04:00
|
|
|
nsCString& operator=(const PRUnichar* aString) {return Assign(aString);}
|
1999-07-17 11:26:16 +04:00
|
|
|
#ifdef AIX
|
|
|
|
nsCString& operator=(const nsSubsumeCStr& aSubsumeString); // AIX requires a const here
|
|
|
|
#else
|
|
|
|
nsCString& operator=(nsSubsumeCStr& aSubsumeString);
|
|
|
|
#endif
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1999-07-09 10:01:55 +04:00
|
|
|
/**
|
1999-08-30 10:55:13 +04:00
|
|
|
* Here's a bunch of methods that append varying types...
|
|
|
|
* @param various...
|
1999-07-09 10:01:55 +04:00
|
|
|
* @return this
|
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& operator+=(const nsCString& aString){return Append(aString,aString.mLength);}
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& operator+=(const char* aCString) {return Append(aCString);}
|
|
|
|
nsCString& operator+=(PRUnichar aChar){return Append(aChar);}
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& operator+=(char aChar){return Append(aChar);}
|
1999-07-09 10:01:55 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/*
|
|
|
|
* Appends n characters from given string to this,
|
|
|
|
* This version computes the length of your given string
|
|
|
|
*
|
|
|
|
* @param aString is the source to be appended to this
|
|
|
|
* @return number of chars copied
|
1999-07-09 10:01:55 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Append(const nsCString& aString) {return Append(aString,aString.mLength);}
|
|
|
|
|
1999-07-09 10:01:55 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/*
|
|
|
|
* Appends n characters from given string to this,
|
|
|
|
*
|
|
|
|
* @param aString is the source to be appended to this
|
1999-07-20 10:58:41 +04:00
|
|
|
* @param aCount -- number of chars to copy; -1 tells us to compute the strlen for you
|
1999-07-17 11:26:16 +04:00
|
|
|
* @return number of chars copied
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& Append(const nsCString& aString,PRInt32 aCount);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Append(const char* aString,PRInt32 aCount=-1);
|
|
|
|
nsCString& Append(PRUnichar aChar);
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& Append(char aChar);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Append(PRInt32 aInteger,PRInt32 aRadix=10); //radix=8,10 or 16
|
|
|
|
nsCString& Append(float aFloat);
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRUint32 Left(nsCString& aCopy,PRInt32 aCount) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRUint32 Mid(nsCString& aCopy,PRUint32 anOffset,PRInt32 aCount) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRUint32 Right(nsCString& aCopy,PRInt32 aCount) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
1999-07-25 21:20:37 +04:00
|
|
|
* @param aCount -- number of chars to be copied from aCopy
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return number of chars inserted into this.
|
|
|
|
*/
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& Insert(const nsCString& aCopy,PRUint32 anOffset,PRInt32 aCount=-1);
|
1999-07-17 11:26:16 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Insert a given string into this string at
|
|
|
|
* a specified offset.
|
|
|
|
*
|
|
|
|
* @param aString* to be inserted into this string
|
|
|
|
* @param anOffset is insert pos in str
|
|
|
|
* @return the number of chars inserted into this string
|
|
|
|
*/
|
|
|
|
nsCString& Insert(const char* aChar,PRUint32 anOffset,PRInt32 aCount=-1);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Insert a single char into this string at
|
1998-09-04 21:26:37 +04:00
|
|
|
* a specified offset.
|
|
|
|
*
|
1999-07-17 11:26:16 +04:00
|
|
|
* @param character to be inserted into this string
|
1998-09-04 21:26:37 +04:00
|
|
|
* @param anOffset is insert pos in str
|
|
|
|
* @return the number of chars inserted into this string
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Insert(PRUnichar aChar,PRUint32 anOffset);
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCString& Insert(char aChar,PRUint32 anOffset);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCString& Cut(PRUint32 anOffset,PRInt32 aCount);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
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
|
1999-08-30 10:55:13 +04:00
|
|
|
* @param aIgnoreCase selects case sensitivity
|
1999-07-17 11:26:16 +04:00
|
|
|
* @param anOffset tells us where in this strig to start searching
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return offset in string, or -1 (kNotFound)
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 Find(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Search for given char within this string
|
|
|
|
*
|
1999-07-17 11:26:16 +04:00
|
|
|
* @param aString is substring to be sought in this
|
|
|
|
* @param anOffset tells us where in this strig to start searching
|
|
|
|
* @param aIgnoreCase selects case sensitivity
|
|
|
|
* @return find pos in string, or -1 (kNotFound)
|
1998-09-04 21:26:37 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 FindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* This method searches this string for the first character
|
1999-08-30 10:55:13 +04:00
|
|
|
* found in the given charset
|
1998-09-04 21:26:37 +04:00
|
|
|
* @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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 FindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 FindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) const;
|
|
|
|
|
1999-07-09 09:11:25 +04:00
|
|
|
|
|
|
|
/**
|
1999-07-17 11:26:16 +04:00
|
|
|
* Search for given char within this string
|
|
|
|
*
|
|
|
|
* @param aString is substring to be sought in this
|
|
|
|
* @param anOffset tells us where in this strig to start searching
|
|
|
|
* @param aIgnoreCase selects case sensitivity
|
|
|
|
* @return find pos in string, or -1 (kNotFound)
|
1999-07-09 09:11:25 +04:00
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRInt32 RFindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1) 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=-1) const;
|
|
|
|
PRInt32 RFindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const;
|
|
|
|
PRInt32 RFindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const;
|
|
|
|
|
|
|
|
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
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
|
1999-07-19 01:26:03 +04:00
|
|
|
* @param aCount tells us how many chars to compare
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return -1,0,1
|
|
|
|
*/
|
1999-07-19 01:26:03 +04:00
|
|
|
virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* These methods compare a given string type to this one
|
|
|
|
* @param aString is the string to be compared to this
|
|
|
|
* @return TRUE or FALSE
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator==(const nsStr &aString) const;
|
1999-07-25 21:20:37 +04:00
|
|
|
PRBool operator==(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
PRBool operator==(const 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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator!=(const nsStr &aString) const;
|
|
|
|
PRBool operator!=(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator<(const nsStr &aString) const;
|
|
|
|
PRBool operator<(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator>(const nsStr &S) const;
|
|
|
|
PRBool operator>(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator<=(const nsStr &S) const;
|
|
|
|
PRBool operator<=(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
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
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool operator>=(const nsStr &S) const;
|
|
|
|
PRBool operator>=(const char* aString) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
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
|
1999-07-17 11:26:16 +04:00
|
|
|
* @param aCount -- number of chars in given string you want to compare
|
1998-09-04 21:26:37 +04:00
|
|
|
* @return TRUE if equal
|
|
|
|
*/
|
1999-07-17 11:26:16 +04:00
|
|
|
PRBool Equals(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
PRBool Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
PRBool Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
PRBool Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
|
|
|
|
|
|
|
|
PRBool EqualsIgnoreCase(const nsStr& aString) const;
|
|
|
|
PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const;
|
|
|
|
PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const;
|
1998-09-04 21:26:37 +04:00
|
|
|
|
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
static void Recycle(nsCString* aString);
|
|
|
|
static nsCString* CreateString(void);
|
1998-09-04 21:26:37 +04:00
|
|
|
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
nsIMemoryAgent* mAgent;
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
};
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
extern NS_COM int fputs(const nsCString& aString, FILE* out);
|
1999-07-17 14:08:10 +04:00
|
|
|
//ostream& operator<<(ostream& aStream,const nsCString& aString);
|
|
|
|
//virtual void DebugDump(ostream& aStream) const;
|
1999-07-17 11:26:16 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**************************************************************
|
|
|
|
Here comes the AutoString class which uses internal memory
|
|
|
|
(typically found on the stack) for its default buffer.
|
|
|
|
If the buffer needs to grow, it gets reallocated on the heap.
|
|
|
|
**************************************************************/
|
|
|
|
|
|
|
|
class NS_COM nsCAutoString : public nsCString {
|
|
|
|
public:
|
|
|
|
|
|
|
|
nsCAutoString();
|
|
|
|
nsCAutoString(const char* aString,PRInt32 aLength=-1);
|
1999-08-24 04:52:32 +04:00
|
|
|
nsCAutoString(const CBufDescriptor& aBuffer);
|
1999-07-17 11:26:16 +04:00
|
|
|
nsCAutoString(const PRUnichar* aString,PRInt32 aLength=-1);
|
|
|
|
nsCAutoString(const nsStr& aString);
|
|
|
|
nsCAutoString(const nsCAutoString& aString);
|
|
|
|
|
|
|
|
#ifdef AIX
|
|
|
|
nsCAutoString(const nsSubsumeCStr& aSubsumeStr); // AIX requires a const
|
|
|
|
#else
|
|
|
|
nsCAutoString(nsSubsumeCStr& aSubsumeStr);
|
|
|
|
#endif // AIX
|
|
|
|
nsCAutoString(PRUnichar aChar);
|
|
|
|
virtual ~nsCAutoString();
|
|
|
|
|
1999-07-25 21:20:37 +04:00
|
|
|
nsCAutoString& operator=(const nsCString& aString) {nsCString::Assign(aString); return *this;}
|
|
|
|
nsCAutoString& operator=(const char* aCString) {nsCString::Assign(aCString); return *this;}
|
|
|
|
nsCAutoString& operator=(PRUnichar aChar) {nsCString::Assign(aChar); return *this;}
|
|
|
|
nsCAutoString& operator=(char aChar) {nsCString::Assign(aChar); return *this;}
|
1999-07-17 11:26:16 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrieve the size of this string
|
|
|
|
* @return string length
|
|
|
|
*/
|
1999-08-31 07:04:37 +04:00
|
|
|
virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
|
1999-07-17 11:26:16 +04:00
|
|
|
|
1999-08-30 10:55:13 +04:00
|
|
|
char mBuffer[kDefaultStringSize];
|
1998-04-14 00:24:54 +04:00
|
|
|
};
|
|
|
|
|
1999-09-02 11:04:59 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
/***************************************************************
|
|
|
|
The subsumestr class is very unusual.
|
|
|
|
It differs from a normal string in that it doesn't use normal
|
|
|
|
copy semantics when another string is assign to this.
|
|
|
|
Instead, it "steals" the contents of the source string.
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
This is very handy for returning nsString classes as part of
|
|
|
|
an operator+(...) for example, in that it cuts down the number
|
|
|
|
of copy operations that must occur.
|
1998-04-14 00:24:54 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
You should probably not use this class unless you really know
|
|
|
|
what you're doing.
|
|
|
|
***************************************************************/
|
|
|
|
class NS_COM nsSubsumeCStr : public nsCString {
|
1998-04-14 00:24:54 +04:00
|
|
|
public:
|
1999-07-17 11:26:16 +04:00
|
|
|
nsSubsumeCStr(nsStr& aString);
|
|
|
|
nsSubsumeCStr(PRUnichar* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
|
|
|
|
nsSubsumeCStr(char* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
|
1999-07-09 10:01:55 +04:00
|
|
|
|
1999-09-02 11:04:59 +04:00
|
|
|
};
|
1999-07-17 11:26:16 +04:00
|
|
|
|
1999-07-09 10:01:55 +04:00
|
|
|
|
|
|
|
#endif
|
1999-07-09 09:11:25 +04:00
|
|
|
|
1999-07-17 11:26:16 +04:00
|
|
|
|