//
// ATTN: you can _not_ use both of these in the same program!
+#include <iostream>
+
wxSTD istream& operator>>(wxSTD istream& is, wxString& WXUNUSED(str))
{
#if 0
if ( pData == NULL ) {
// allocation failures are handled by the caller
- return FALSE;
+ return false;
}
pData->nRefs = 1;
pData->nAllocLength = nLen + EXTRA_ALLOC;
m_pchData = pData->data(); // data starts after wxStringData
m_pchData[nLen] = wxT('\0');
- return TRUE;
+ return true;
}
// must be called before changing this string
size_t nLen = pData->nDataLength;
if ( !AllocBuffer(nLen) ) {
// allocation failures are handled by the caller
- return FALSE;
+ return false;
}
memcpy(m_pchData, pData->data(), nLen*sizeof(wxChar));
}
wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
- return TRUE;
+ return true;
}
// must be called before replacing contents of this string
pData->Unlock();
if ( !AllocBuffer(nLen) ) {
// allocation failures are handled by the caller
- return FALSE;
+ return false;
}
}
else {
if ( pData == NULL ) {
// allocation failures are handled by the caller
// keep previous data since reallocation failed
- return FALSE;
+ return false;
}
pData->nAllocLength = nLen;
wxASSERT( !GetStringData()->IsShared() ); // we must be the only owner
- return TRUE;
+ return true;
}
wxStringBase& wxStringBase::append(size_t n, wxChar ch)
if ( pData == NULL ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
pData->nRefs = 1;
size_t nOldLen = pData->nDataLength;
if ( !AllocBuffer(nLen) ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
memcpy(m_pchData, pData->data(), nOldLen*sizeof(wxChar));
}
if ( pData == NULL ) {
// allocation failure handled by caller
// keep previous data since reallocation failed
- return FALSE;
+ return false;
}
// it's not important if the pointer changed or not (the check for this
}
}
//else: we've already got enough
- return TRUE;
+ return true;
+}
+
+wxStringBase::iterator wxStringBase::begin()
+{
+ if (length() > 0)
+ CopyBeforeWrite();
+ return m_pchData;
+}
+
+wxStringBase::iterator wxStringBase::end()
+{
+ if (length() > 0)
+ CopyBeforeWrite();
+ return m_pchData + length();
}
wxStringBase::iterator wxStringBase::erase(iterator it)
}
} while ( cursor-- > c_str() );
}
-
+
return npos;
}
else {
if ( !AllocBeforeWrite(nSrcLen) ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
memcpy(m_pchData, pszSrcData, nSrcLen*sizeof(wxChar));
GetStringData()->nDataLength = nSrcLen;
m_pchData[nSrcLen] = wxT('\0');
}
- return TRUE;
+ return true;
}
// ---------------------------------------------------------------------------
wxStringData* pOldData = GetStringData();
if ( !AllocBuffer(nNewLen) ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
memcpy(m_pchData, pOldData->data(), nLen*sizeof(wxChar));
pOldData->Unlock();
// we have to grow the buffer
if ( capacity() < nNewLen ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
}
else {
GetStringData()->nDataLength = nNewLen; // and fix the length
}
//else: the string to append was empty
- return TRUE;
+ return true;
}
// ---------------------------------------------------------------------------
else {
if ( !dest.AllocBuffer(nCopyLen) ) {
// allocation failure handled by caller
- return FALSE;
+ return false;
}
memcpy(dest.m_pchData, m_pchData + nCopyIndex, nCopyLen*sizeof(wxChar));
}
- return TRUE;
+ return true;
}
#endif // !wxUSE_STL
// from multibyte string
wxString::wxString(const char *psz, wxMBConv& conv, size_t nLength)
{
+ // if nLength != npos, then we have to make a NULL-terminated copy
+ // of first nLength bytes of psz first because the input buffer to MB2WC
+ // must always be NULL-terminated:
+ wxCharBuffer inBuf((const char *)NULL);
+ if (nLength != npos)
+ {
+ wxASSERT( psz != NULL );
+ wxCharBuffer tmp(nLength);
+ memcpy(tmp.data(), psz, nLength);
+ tmp.data()[nLength] = '\0';
+ inBuf = tmp;
+ psz = inBuf.data();
+ }
+
// first get the size of the buffer we need
size_t nLen;
if ( psz )
{
// calculate the needed size ourselves or use the provided one
- nLen = nLength == npos ? conv.MB2WC(NULL, psz, 0) : nLength;
+ nLen = conv.MB2WC(NULL, psz, 0);
}
else
{
}
else
{
- wxWCharBuffer buf(nLen + 1);
+ wxWCharBuffer buf(nLen);
// MB2WC wants the buffer size, not the string length hence +1
nLen = conv.MB2WC(buf.data(), psz, nLen + 1);
// from wide string
wxString::wxString(const wchar_t *pwz, wxMBConv& conv, size_t nLength)
{
+ // if nLength != npos, then we have to make a NULL-terminated copy
+ // of first nLength chars of psz first because the input buffer to WC2MB
+ // must always be NULL-terminated:
+ wxWCharBuffer inBuf((const wchar_t *)NULL);
+ if (nLength != npos)
+ {
+ wxASSERT( pwz != NULL );
+ wxWCharBuffer tmp(nLength);
+ memcpy(tmp.data(), pwz, nLength * sizeof(wchar_t));
+ tmp.data()[nLength] = '\0';
+ inBuf = tmp;
+ pwz = inBuf.data();
+ }
+
// first get the size of the buffer we need
size_t nLen;
if ( pwz )
{
// calculate the needed size ourselves or use the provided one
- nLen = nLength == npos ? conv.WC2MB(NULL, pwz, 0) : nLength;
+ nLen = conv.WC2MB(NULL, pwz, 0);
}
else
{
}
wxASSERT( GetStringData()->nRefs == 1 );
- GetStringData()->Validate(FALSE);
+ GetStringData()->Validate(false);
return m_pchData;
}
void wxString::UngetWriteBuf()
{
GetStringData()->nDataLength = wxStrlen(m_pchData);
- GetStringData()->Validate(TRUE);
+ GetStringData()->Validate(true);
}
void wxString::UngetWriteBuf(size_t nLen)
{
GetStringData()->nDataLength = nLen;
- GetStringData()->Validate(TRUE);
+ GetStringData()->Validate(true);
}
#endif
}
// check that the string starts with prefix and return the rest of the string
-// in the provided pointer if it is not NULL, otherwise return FALSE
+// in the provided pointer if it is not NULL, otherwise return false
bool wxString::StartsWith(const wxChar *prefix, wxString *rest) const
{
wxASSERT_MSG( prefix, _T("invalid parameter in wxString::StartsWith") );
if ( *prefix++ != *p++ )
{
// no match
- return FALSE;
+ return false;
}
}
*rest = p;
}
- return TRUE;
+ return true;
}
// extract nCount last (rightmost) characters
wxString wxString::AfterLast(wxChar ch) const
{
wxString str;
- int iPos = Find(ch, TRUE);
+ int iPos = Find(ch, true);
if ( iPos == wxNOT_FOUND )
str = *this;
else
wxString wxString::BeforeLast(wxChar ch) const
{
wxString str;
- int iPos = Find(ch, TRUE);
+ int iPos = Find(ch, true);
if ( iPos != wxNOT_FOUND && iPos != 0 )
str = wxString(c_str(), iPos);
{
const wxChar *s = (const wxChar*) *this;
while(*s){
- if(!isascii(*s)) return(FALSE);
+ if(!isascii(*s)) return(false);
s++;
}
- return(TRUE);
+ return(true);
}
bool wxString::IsWord() const
{
const wxChar *s = (const wxChar*) *this;
while(*s){
- if(!wxIsalpha(*s)) return(FALSE);
+ if(!wxIsalpha(*s)) return(false);
s++;
}
- return(TRUE);
+ return(true);
}
bool wxString::IsNumber() const
if (wxStrlen(s))
if ((s[0] == '-') || (s[0] == '+')) s++;
while(*s){
- if(!wxIsdigit(*s)) return(FALSE);
+ if(!wxIsdigit(*s)) return(false);
s++;
}
- return(TRUE);
+ return(true);
}
wxString wxString::Strip(stripType w) const
{
wxString s = *this;
- if ( w & leading ) s.Trim(FALSE);
- if ( w & trailing ) s.Trim(TRUE);
+ if ( w & leading ) s.Trim(false);
+ if ( w & trailing ) s.Trim(true);
return s;
}
// trimming and padding
// ---------------------------------------------------------------------------
-// some compilers (VC++ 6.0 not to name them) return TRUE for a call to
+// some compilers (VC++ 6.0 not to name them) return true for a call to
// isspace('ê') in the C locale which seems to be broken to me, but we have to
// live with this by checking that the character is a 7 bit one - even if this
// may fail to detect some spaces (I don't know if Unicode doesn't have
bool wxString::ToLong(long *val, int base) const
{
- wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToLong") );
+ wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToLong") );
wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
const wxChar *start = c_str();
wxChar *end;
*val = wxStrtol(start, &end, base);
- // return TRUE only if scan was stopped by the terminating NUL and if the
+ // return true only if scan was stopped by the terminating NUL and if the
// string was not empty to start with
return !*end && (end != start);
}
bool wxString::ToULong(unsigned long *val, int base) const
{
- wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToULong") );
+ wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToULong") );
wxASSERT_MSG( !base || (base > 1 && base <= 36), _T("invalid base") );
const wxChar *start = c_str();
wxChar *end;
*val = wxStrtoul(start, &end, base);
- // return TRUE only if scan was stopped by the terminating NUL and if the
+ // return true only if scan was stopped by the terminating NUL and if the
// string was not empty to start with
return !*end && (end != start);
}
bool wxString::ToDouble(double *val) const
{
- wxCHECK_MSG( val, FALSE, _T("NULL pointer in wxString::ToDouble") );
+ wxCHECK_MSG( val, false, _T("NULL pointer in wxString::ToDouble") );
const wxChar *start = c_str();
wxChar *end;
*val = wxStrtod(start, &end);
- // return TRUE only if scan was stopped by the terminating NUL and if the
+ // return true only if scan was stopped by the terminating NUL and if the
// string was not empty to start with
return !*end && (end != start);
}
// misc other operations
// ----------------------------------------------------------------------------
-// returns TRUE if the string matches the pattern which may contain '*' and
+// returns true if the string matches the pattern which may contain '*' and
// '?' metacharacters (as usual, '?' matches any character and '*' any number
// of them)
bool wxString::Matches(const wxChar *pszMask) const
switch ( *pszMask ) {
case wxT('?'):
if ( *pszTxt == wxT('\0') )
- return FALSE;
+ return false;
// pszTxt and pszMask will be incremented in the loop statement
// if there is nothing more, match
if ( *pszMask == wxT('\0') )
- return TRUE;
+ return true;
// are there any other metacharacters in the mask?
size_t uiLenMask;
wxString strToMatch(pszMask, uiLenMask);
const wxChar* pMatch = wxStrstr(pszTxt, strToMatch);
if ( pMatch == NULL )
- return FALSE;
+ return false;
// -1 to compensate "++" in the loop
pszTxt = pMatch + uiLenMask - 1;
default:
if ( *pszMask != *pszTxt )
- return FALSE;
+ return false;
break;
}
}
// match only if nothing left
if ( *pszTxt == wxT('\0') )
- return TRUE;
+ return true;
// if we failed to match, backtrack if we can
if ( pszLastStarInText ) {
goto match;
}
- return FALSE;
+ return false;
#endif // wxUSE_REGEX/!wxUSE_REGEX
}
m_nCount += nInsert;
}
+// range insert (STL 23.2.4.3)
+void
+wxArrayString::insert(iterator it, const_iterator first, const_iterator last)
+{
+ const int idx = it - begin();
+
+ // grow it once
+ Grow(last - first);
+
+ // reset "it" since it can change inside Grow()
+ it = begin() + idx;
+
+ while ( first != last )
+ {
+ it = insert(it, *first);
+
+ // insert returns an iterator to the last element inserted but we need
+ // insert the next after this one, that is before the next one
+ ++it;
+
+ ++first;
+ }
+}
+
// expand the array
void wxArrayString::SetCount(size_t count)
{
// if we don't use the compare function, this flag tells us if we sort the
// array in ascending or descending order
-static bool gs_sortAscending = TRUE;
+static bool gs_sortAscending = true;
// function which is called by quick sort
extern "C" int wxC_CALLING_CONV // LINKAGEMODE
bool wxArrayString::operator==(const wxArrayString& a) const
{
if ( m_nCount != a.m_nCount )
- return FALSE;
+ return false;
for ( size_t n = 0; n < m_nCount; n++ )
{
if ( Item(n) != a[n] )
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
#endif // !wxUSE_STL
-int wxStringSortAscending(wxString* s1, wxString* s2)
+int wxCMPFUNC_CONV wxStringSortAscending(wxString* s1, wxString* s2)
{
return wxStrcmp(s1->c_str(), s2->c_str());
}
-int wxStringSortDescending(wxString* s1, wxString* s2)
+int wxCMPFUNC_CONV wxStringSortDescending(wxString* s1, wxString* s2)
{
return -wxStrcmp(s1->c_str(), s2->c_str());
}
projects / wxWidgets.git / blobdiff