void CString::ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData)
{
// -- the main routine for += operators
// concatenating an empty string is a no-op!
if (nSrcLen == 0)
return;
// if the buffer is too small, or we have a width mis-match, just
// allocate a new buffer (slow but sure)
if (GetData()->nRefs > 1 || GetData()->nDataLength + nSrcLen > GetData()->nAllocLength)
{
// we have to grow the buffer, use the ConcatCopy routine
CStringData* pOldData = GetData();
ConcatCopy(GetData()->nDataLength, m_pchData, nSrcLen, lpszSrcData);
ASSERT(pOldData != NULL);
CString::Release(pOldData);
}
else
{
// fast concatenation when buffer big enough
memcpy(m_pchData+GetData()->nDataLength, lpszSrcData, nSrcLen*sizeof(TCHAR));
GetData()->nDataLength += nSrcLen;
ASSERT(GetData()->nDataLength <= GetData()->nAllocLength);
m_pchData[GetData()->nDataLength] = '\0';
}
}
/*
* @implemented
*/
void CHString::ConcatInPlace(int nSrcLen, LPCWSTR lpszSrcData)
{
// With null length, there's not that much to concat...
if (nSrcLen == 0)
{
return;
}
// Still no negative length
if (nSrcLen < 0)
{
RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
}
// Ensure we wouldn't overflow with the concat
if (GetData()->nDataLength + nSrcLen > INT_MAX)
{
RaiseException(STATUS_INTEGER_OVERFLOW, EXCEPTION_NONCONTINUABLE, 0, 0);
}
// In case we have to modify a shared string OR if it can't fit into current buffer...
if (GetData()->nRefs > 1 || GetData()->nDataLength + nSrcLen > GetData()->nAllocLength)
{
// Allocate a new buffer! (without forgetting to release old one)
CHStringData* OldData = GetData();
// You remember about "InPlace" in the function's name?
// The cake is a lie
ConcatCopy(GetData()->nDataLength, m_pchData, nSrcLen, lpszSrcData);
Release(OldData);
}
else
{
// Ensure we don't overflow
if (nSrcLen > INT_MAX)
{
RaiseException(STATUS_INTEGER_OVERFLOW, EXCEPTION_NONCONTINUABLE, 0, 0);
}
// Then, just copy and null terminate
wcsncpy(m_pchData + GetData()->nDataLength, lpszSrcData, nSrcLen);
GetData()->nDataLength += nSrcLen;
m_pchData[GetData()->nDataLength] = 0;
}
}
void CFX_WideString::ConcatInPlace(FX_STRSIZE nSrcLen, const FX_WCHAR* lpszSrcData)
{
if (nSrcLen == 0 || lpszSrcData == NULL) {
return;
}
if (m_pData == NULL) {
m_pData = StringData::Create(nSrcLen);
if (m_pData) {
FXSYS_memcpy(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
}
return;
}
if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
} else {
FXSYS_memcpy(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
m_pData->m_nDataLength += nSrcLen;
m_pData->m_String[m_pData->m_nDataLength] = 0;
}
}
void CStrClass::ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData)
{
// -- the main routine for += operators
// if the buffer is too small, or we have a width mis-match, just
// allocate a new buffer (slow but sure)
if (m_nDataLength + nSrcLen > m_nAllocLength)
{
// we have to grow the buffer, use the Concat in place routine
LPTSTR lpszOldData = m_pchData;
ConcatCopy(m_nDataLength, lpszOldData, nSrcLen, lpszSrcData);
SafeDelete(lpszOldData);
}
else
{
// fast concatenation when buffer big enough
memcpy(&m_pchData[m_nDataLength], lpszSrcData, nSrcLen*sizeof(TCHAR));
m_nDataLength += nSrcLen;
}
m_pchData[m_nDataLength] = '\0';
}
void CFX_WideString::ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData)
{
if (nSrcLen == 0 || lpszSrcData == NULL) {
return;
}
if (m_pData == NULL) {
m_pData = FX_AllocStringW(nSrcLen);
if (m_pData) {
FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
}
return;
}
if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
CFX_StringDataW* pOldData = m_pData;
ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
FX_ReleaseStringW(pOldData);
} else {
FXSYS_memcpy32(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
m_pData->m_nDataLength += nSrcLen;
m_pData->m_String[m_pData->m_nDataLength] = 0;
}
}
const CCOMStringW& CCOMStringW::operator+=(WCHAR ch)
{
USES_CONVERSION;
ConcatCopy(ch);
return *this;
}
const CCOMStringW& CCOMStringW::operator+=(const WCHAR* lpsz)
{
ConcatCopy(lpsz);
return *this;
}
const CCOMStringW& CCOMStringW::operator+=(CCOMStringW& strSrc)
{
ConcatCopy((const WCHAR* ) strSrc);
return *this;
}
const CCOMString& CCOMString::operator+=(BSTR bstrStr)
{
USES_CONVERSION;
ConcatCopy(OLE2T(bstrStr));
return *this;
}
const CCOMString& CCOMString::operator+=(LPCTSTR lpsz)
{
ConcatCopy(lpsz);
return *this;
}
const CCOMString& CCOMString::operator+=(CCOMString& strSrc)
{
ConcatCopy((LPCTSTR) strSrc);
return *this;
}
