mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-07-31 17:39:05 +00:00
886 lines
18 KiB
C++
886 lines
18 KiB
C++
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "util\String.h"
|
|
|
|
using namespace Alfresco;
|
|
using namespace std;
|
|
|
|
/**
|
|
* Default constructor
|
|
*/
|
|
String::String() {
|
|
m_string = std::wstring();
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param alloc const unsigned int
|
|
*/
|
|
String::String(const unsigned int alloc) {
|
|
m_string = std::wstring();
|
|
m_string.reserve( alloc);
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param str const char*
|
|
*/
|
|
String::String(const char* str) {
|
|
|
|
// Expand the characters to wide characters and append to the string
|
|
|
|
wchar_t wch;
|
|
|
|
while ( *str != '\0') {
|
|
wch = (wchar_t) *str++;
|
|
m_string += wch;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param str const unsigned char*
|
|
*/
|
|
String::String(const unsigned char* str) {
|
|
|
|
// Expand the characters to wide characters and append to the string
|
|
|
|
wchar_t wch;
|
|
|
|
while ( *str != '\0') {
|
|
wch = (wchar_t) *str++;
|
|
m_string += wch;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param buf const char*
|
|
* @param offset const unsigned int
|
|
* @param len const unsigned int
|
|
*/
|
|
String::String(const char* buf, const unsigned int offset, const unsigned int len) {
|
|
|
|
// Expand the characters to wide characters and append to the string
|
|
|
|
wchar_t wch;
|
|
|
|
const char* str = buf + offset;
|
|
unsigned int sLen = len;
|
|
|
|
while ( sLen--) {
|
|
wch = (wchar_t) *str++;
|
|
m_string += wch;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param str const wchar_t*
|
|
*/
|
|
String::String(const wchar_t* str) {
|
|
m_string = std::wstring( str);
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param buf const wchar_t*
|
|
* @param offset const unsigned int
|
|
* @param len const unsigned int
|
|
*/
|
|
String::String(const wchar_t* buf, const unsigned int offset, const unsigned int len) {
|
|
m_string = std::wstring(buf + offset, len);
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param str const std::wstring&
|
|
*/
|
|
String::String(const std::wstring& str) {
|
|
m_string = str;
|
|
}
|
|
|
|
/**
|
|
* Copy constructor
|
|
*
|
|
* @param str const String&
|
|
*/
|
|
String::String(const String& str) {
|
|
m_string = std::wstring(str.data());
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param byts ByteArray&
|
|
*/
|
|
String::String( ByteArray& byts) {
|
|
|
|
// Expand the characters to wide characters and append to the string
|
|
|
|
wchar_t wch;
|
|
|
|
for ( unsigned int idx = 0; idx < byts.getLength(); idx++) {
|
|
wch = (wchar_t) byts[idx];
|
|
m_string += wch;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compare strings for equality
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::equals(const wchar_t* str) const {
|
|
|
|
// Check that the string is valid
|
|
|
|
if ( str == NULL)
|
|
return false;
|
|
|
|
// Compare the strings
|
|
|
|
if ( m_string.compare(str) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Compare strings for equality
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::equals(const String& str) const {
|
|
|
|
// Compare the strings
|
|
|
|
if ( m_string.compare(str.data()) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Compare strings for equality ignoring case
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::equalsIgnoreCase(const wchar_t* str) const {
|
|
return _wcsicmp( str, data()) == 0 ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Compare strings for equality ignoring case
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::equalsIgnoreCase(const String& str) const {
|
|
return _wcsicmp( str.data(), data()) == 0 ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Compare strings
|
|
*
|
|
* @param str const String&
|
|
* @return int
|
|
*/
|
|
int String::compareTo( const String& str) const {
|
|
return m_string.compare( str.getString());
|
|
}
|
|
|
|
/**
|
|
* Compare strings
|
|
*
|
|
* @param pStr const wchar_t*
|
|
* @return int
|
|
*/
|
|
int String::compareTo( const wchar_t* pStr) const {
|
|
return m_string.compare( pStr);
|
|
}
|
|
|
|
/**
|
|
* Convert the string to lower case returning the resulting String
|
|
*
|
|
* @return String
|
|
*/
|
|
String String::toLowerCase() const {
|
|
|
|
// Create a copy of the string then convert to lowercase
|
|
|
|
std::wstring lstr(m_string);
|
|
|
|
for ( unsigned int i = 0; i < lstr.length(); i++)
|
|
lstr[i] = tolower(lstr[i]);
|
|
|
|
return String(lstr);
|
|
}
|
|
|
|
/**
|
|
* Convert the string to upper case returning the resulting String
|
|
*
|
|
* @return String
|
|
*/
|
|
String String::toUpperCase() const {
|
|
|
|
// Create a copy of the string then convert to uppercase
|
|
|
|
std::wstring ustr(m_string);
|
|
|
|
for ( unsigned int i = 0; i < ustr.length(); i++)
|
|
ustr[i] = toupper(ustr[i]);
|
|
|
|
return String(ustr);
|
|
}
|
|
|
|
/**
|
|
* Return the index of the specified character, or -1 if not found
|
|
*
|
|
* @param ch const wchar_t
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::indexOf(const wchar_t ch, int startIndex) const {
|
|
return (int) m_string.find_first_of( ch, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Return the index of the specified string, or -1 if not found
|
|
*
|
|
* @param str const wchar_t*
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::indexOf(const wchar_t* str, int startIndex) const {
|
|
return (int) m_string.find_first_of( str, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Return the index of the specified string, or -1 if not found
|
|
*
|
|
* @param str const String&
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::indexOf(const String& str, int startIndex) const {
|
|
return (int) m_string.find_first_of( str, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Return the last index of the specified character, or -1 if not found
|
|
*
|
|
* @param ch const wchar_t
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::lastIndexOf(const wchar_t ch, int startIndex) const {
|
|
return (int) m_string.find_last_of( ch, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Return the last index of the specified string, or -1 if not found
|
|
*
|
|
* @param str const wchar_t*
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::lastIndexOf(const wchar_t* str, int startIndex) const {
|
|
return (int) m_string.find_last_of( str, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Return the last index of the specified string, or -1 if not found
|
|
*
|
|
* @param str const String&
|
|
* @param startIndex int
|
|
* @return int
|
|
*/
|
|
int String::lastIndexOf(const String& str, int startIndex) const {
|
|
return (int) m_string.find_last_of( str, startIndex);
|
|
}
|
|
|
|
/**
|
|
* Check if this string starts with the specified string.
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::startsWith(const wchar_t* str) const {
|
|
|
|
// Check if the string to check is valid
|
|
|
|
if ( str == NULL)
|
|
return false;
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
size_t len = wcslen(str);
|
|
if ( str == NULL || wcslen(str) > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string starts with the specified string
|
|
|
|
if ( m_string.compare(0, len, str) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this string starts with the specified string.
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::startsWith(const String& str) const {
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
if ( str.length() > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string starts with the specified string
|
|
|
|
if ( m_string.compare(0, str.length(), str.data()) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this string starts with the specified string, ignoring case.
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::startsWithIgnoreCase(const wchar_t* str) const {
|
|
|
|
// Check if the string to check is valid
|
|
|
|
if ( str == NULL)
|
|
return false;
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
size_t len = wcslen(str);
|
|
if ( str == NULL || wcslen(str) > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string starts with the specified string
|
|
|
|
if ( _wcsnicmp(str, data(), len) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this string starts with the specified string, ignoring case.
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::startsWithIgnoreCase(const String& str) const {
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
if ( str.length() > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string starts with the specified string
|
|
|
|
if ( _wcsnicmp( str.data(), data(), str.length()) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this string ends with the specified string.
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::endsWith(const wchar_t* str) const {
|
|
|
|
// Check if the string to check is valid
|
|
|
|
if ( str == NULL)
|
|
return false;
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
size_t len = wcslen(str);
|
|
if ( str == NULL || wcslen(str) > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string ends with the specified string
|
|
|
|
if ( m_string.compare(m_string.length() - len, len, str) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if this string ends with the specified string.
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::endsWith(const String& str) const {
|
|
|
|
// Get the string length, if the comparison string is longer than this string
|
|
// then there is no match.
|
|
|
|
if ( str.length() > m_string.length())
|
|
return false;
|
|
|
|
// Check if this string ends with the specified string
|
|
|
|
if ( m_string.compare(m_string.length() - str.length(), str.length(), str.data()) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Trim leading and trailing whitespace from the string returning the resulting String
|
|
*
|
|
* @return String
|
|
*/
|
|
String String::trim( void) const {
|
|
std::wstring str = m_string;
|
|
str.erase( str.find_last_not_of( L" ") + 1);
|
|
|
|
return String( str);
|
|
}
|
|
|
|
/**
|
|
* Return a substring of this string
|
|
*
|
|
* @param beginIndex unsigned int
|
|
* @return String
|
|
*/
|
|
String String::substring( unsigned int beginIndex) const {
|
|
std::wstring str = m_string.substr( beginIndex);
|
|
return String(str);
|
|
}
|
|
|
|
/**
|
|
* Return a substring of this string
|
|
*
|
|
* @param beginIndex unsigned int
|
|
* @param endIndex unsigned int
|
|
* @return String
|
|
*/
|
|
String String::substring( unsigned int beginIndex, unsigned int endIndex) const {
|
|
std::wstring str = m_string.substr( beginIndex, (endIndex - beginIndex));
|
|
return String(str);
|
|
}
|
|
|
|
/**
|
|
* Assignment operator
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return String&
|
|
*/
|
|
String& String::operator=(const wchar_t* str) {
|
|
m_string = str;
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Assignment operator
|
|
*
|
|
* @param str const String&
|
|
* @return String&
|
|
*/
|
|
String& String::operator=(const String& str) {
|
|
m_string = str.data();
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Return the string as an array of 8 bit bytes.
|
|
*
|
|
* @param byts ByteArray&
|
|
* @return ByteArray
|
|
*/
|
|
ByteArray String::getBytes( ByteArray& byts) const {
|
|
|
|
// Create a byte array to hold the byte data
|
|
|
|
byts.setLength( length());
|
|
|
|
// Convert the wide characters to ASCII characters
|
|
|
|
for ( unsigned int i = 0; i < length(); i++)
|
|
byts[ i] = (char) (charAt(i) & 0xFF);
|
|
return byts;
|
|
}
|
|
|
|
/**
|
|
* Return the string as an array of 8 bit bytes.
|
|
*
|
|
* @return ByteArray
|
|
*/
|
|
ByteArray String::getBytes( void) const {
|
|
|
|
// Create a byte array to hold the byte data
|
|
|
|
ByteArray byts;
|
|
byts.setLength( length());
|
|
|
|
// Convert the wide characters to ASCII characters
|
|
|
|
for ( unsigned int i = 0; i < length(); i++)
|
|
byts[ i] = (char) (charAt(i) & 0xFF);
|
|
return byts;
|
|
}
|
|
|
|
/**
|
|
* Equality operator
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::operator== ( const String& str) const {
|
|
return equals( str);
|
|
}
|
|
|
|
/**
|
|
* Equality operator
|
|
*
|
|
* @param str const wchar_t*
|
|
* @return bool
|
|
*/
|
|
bool String::operator== ( const wchar_t* str) const {
|
|
return equals( str);
|
|
}
|
|
|
|
/**
|
|
* Equality operator
|
|
*
|
|
* @param str const char*
|
|
* @return bool
|
|
*/
|
|
bool String::operator== ( const char* str) const {
|
|
return equals( String( str));
|
|
}
|
|
|
|
/**
|
|
* Wide character output stream operator
|
|
*
|
|
* @param out wostream&
|
|
* @param str const String&
|
|
* @return wostream&
|
|
*/
|
|
std::wostream& Alfresco::operator<< ( std::wostream& out, const Alfresco::String& str) {
|
|
return out << str.data();
|
|
}
|
|
|
|
/**
|
|
* Less than operator
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool String::operator<( const String& str) const {
|
|
return getString().compare( str.getString()) < 0 ? true : false;
|
|
}
|
|
|
|
/**
|
|
* ASCII character output stream operator
|
|
*
|
|
* @param out ostream&
|
|
* @param str const String&
|
|
* @return ostream&
|
|
*/
|
|
std::ostream& Alfresco::operator<< ( std::ostream& out, const Alfresco::String& str) {
|
|
std::string ascStr;
|
|
ascStr.reserve( str.length());
|
|
|
|
for ( unsigned int i = 0; i < str.length(); i++)
|
|
ascStr += (char) ( str.charAt( i) & 0xFF);
|
|
return out << ascStr.c_str();
|
|
}
|
|
|
|
/**
|
|
* Replace occurrences of the character oldCh with newCh
|
|
*
|
|
* @param oldCh wchar_t
|
|
* @param newCh wchar_t
|
|
*/
|
|
void String::replace( wchar_t oldCh, wchar_t newCh) {
|
|
if ( m_string.size() == 0)
|
|
return;
|
|
for ( unsigned int i = 0; i < m_string.size(); i++) {
|
|
if ( m_string.at( i) == oldCh)
|
|
m_string[i] = newCh;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a character to this string
|
|
*
|
|
* @param ch wchar_t
|
|
*/
|
|
void String::append( wchar_t ch) {
|
|
m_string += ch;
|
|
}
|
|
|
|
/**
|
|
* Append a string to this string
|
|
*
|
|
* @param str const char*
|
|
*/
|
|
void String::append ( const char* str) {
|
|
|
|
// Expand the characters to wide characters and append to the string
|
|
|
|
wchar_t wch;
|
|
|
|
while ( *str != '\0') {
|
|
wch = (wchar_t) *str++;
|
|
m_string += wch;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a string to this string
|
|
*
|
|
* @param str const wchar_t*
|
|
*/
|
|
void String::append (const wchar_t* str) {
|
|
while ( *str != 0)
|
|
m_string += *str++;
|
|
}
|
|
|
|
/**
|
|
* Append a string to this string
|
|
*
|
|
* @param str const String&
|
|
*/
|
|
void String::append (const String& str) {
|
|
m_string += str.getString();
|
|
}
|
|
|
|
/**
|
|
* Append an integer value to this string
|
|
*
|
|
* @param ival const unsigned int
|
|
*/
|
|
void String::append (const unsigned int ival) {
|
|
wchar_t buf[32];
|
|
swprintf( buf, 32, L"%u", ival);
|
|
|
|
m_string += buf;
|
|
}
|
|
|
|
/**
|
|
* Append a long value to this string
|
|
*
|
|
* @param lval const unsigned long
|
|
*/
|
|
void String::append (const unsigned long lval) {
|
|
wchar_t buf[32];
|
|
swprintf( buf, 32, L"%lu", lval);
|
|
|
|
m_string += buf;
|
|
}
|
|
|
|
/**
|
|
* Append a long/64 bit value to this string
|
|
*
|
|
* @param l64val const unsigned long
|
|
*/
|
|
void String::append (const LONG64 l64val) {
|
|
wchar_t buf[32];
|
|
swprintf( buf, 32, L"%I64u", l64val);
|
|
|
|
m_string += buf;
|
|
}
|
|
|
|
/**
|
|
* Split a string into tokens
|
|
*
|
|
* @param delims const String&
|
|
* @return StringList
|
|
*/
|
|
StringList String::tokenize( const String& delims) const {
|
|
|
|
// Skip leading delimiters
|
|
|
|
StringList tokens;
|
|
string::size_type lastPos = m_string.find_first_not_of( delims, 0);
|
|
|
|
// Find a non-delimiter character
|
|
|
|
string::size_type pos = m_string.find_first_of( delims, lastPos);
|
|
|
|
while ( pos != string::npos || lastPos != string::npos) {
|
|
|
|
// Add the current token to the list
|
|
|
|
tokens.addString( m_string.substr( lastPos, pos - lastPos));
|
|
|
|
// Skip delimiter(s)
|
|
|
|
lastPos = m_string.find_first_not_of( delims, pos);
|
|
|
|
// Find next token
|
|
|
|
pos = m_string.find_first_of( delims, lastPos);
|
|
}
|
|
|
|
// Return the token list
|
|
|
|
return tokens;
|
|
}
|
|
|
|
/**
|
|
* Default constructor
|
|
*/
|
|
StringList::StringList( void) {
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param reserve unsigned int
|
|
*/
|
|
StringList::StringList( unsigned int reserve) {
|
|
m_list.reserve( reserve);
|
|
}
|
|
|
|
/**
|
|
* Copy constructor
|
|
*
|
|
* @param strList const StringList&
|
|
*/
|
|
StringList::StringList( const StringList& strList) {
|
|
copyFrom( strList);
|
|
}
|
|
|
|
/**
|
|
* Copy strings from the specified list
|
|
*
|
|
* @param strList const StringList&
|
|
*/
|
|
void StringList::copyFrom( const StringList& strList) {
|
|
for ( unsigned int idx = 0; idx < strList.numberOfStrings(); idx++)
|
|
addString( strList.getStringAt( idx));
|
|
}
|
|
|
|
/**
|
|
* Check if the list contains the string
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool StringList::containsString ( const String& str) {
|
|
for ( std::vector<String>::iterator pos = m_list.begin(); pos < m_list.end(); pos++) {
|
|
if ( str.equals( *pos))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if the list contains the string, ignoring case
|
|
*
|
|
* @param str const String&
|
|
* @return bool
|
|
*/
|
|
bool StringList::containsStringCaseless ( const String& str) {
|
|
for ( std::vector<String>::iterator pos = m_list.begin(); pos < m_list.end(); pos++) {
|
|
if ( str.equalsIgnoreCase( *pos))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Find the specified string and return the position within the list, or -1 if not found
|
|
*
|
|
* @param str const String&
|
|
* @return int
|
|
*/
|
|
int StringList::indexOf( const String& str) const {
|
|
for ( unsigned int i = 0; i < m_list.size(); i++) {
|
|
if ( m_list[i].equals( str))
|
|
return (int) i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Remove the specified string from the list
|
|
*
|
|
* @param str const String&
|
|
*/
|
|
void StringList::removeString ( const String& str) {
|
|
for ( std::vector<String>::iterator pos = m_list.begin(); pos < m_list.end(); pos++) {
|
|
if ( str.equals( *pos)) {
|
|
m_list.erase( pos);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the specified string from the list, ignoring case
|
|
*
|
|
* @param str const String&
|
|
*/
|
|
void StringList::removeStringCaseless ( const String& str) {
|
|
for ( std::vector<String>::iterator pos = m_list.begin(); pos < m_list.end(); pos++) {
|
|
if ( str.equalsIgnoreCase( *pos)) {
|
|
m_list.erase( pos);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the string list as a comma separated string
|
|
*
|
|
* @return String
|
|
*/
|
|
String StringList::toString( void) const {
|
|
String ret;
|
|
|
|
for ( unsigned int i = 0; i < numberOfStrings(); i++) {
|
|
ret += getStringAt( i);
|
|
ret += ",";
|
|
}
|
|
|
|
return ret;
|
|
}
|