summaryrefslogtreecommitdiffstats
path: root/qtools/qcstring.h
diff options
context:
space:
mode:
Diffstat (limited to 'qtools/qcstring.h')
-rw-r--r--qtools/qcstring.h806
1 files changed, 252 insertions, 554 deletions
diff --git a/qtools/qcstring.h b/qtools/qcstring.h
index b126194..0f3f932 100644
--- a/qtools/qcstring.h
+++ b/qtools/qcstring.h
@@ -22,52 +22,21 @@
#endif // QT_H
#include <string>
+#include <algorithm>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if !defined(_OS_WIN32_) || defined(__MINGW32__)
-#include <stdint.h>
-#endif
-
-#if defined(_OS_SUN_) && defined(_CC_GNU_)
-#include <strings.h>
-#endif
-
-#include <assert.h>
+#include <cctype>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <cstdint>
class QGString;
/*****************************************************************************
- Fixes and workarounds for some platforms
- *****************************************************************************/
-
-#if defined(_OS_HPUX_)
-// HP-UX has badly defined strstr() etc.
-// ### fix in 3.0: change hack_* to qt_hack_*
-// by the way HP-UX is probably right, the standard has evolved and
-// we'll have to adapt to it
-inline char *hack_strstr( const char *s1, const char *s2 )
-{ return (char *)strstr(s1, s2); }
-inline char *hack_strchr( const char *s, int c )
-{ return (char *)strchr(s, c); }
-inline char *hack_strrchr( const char *s, int c )
-{ return (char *)strrchr(s, c); }
-#define strstr(s1,s2) hack_strstr((s1),(s2))
-#define strchr(s,c) hack_strchr((s),(c))
-#define strrchr(s,c) hack_strrchr((s),(c))
-#endif
-
-/*****************************************************************************
Safe and portable C string functions; extensions to standard string.h
*****************************************************************************/
-Q_EXPORT void *qmemmove( void *dst, const void *src, uint len );
-
-#if defined(_OS_SUN_) || defined(_CC_OC_)
-#define memmove(s1,s2,n) qmemmove((s1),(s2),(n))
-#endif
+void *qmemmove( void *dst, const void *src, uint len );
#if defined(_OS_WIN32_)
#define qsnprintf _snprintf
@@ -75,45 +44,45 @@ Q_EXPORT void *qmemmove( void *dst, const void *src, uint len );
#define qsnprintf snprintf
#endif
-Q_EXPORT char *qstrdup( const char * );
+char *qstrdup( const char * );
-Q_EXPORT inline uint cstrlen( const char *str )
+inline uint cstrlen( const char *str )
{ return (uint)strlen(str); }
-Q_EXPORT inline uint qstrlen( const char *str )
+inline uint qstrlen( const char *str )
{ return str ? (uint)strlen(str) : 0; }
-Q_EXPORT inline char *cstrcpy( char *dst, const char *src )
+inline char *cstrcpy( char *dst, const char *src )
{ return strcpy(dst,src); }
-Q_EXPORT inline char *qstrcpy( char *dst, const char *src )
+inline char *qstrcpy( char *dst, const char *src )
{ return src ? strcpy(dst, src) : 0; }
-Q_EXPORT char * qstrncpy(char *src,const char *dst, uint len);
+char * qstrncpy(char *src,const char *dst, uint len);
-Q_EXPORT inline int cstrcmp( const char *str1, const char *str2 )
+inline int cstrcmp( const char *str1, const char *str2 )
{ return strcmp(str1,str2); }
-Q_EXPORT inline int qstrcmp( const char *str1, const char *str2 )
+inline int qstrcmp( const char *str1, const char *str2 )
{ return (str1 && str2) ? strcmp(str1,str2) : (int)((intptr_t)str2 - (intptr_t)str1); }
-Q_EXPORT inline int cstrncmp( const char *str1, const char *str2, uint len )
+inline int cstrncmp( const char *str1, const char *str2, uint len )
{ return strncmp(str1,str2,len); }
-Q_EXPORT inline int qstrncmp( const char *str1, const char *str2, uint len )
+inline int qstrncmp( const char *str1, const char *str2, uint len )
{ return (str1 && str2) ? strncmp(str1,str2,len) :
(int)((intptr_t)str2 - (intptr_t)str1); }
-Q_EXPORT int qstricmp( const char *str1, const char *str2 );
+int qstricmp( const char *str1, const char *str2 );
-Q_EXPORT int qstrnicmp( const char *str1, const char *str2, uint len );
+int qstrnicmp( const char *str1, const char *str2, uint len );
/*****************************************************************************
QByteArray class
*****************************************************************************/
#if defined(Q_TEMPLATEDLL)
-template class Q_EXPORT QArray<char>;
+template class QArray<char>;
#endif
typedef QArray<char> QByteArray;
@@ -121,120 +90,75 @@ typedef QArray<char> QByteArray;
QByteArray stream functions
*****************************************************************************/
#ifndef QT_NO_DATASTREAM
-Q_EXPORT QDataStream &operator<<( QDataStream &, const QByteArray & );
-Q_EXPORT QDataStream &operator>>( QDataStream &, QByteArray & );
+QDataStream &operator<<( QDataStream &, const QByteArray & );
+QDataStream &operator>>( QDataStream &, QByteArray & );
#endif
class QRegExp;
/** This is an alternative implementation of QCString. It provides basically
- * the same functions but uses reference counting and copy on write.
+ * the same functions but uses std::string as the underlying string type
*/
class QCString
{
-public:
- /** creates an empty string */
- QCString() : m_rep()
- {
- }
-
- /** destroys the string */
- ~QCString()
- {
- }
+ public:
+ QCString() = default;
+ ~QCString() = default;
+ QCString( const QCString &s ) = default;
+ QCString &operator=( const QCString &s ) = default;
+ QCString( QCString &&s ) = default;
+ QCString &operator=( QCString &&s ) = default;
- /** makes a copy of a string. */
- QCString( const QCString &s ) : m_rep(s.m_rep)
- {
- }
+ QCString( const std::string &s ) : m_rep(s) {}
/** creates a string with room for size characters
- * @param[in] size the number of character to allocate (including the 0-terminator)
+ * @param[in] size the number of character to allocate (also counting the 0-terminator!)
*/
- explicit QCString( uint size ) : m_rep(size)
- {
- }
+ explicit QCString( uint size ) { m_rep.resize(size>0 ? size-1 : 0); }
/** creates a string from a plain C string.
* @param[in] str A zero terminated C string. When 0 an empty string is created.
*/
- QCString( const char *str ) : m_rep(str)
- {
- }
+ QCString( const char *str ) : m_rep(str?str:"") {}
/** creates a string from \a str and copies over the first \a maxlen characters. */
- QCString( const char *str, uint maxlen ) : m_rep(str,maxlen)
- {
- }
+ QCString( const char *str, uint maxlen ) : m_rep(str?str:"") { m_rep.resize(maxlen); }
/** replaces the contents by that of string \a s. */
- QCString &operator=( const QCString &s )
- {
- m_rep = s.m_rep;
- return *this;
- }
/** replaces the contents by that of C string \a str. */
- QCString &operator=( const char *str)
- {
- m_rep = str;
- return *this;
- }
+ QCString &operator=( const char *str) { m_rep = str?str:""; return *this; }
/** Returns TRUE iff the string is empty. Equivalent to isEmpty(). */
- bool isNull() const
- {
- return m_rep.isEmpty();
- }
+ bool isNull() const { return m_rep.empty(); }
/** Returns TRUE iff the string is empty */
- bool isEmpty() const
- {
- return m_rep.isEmpty();
- }
+ bool isEmpty() const { return m_rep.empty(); }
- /** Returns the length of the string, excluding the 0-terminator. Equivalent to size(). */
- uint length() const
- {
- return m_rep.length();
- }
+ /** Returns the length of the string, not counting the 0-terminator. Equivalent to size(). */
+ uint length() const { return (uint)m_rep.size(); }
- /** Returns the length of the string, excluding the 0-terminator. */
- uint size() const
- {
- return m_rep.length();
- }
+ /** Returns the length of the string, not counting the 0-terminator. */
+ uint size() const { return (uint)m_rep.size(); }
/** Returns a pointer to the contents of the string in the form of a 0-terminated C string */
- const char *data() const
- {
- return m_rep.data();
- }
+ const char *data() const { return m_rep.empty() ? 0 : m_rep.c_str(); }
/** Returns a writable pointer to the data.
* @warning if the string is shared it will modifying the string directly and
* this will overwrite all copies as well!
*/
- char *rawData() const
- {
- return m_rep.rawData();
- }
+ char *rawData() const { return m_rep.empty() ? 0 : const_cast<char*>(&m_rep[0]); }
/** Resizes the string to hold \a newlen characters
- * (this value should include the 0-terminator). If the string is enlarged the contents will
+ * (this value should also count the 0-terminator).
+ * If the string is enlarged the contents will
* be left unmodified.
*/
- bool resize( uint newlen )
- {
- m_rep.resize(newlen);
- return TRUE;
- }
+ bool resize( uint newlen ) { m_rep.resize( newlen>0 ? newlen-1 : 0 ); return TRUE; }
/** Truncates the string at position \a pos. */
- bool truncate( uint pos )
- {
- return resize(pos+1);
- }
+ bool truncate( uint pos ) { return resize( pos + 1 ); }
/** Fills a string with a predefined character
* @param[in] c the character used to fill the string with.
@@ -244,523 +168,286 @@ public:
*/
bool fill( char c, int len = -1 )
{
- m_rep.fill(c,len);
+ int l = len==-1 ? (int)m_rep.size() : len;
+ m_rep = std::string(l,c);
return TRUE;
}
/** Returns a deep copy of the string. */
- QCString copy() const
- {
- if (length()==0) return QCString();
- QCString cs(length()+1);
- memcpy(cs.rawData(),data(),length());
- return cs;
- }
+ QCString copy() const { return *this; }
QCString &sprintf( const char *format, ... );
+
int find( char c, int index=0, bool cs=TRUE ) const;
int find( const char *str, int index=0, bool cs=TRUE ) const;
int find( const QCString &str, int index=0, bool cs=TRUE ) const;
int find( const QRegExp &rx, int index=0 ) const;
+
int findRev( char c, int index=-1, bool cs=TRUE) const;
int findRev( const char *str, int index=-1, bool cs=TRUE) const;
int findRev( const QRegExp &rx, int index=-1 ) const;
+
int contains( char c, bool cs=TRUE ) const;
int contains( const char *str, bool cs=TRUE ) const;
int contains( const QRegExp &rx ) const;
- bool stripPrefix(const char *prefix);
- QCString left( uint len ) const;
- QCString right( uint len ) const;
- QCString mid( uint index, uint len=(uint)-1) const;
- QCString lower() const;
- QCString upper() const;
- QCString stripWhiteSpace() const;
+
+ bool stripPrefix(const char *prefix)
+ {
+ if (prefix==0 || m_rep.empty()) return FALSE;
+ if (m_rep.rfind(prefix,0)==0) // string starts with prefix
+ {
+ m_rep.erase(0,qstrlen(prefix));
+ return TRUE;
+ }
+ return FALSE;
+ }
+
+ QCString left( uint len ) const
+ {
+ return m_rep.empty() ? QCString() : QCString(m_rep.substr(0,len));
+ }
+
+ QCString right( uint len ) const
+ {
+ return m_rep.empty() ? QCString() :
+ len<m_rep.size() ? QCString(m_rep.substr(m_rep.size()-len,len)) :
+ *this;
+ }
+
+ QCString mid( uint index, uint len=(uint)-1) const
+ {
+ uint slen = (uint)m_rep.size();
+ if (len==(uint)-1) len = slen-index;
+ return m_rep.empty() || index>slen || len==0 ? QCString() :
+ QCString(m_rep.substr(index,len));
+ }
+
+ QCString lower() const
+ {
+ std::string s = m_rep;
+ std::transform(s.begin(),s.end(),s.begin(),
+ [](unsigned char c){ return (unsigned char)std::tolower(c); });
+ return s;
+ }
+
+ QCString upper() const
+ {
+ std::string s = m_rep;
+ std::transform(s.begin(),s.end(),s.begin(),
+ [](unsigned char c){ return (unsigned char)std::toupper(c); });
+ return s;
+ }
+
+ QCString stripWhiteSpace() const
+ {
+ int sl = (uint)m_rep.size();
+ if (sl==0 || (!std::isspace(m_rep[0]) && !std::isspace(m_rep[sl-1]))) return *this;
+ int start=0,end=sl-1;
+ while (start<sl && std::isspace(m_rep[start])) start++;
+ if (start==sl) return QCString(); // only whitespace
+ while (end>start && std::isspace(m_rep[end])) end--;
+ return QCString(m_rep.substr(start,1+end-start));
+ }
+
QCString simplifyWhiteSpace() const;
- QCString &assign( const char *str );
- QCString &insert( uint index, const char *s );
- QCString &insert( uint index, char c);
- QCString &append( const char *s );
- QCString &prepend( const char *s );
- QCString &remove( uint index, uint len );
+
+ QCString &insert( uint index, const char *s )
+ {
+ uint len = s ? qstrlen(s) : 0;
+ if (len>0)
+ {
+ uint ol = (uint)m_rep.size();
+ if (index>ol) // insert beyond end of string and fill gap with spaces
+ {
+ m_rep.resize(index+len);
+ std::memset(&m_rep[ol],' ',index-ol);
+ std::memcpy(&m_rep[index],s,len+1);
+ }
+ else // insert inside the string
+ {
+ m_rep.insert(index,s);
+ }
+ }
+ return *this;
+ }
+
+ QCString &insert( uint index, char c)
+ {
+ char s[2] = { c, '\0' };
+ return insert(index,s);
+ }
+
+ QCString &append( const char *s )
+ {
+ return operator+=(s);
+ }
+
+ QCString &prepend( const char *s )
+ {
+ return insert(0,s);
+ }
+
+ QCString &remove( uint index, uint len )
+ {
+ uint ol = (uint)m_rep.size();
+ if (index<ol && len>0) m_rep.erase(index,index+len>=ol ? std::string::npos : len);
+ return *this;
+ }
+
QCString &replace( uint index, uint len, const char *s);
QCString &replace( const QRegExp &rx, const char *str );
- short toShort( bool *ok=0, int base=10 ) const;
+
+ short toShort( bool *ok=0, int base=10 ) const;
ushort toUShort( bool *ok=0, int base=10 ) const;
- int toInt( bool *ok=0, int base=10 ) const;
- uint toUInt( bool *ok=0, int base=10 ) const;
- long toLong( bool *ok=0, int base=10 ) const;
- ulong toULong( bool *ok=0, int base=10 ) const;
+ int toInt( bool *ok=0, int base=10 ) const;
+ uint toUInt( bool *ok=0, int base=10 ) const;
+ long toLong( bool *ok=0, int base=10 ) const;
+ ulong toULong( bool *ok=0, int base=10 ) const;
uint64 toUInt64( bool *ok=0, int base=10 ) const;
- QCString &setNum(short n);
- QCString &setNum(ushort n);
- QCString &setNum(int n);
- QCString &setNum(uint n);
- QCString &setNum(long n);
- QCString &setNum(ulong n);
- bool startsWith( const char *s ) const;
- /** Converts the string to a plain C string */
- operator const char *() const
+ QCString &setNum(short n)
{
- return (const char *)data();
+ m_rep = std::to_string(n);
+ return *this;
}
- /** Appends string \a str to this string and returns a reference to the result. */
- QCString &operator+=( const char *str )
+ QCString &setNum(ushort n)
{
- if (!str) return *this;
- uint len1 = length();
- uint len2 = (uint)strlen(str);
- resize(len1+len2+1);
- memcpy(rawData()+len1,str,len2);
+ m_rep = std::to_string(n);
return *this;
}
- /** Appends character \a c to this string and returns a reference to the result. */
- QCString &operator+=( char c )
+ QCString &setNum(int n)
{
- uint len = length();
- resize(len+2);
- rawData()[len]=c;
+ m_rep = std::to_string(n);
return *this;
}
- /** Returns a reference to the character at index \a i. */
- char &at( uint i) const
+ QCString &setNum(uint n)
{
- return m_rep.at(i);
+ m_rep = std::to_string(n);
+ return *this;
}
- /** Indexing operator. Equivalent to at(). */
- char &operator[]( int i ) const
+ QCString &setNum(long n)
{
- return m_rep.at((uint)i);
+ m_rep = std::to_string(n);
+ return *this;
}
- private:
-
- struct LSData;
-
- // long string representation
- struct LongStringRep
+ QCString &setNum(ulong n)
{
- uchar isShort; // : 1; // should be shared with ShortStringRep
- //uchar : 7;
- LSData *d;
- };
+ m_rep = std::to_string(n);
+ return *this;
+ }
-#define SHORT_STR_CAPACITY ((int)sizeof(LongStringRep)-2)
-#define SHORT_STR_MAX_LEN (SHORT_STR_CAPACITY-1)
+ bool startsWith( const char *s ) const
+ {
+ if (m_rep.empty() || s==0) return s==0;
+ return m_rep.rfind(s,0)==0; // looking "backward" starting and ending at index 0
+ }
- // short string representation
- struct ShortStringRep
+ /** Converts the string to a plain C string */
+ operator const char *() const
{
- uchar isShort; // : 1; // should be shared with LongStringRep
- uchar len; // : 7;
- char str[SHORT_STR_CAPACITY]; // size including 0-terminator
- };
+ return data();
+ }
- // ref counting string header
- struct LSHeader
+ std::string str() const
{
- uint len; // length of string without 0 terminator
- int refCount; // -1=leaked, 0=one ref & non-cost, n>0, n+1 refs, const
- };
- // ref counting string data and methods
- struct LSData : public LSHeader
+ return m_rep;
+ }
+
+ /** Appends string \a str to this string and returns a reference to the result. */
+ QCString &operator+=( const char *str )
{
- char *toStr()
- {
- return (char*)(this+1); // string data starts after the header
- }
+ if (str) m_rep+=str;
+ return *this;
+ }
- // creates a LSData item with room for size bytes (which includes the 0 terminator!)
- // if size is zero, an empty string will be created.
- static LSData *create(uint size)
- {
- LSData *data;
- data = (LSData*)malloc(sizeof(LSHeader)+size);
- data->len = size-1;
- data->refCount = 0;
- data->toStr()[size-1] = 0;
- return data;
- }
- // remove out reference to the data. Frees memory if no more users
- void dispose()
- {
- if (--refCount<0) free(this);
- }
+ /** Appends character \a c to this string and returns a reference to the result. */
+ QCString &operator+=( char c )
+ {
+ m_rep+=c;
+ return *this;
+ }
- // resizes LSData so it can hold size bytes (which includes the 0 terminator!)
- // Since this is for long strings only, size should be > SHORT_STR_CAPACITY
- static LSData *resize(LSData *d,uint size)
- {
- if (d->len>0 && d->refCount==0) // non-const, non-empty
- {
- d = (LSData*)realloc(d,sizeof(LSHeader)+size);
- d->len = size-1;
- d->toStr()[size-1] = 0;
- return d;
- }
- else // need to make a copy
- {
- LSData *newData = LSData::create(size);
- uint len = d->len;
- if (len>=size) len=size-1;
- memcpy(newData->toStr(),d->toStr(),len);
- newData->toStr()[len]=0;
- d->dispose();
- return newData;
- }
- }
- };
+ /** Returns a reference to the character at index \a i. */
+ char &at( uint i) const
+ {
+ return const_cast<char&>(m_rep[i]);
+ }
- class StringRep
+ /** Indexing operator. Equivalent to at(). */
+ char &operator[]( int i ) const
{
- public:
- StringRep()
- {
- initEmpty();
- }
- void initEmpty()
- {
- u.s.isShort=TRUE;
- u.s.len=0;
- //memset(u.s.str,0,SHORT_STR_CAPACITY);
- }
- ~StringRep()
- {
- if (!u.s.isShort)
- {
- u.l.d->dispose();
- }
- }
- StringRep(const StringRep &s)
- {
- if (&s!=this)
- {
- u.s.isShort = s.u.s.isShort;
- if (s.u.s.isShort)
- {
- u.s.len = s.u.s.len;
- memcpy(u.s.str,s.u.s.str,s.u.s.len+1);
- }
- else
- {
- u.l.d = s.u.l.d;
- u.l.d->refCount++;
- }
- }
- else // self-assignment
- {
- u = s.u; // avoid uninitialized warning from gcc
- }
- }
- StringRep(uint size)
- {
- u.s.isShort = size<=SHORT_STR_CAPACITY;
- if (size<=SHORT_STR_CAPACITY) // init short string
- {
- if (size>0)
- {
- u.s.len = (uchar)(size-1);
- u.s.str[size-1]='\0';
- }
- else
- {
- u.s.len = 0;
- }
- }
- else // int long string
- {
- u.l.d = LSData::create(size);
- }
- }
- StringRep(const char *str)
- {
- if (str)
- {
- uint len = (uint)strlen(str);
- u.s.isShort = len<SHORT_STR_CAPACITY;
- if (len<SHORT_STR_CAPACITY)
- {
- u.s.len = (uchar)len;
- qstrncpy(u.s.str,str,SHORT_STR_CAPACITY);
- }
- else
- {
- u.l.d = LSData::create(len+1);
- memcpy(u.l.d->toStr(),str,u.l.d->len);
- }
- }
- else // create empty string
- {
- initEmpty();
- }
- }
- StringRep( const char *str, uint maxlen )
- {
- if (str && maxlen>0)
- {
- uint len=(uint)strlen(str);
- if (len>maxlen) len=maxlen;
- u.s.isShort = len<=SHORT_STR_MAX_LEN;
- if (u.s.isShort)
- {
- u.s.len = (uchar)len;
- memcpy(u.s.str,str,len);
- u.s.str[len]='\0';
- }
- else
- {
- u.l.d = LSData::create(len+1);
- memcpy(u.l.d->toStr(),str,len);
- }
- }
- else // create empty string
- {
- initEmpty();
- }
- }
- StringRep &operator=(const StringRep &s)
- {
- if (&s!=this)
- {
- if (!u.s.isShort)
- {
- u.l.d->dispose();
- }
- u.s.isShort = s.u.s.isShort;
- if (u.s.isShort) // copy by value
- {
- u.s.len = s.u.s.len;
- memcpy(u.s.str,s.u.s.str,s.u.s.len+1);
- }
- else // copy by reference
- {
- u.l.d = s.u.l.d;
- u.l.d->refCount++;
- }
- }
- else // self-assignment
- {
- u = s.u; // avoid uninitialized warning from gcc
- }
- return *this;
- }
- StringRep &operator=(const char *str)
- {
- if (!u.s.isShort)
- {
- u.l.d->dispose();
- }
- if (str)
- {
- uint len = (uint)strlen(str);
- u.s.isShort = len<SHORT_STR_CAPACITY;
- if (len<SHORT_STR_CAPACITY)
- {
- u.s.len = (uchar)len;
- qstrncpy(u.s.str,str,SHORT_STR_CAPACITY);
- }
- else
- {
- u.l.d = LSData::create(len+1);
- memcpy(u.l.d->toStr(),str,len);
- }
- }
- else
- {
- initEmpty();
- }
- return *this;
- }
- bool isEmpty() const
- {
- return u.s.isShort && u.s.len==0;
- }
- uint length() const
- {
- uint l = u.s.isShort ? u.s.len : u.l.d->len;
- return l;
- }
- const char *data() const
- {
- if (u.s.isShort)
- {
- return u.s.len==0 ? 0 : u.s.str;
- }
- else
- {
- return u.l.d->len==0 ? 0 : u.l.d->toStr();
- }
- }
- char *rawData() const
- {
- if (u.s.isShort)
- {
- return u.s.len==0 ? 0 : (char*)u.s.str;
- }
- else
- {
- //assert(u.l.d->refCount==0); // string may not be shared when accessed raw
- return u.l.d->len==0 ? 0 : u.l.d->toStr();
- }
- }
- char &at(uint i) const
- {
- if (u.s.isShort)
- {
- return (char&)u.s.str[i];
- }
- else
- {
- return u.l.d->toStr()[i];
- }
- }
- bool resize( uint newlen )
- {
- if (u.s.isShort && newlen<=SHORT_STR_CAPACITY) // resize short string
- {
- if (newlen>0)
- {
- u.s.len = (uchar)(newlen-1);
- u.s.str[newlen-1]='\0';
- }
- else // string becomes empty
- {
- initEmpty();
- }
- }
- else if (u.s.isShort) // turn short string into long string
- {
- StringRep tmp = *this;
- u.s.isShort=FALSE;
- u.l.d = LSData::create(newlen);
- if (tmp.u.s.len>0)
- {
- memcpy(u.l.d->toStr(),tmp.u.s.str,tmp.u.s.len+1);
- }
- else
- {
- u.l.d->toStr()[0]='\0';
- }
- }
- else if (!u.s.isShort && newlen<=SHORT_STR_CAPACITY) // turn long string into short string
- {
- if (newlen>0)
- {
- StringRep tmp(newlen); // copy short part into tmp buffer
- memcpy(tmp.u.s.str,u.l.d->toStr(),newlen-1);
- tmp.u.s.str[newlen-1]='\0';
- u.l.d->dispose();
- u.s = tmp.u.s;
- }
- else
- {
- u.l.d->dispose();
- initEmpty();
- }
- }
- else // resize long string
- {
- u.l.d = u.l.d->resize(u.l.d,newlen);
- }
- return TRUE;
- }
- bool fill( char c, int len )
- {
- uint ulen = len<0 ? length() : (uint)len;
- if (!u.s.isShort) // detach from shared string
- {
- resize(ulen+1);
- }
- else if (ulen!=length())
- {
- if (ulen>0)
- {
- resize(ulen+1);
- }
- }
- if (ulen>0)
- {
- memset(rawData(),c,ulen);
- }
- return TRUE;
- }
- private:
- union ShortOrLongStringSelector
- {
- ShortStringRep s;
- LongStringRep l;
- } u;
- };
- StringRep m_rep;
+ return const_cast<char&>(m_rep[i]);
+ }
+ private:
+ std::string m_rep;
};
/*****************************************************************************
QCString stream functions
*****************************************************************************/
#ifndef QT_NO_DATASTREAM
-Q_EXPORT QDataStream &operator<<( QDataStream &, const QCString & );
-Q_EXPORT QDataStream &operator>>( QDataStream &, QCString & );
+QDataStream &operator<<( QDataStream &, const QCString & );
+QDataStream &operator>>( QDataStream &, QCString & );
#endif
/*****************************************************************************
QCString non-member operators
*****************************************************************************/
-Q_EXPORT inline bool operator==( const QCString &s1, const QCString &s2 )
+inline bool operator==( const QCString &s1, const QCString &s2 )
{ return qstrcmp(s1.data(),s2.data()) == 0; }
-Q_EXPORT inline bool operator==( const QCString &s1, const char *s2 )
+inline bool operator==( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) == 0; }
-Q_EXPORT inline bool operator==( const char *s1, const QCString &s2 )
+inline bool operator==( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) == 0; }
-Q_EXPORT inline bool operator!=( const QCString &s1, const QCString &s2 )
+inline bool operator!=( const QCString &s1, const QCString &s2 )
{ return qstrcmp(s1.data(),s2.data()) != 0; }
-Q_EXPORT inline bool operator!=( const QCString &s1, const char *s2 )
+inline bool operator!=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) != 0; }
-Q_EXPORT inline bool operator!=( const char *s1, const QCString &s2 )
+inline bool operator!=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) != 0; }
-Q_EXPORT inline bool operator<( const QCString &s1, const QCString& s2 )
+inline bool operator<( const QCString &s1, const QCString& s2 )
{ return qstrcmp(s1.data(),s2.data()) < 0; }
-Q_EXPORT inline bool operator<( const QCString &s1, const char *s2 )
+inline bool operator<( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) < 0; }
-Q_EXPORT inline bool operator<( const char *s1, const QCString &s2 )
+inline bool operator<( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) < 0; }
-Q_EXPORT inline bool operator<=( const QCString &s1, const char *s2 )
+inline bool operator<=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) <= 0; }
-Q_EXPORT inline bool operator<=( const char *s1, const QCString &s2 )
+inline bool operator<=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) <= 0; }
-Q_EXPORT inline bool operator>( const QCString &s1, const char *s2 )
+inline bool operator>( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) > 0; }
-Q_EXPORT inline bool operator>( const char *s1, const QCString &s2 )
+inline bool operator>( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) > 0; }
-Q_EXPORT inline bool operator>=( const QCString &s1, const char *s2 )
+inline bool operator>=( const QCString &s1, const char *s2 )
{ return qstrcmp(s1.data(),s2) >= 0; }
-Q_EXPORT inline bool operator>=( const char *s1, const QCString &s2 )
+inline bool operator>=( const char *s1, const QCString &s2 )
{ return qstrcmp(s1,s2.data()) >= 0; }
-Q_EXPORT inline QCString operator+( const QCString &s1, const QCString &s2 )
+inline QCString operator+( const QCString &s1, const QCString &s2 )
{
- QCString tmp(s1);
- tmp += s2;
- return tmp;
+ return QCString(s1.str()+s2.str());
}
@@ -768,28 +455,28 @@ inline QCString operator+( const QCString &s1, const QGString &s2 );
inline QCString operator+( const QGString &s1, const QCString &s2 );
-Q_EXPORT inline QCString operator+( const QCString &s1, const char *s2 )
+inline QCString operator+( const QCString &s1, const char *s2 )
{
QCString tmp(s1);
tmp += s2;
return tmp;
}
-Q_EXPORT inline QCString operator+( const char *s1, const QCString &s2 )
+inline QCString operator+( const char *s1, const QCString &s2 )
{
QCString tmp(s1);
tmp += s2;
return tmp;
}
-Q_EXPORT inline QCString operator+( const QCString &s1, char c2 )
+inline QCString operator+( const QCString &s1, char c2 )
{
QCString tmp( s1.data() );
tmp += c2;
return tmp;
}
-Q_EXPORT inline QCString operator+( char c1, const QCString &s2 )
+inline QCString operator+( char c1, const QCString &s2 )
{
QCString tmp;
tmp += c1;
@@ -807,14 +494,25 @@ inline const char *qPrint(const QCString &s)
if (!s.isEmpty()) return s.data(); else return "";
}
+inline const char *qPrint(const std::string &s)
+{
+ return s.c_str();
+}
+
inline std::string toStdString(const QCString &s)
{
- if (!s.isEmpty()) return std::string(s.data()); else return std::string();
+ return s.str();
}
// helper functions
-QCString substitute(const QCString &s,const QCString &src,const QCString &dst);
+QCString substitute(const QCString &str,const QCString &find,const QCString &replace);
QCString substitute(const QCString &s,const QCString &src,const QCString &dst,int skip_seq);
-QCString substitute(const QCString &s,char srcChar,char dstChar);
+
+inline QCString substitute(const QCString &s,char srcChar,char dstChar)
+{
+ std::string ss = s.str();
+ std::replace(ss.begin(),ss.end(),srcChar,dstChar);
+ return ss;
+}
#endif // QCSTRING_H