Re: Split a _bstr_t
"Anwar Khan" <anwaruk@gmail.com> wrote in message
news:%23PFk3nKgGHA.1320@TK2MSFTNGP04.phx.gbl...
Hi All,
I need to do a split on _bstr_t string.
There seems to be no direct API to do this (I think so!).
Looking for something like the way we can play around with the MFC
CString.
Not 'out of the box' but the replacement below does the trick.
Thanks and regards,
Anwar.
#pragma once
#ifndef CComBSTR
#define CComBSTR CComBSTR2
#endif
#define CComVariant CComVariant2
namespace ATL
{
/////////////////////////////////////////////////////////////////////////////
// CComBSTR2
class CComBSTR2
{
public:
BSTR m_str;
CComBSTR2() throw()
{
m_str = NULL;
}
CComBSTR2(int nSize)
{
//if (nSize == 0) //BUG it should be possible to assign a L"" string
m_str = NULL;
HRESULT hr = SetLength(nSize);
if (FAILED(hr))
AtlThrow(hr);
ZeroMemory(m_str, nSize * sizeof(WCHAR));
}
CComBSTR2(int nSize, LPCOLESTR sz)
{
if (nSize == 0)
m_str = NULL;
else
{
m_str = ::SysAllocStringLen(sz, nSize);
if (m_str == NULL)
AtlThrow(E_OUTOFMEMORY);
}
}
CComBSTR2(LPCOLESTR pSrc)
{
if (pSrc == NULL)
m_str = NULL;
else
{
m_str = ::SysAllocString(pSrc);
if (m_str == NULL)
AtlThrow(E_OUTOFMEMORY);
}
}
CComBSTR2(const CComBSTR2& src)
{
m_str = src.Copy();
if (!!src && m_str == NULL)
AtlThrow(E_OUTOFMEMORY);
}
CComBSTR2(REFGUID guid)
{
OLECHAR szGUID[64] = {0};
m_str = ::SysAllocStringLen(szGUID,
::StringFromGUID2(guid, szGUID, 64)
);
if (m_str == NULL)
AtlThrow(E_OUTOFMEMORY);
}
CComBSTR2& operator=(const CComBSTR2& src)
{
if (m_str != src.m_str)
{
if (::SysReAllocStringLen(&m_str, src, src.Length()) == FALSE)
AtlThrow(E_OUTOFMEMORY);
}
return *this;
}
CComBSTR2& operator=(LPCOLESTR pSrc)
{
if (pSrc != m_str)
{
if (pSrc != NULL)
{
if (::SysReAllocString(&m_str, pSrc) == FALSE)
AtlThrow(E_OUTOFMEMORY);
}
else
Empty();
}
return *this;
}
~CComBSTR2() throw()
{
::SysFreeString(m_str);
}
unsigned int __stdcall Length() const throw()
{
return SysStringLen(m_str);
}
unsigned int __stdcall ByteLength() const throw()
{
return SysStringByteLen(m_str);
}
operator BSTR() const throw()
{
return m_str;
}
BSTR* __stdcall operator&() throw()
{
return &m_str;
}
BSTR __stdcall Copy() const throw()
{
return m_str == NULL ? NULL :
::SysAllocStringByteLen((char*)m_str, ByteLength());
}
//modified by E.N. pbstr is now in/out!
// you must care for it that it properly gets initialized
STDMETHODIMP CopyTo(BSTR* pbstr) throw()
{
ATLASSERT(pbstr != NULL);
HRESULT hr;
if (pbstr == NULL)
hr = E_POINTER;
else
hr =::SysReAllocStringLen(pbstr, m_str, Length()) == FALSE ?
E_OUTOFMEMORY : S_OK;
return hr;
}
// *** returns true if length equals zero characters or when
unallocated(null pointer)
bool __stdcall IsEmpty (void) throw()
{
return m_str == NULL || Length() == 0;
}
/* added by may 2005 e.n. needs #include 'wchar.h'*/
HRESULT __stdcall Format(PCWSTR pszFormat, va_list args) throw()
{
size_t len = _vscwprintf( pszFormat, args );
HRESULT hr = SetLength((UINT)len) ;
if(SUCCEEDED(hr))
if (vswprintf( m_str, len + 1, pszFormat, args ) < 0)
hr = E_INVALIDARG;
return hr;
}
/* added by may 2005 e.n. needs #include 'wchar.h'*/
HRESULT __cdecl Format(PCWSTR pszFormat, ...) throw()
{
va_list args;
va_start( args, pszFormat );
HRESULT hr = Format(pszFormat, args);
va_end(args);
return hr;
}
HRESULT __stdcall Insert(unsigned int atPosition, PCWSTR value) throw()
{
return Insert(atPosition, CComBSTR(value));
}
HRESULT __stdcall Insert(unsigned int atPosition, const CComBSTR& value)
throw()
{
unsigned int toInsert = value.Length();
unsigned int curLen = Length();
HRESULT hr = S_OK;
if (atPosition > curLen || value == NULL)
hr = E_INVALIDARG;
else
hr = SetLength(curLen + toInsert);
if (SUCCEEDED(hr) && curLen != 0 && toInsert != 0)
{
MoveMemory(&m_str[atPosition + toInsert], &m_str[atPosition],
(curLen - atPosition) * sizeof(OLECHAR));
CopyMemory(&m_str[atPosition], value, toInsert * sizeof(wchar_t));
}
return hr;
}
HRESULT TrimStart(PCWSTR trimwhat = NULL) throw()
{
PCWSTR trim = trimwhat == NULL? L" ": trimwhat;
if (IsEmpty()) return S_OK;
unsigned int trimLen = (unsigned int)wcslen(trim);
while(StartsWith(trim))
Remove(0, trimLen);
return S_OK;
}
HRESULT TrimEnd(PCWSTR trimwhat = NULL) throw()
{
PCWSTR trim = trimwhat == NULL? L" ": trimwhat;
if (IsEmpty()) return S_OK;
unsigned int trimLen = (unsigned int)wcslen(trim);
while(EndsWith(trim))
SetLength(Length() - trimLen);
return S_OK;
}
//** removes in-place characters from this BSTR
HRESULT __stdcall Remove(
//** zero based starting position where you start to remove characters
//** if this number is outside valid bounds, E_INVALIDARG is returned
unsigned int startIndex,
//** the number of characters, you want to remove
//** if this number is outside valid bounds, it is corrected
unsigned int count) throw()
{
unsigned int maxIdx = Length();
// avoid buffer overflow
if (count + startIndex > maxIdx) count = maxIdx - startIndex;
HRESULT hr = S_OK;
if (startIndex < maxIdx)
{
//copy back, overlapped memory
MoveMemory(&m_str[startIndex], &m_str[startIndex + count] ,
(maxIdx - count) * sizeof(OLECHAR));
// shrink to new length
SetLength(maxIdx - count);
}
else
hr = E_INVALIDARG;
return hr;
}
// original string john smith
// merge with west at position 6
// result john westh
// won't extend string length!
void __stdcall MergeString(unsigned int startIndex, const BSTR value)
throw()
{
unsigned int maxIdx = Length();
if (startIndex > maxIdx || value == NULL) return; // illegal operation
unsigned int mergeLen = SysStringLen(value);
if (mergeLen + startIndex > maxIdx)
mergeLen = maxIdx - startIndex;
MoveMemory(&m_str[startIndex], value, mergeLen * sizeof(wchar_t));
}
BSTR __stdcall Substring(unsigned int startIndex) throw()
{
unsigned int maxIdx = Length();
if (m_str != NULL && startIndex >= 0 && startIndex <= maxIdx)
{
return ::SysAllocStringLen(m_str + startIndex, maxIdx - startIndex);
}
else
return NULL;
}
HRESULT __stdcall SetByteLength(unsigned int length) throw()
{
return _SetByteLength(&m_str, length);
}
// Cuts the length to specified but does not clear contents
HRESULT __stdcall SetLength(unsigned int length) throw()
{
return _SetLength(&m_str, length);
}
private:
static HRESULT __stdcall _SetByteLength(BSTR *str, unsigned int length)
throw()
{
//#ifdef SysReAllocStringByteLen
// return SysReAllocStringByteLen2(str, NULL, length) == FALSE ?
E_OUTOFMEMORY : S_OK;
//#else
BSTR Copy = NULL;
UINT origLen = SysStringByteLen(*str);
if (origLen != 0)
{
Copy = SysAllocStringByteLen((LPCSTR)*str, origLen);
}
SysFreeString(*str);
*str = (BSTR)SysAllocStringByteLen(NULL, length);
if (origLen != NULL && *str != NULL)
{
strncpy_s((PSTR)*str, length + 1, (PCSTR)Copy, origLen > length ? length
: origLen);
SysFreeString(Copy);
}
return *str == NULL ? E_OUTOFMEMORY : S_OK;
//#endif
}
static HRESULT __stdcall _SetLength(BSTR * str, unsigned int length)
throw()
{
return ::SysReAllocStringLen(str, NULL, length) == FALSE ? E_OUTOFMEMORY :
S_OK;
}
public:
/// <summary>
/// Replaces a find token with a specified token
/// By E.N.
/// </summary>
/// <param name="find">token to be replace</param>
/// <param name="replace">token that will replace</param>
/// <param name="caseInsensitive">if true, will do a case insensitive
replacement</param>
/// <example>
/// CComBSTR2 myReplace(L"the dog jumps over the");
/// myReplace(CComBSTR2(L"the"), CComBSTR2(L"big"));
/// </example>
/// <returns>The example would modify the string to "big dog jumps over
big" </returns>
HRESULT __stdcall Replace(BSTR find, BSTR replace, bool caseInsensitive)
throw()
{
HRESULT hr = S_OK;
if (m_str == NULL)
hr = E_POINTER;
else
{
//replacement Could be done in-place using intelligent code using
// backward/forward copying and resizing the m_str but not for now...
SAFEARRAY *psa = Split(find, caseInsensitive);
//could Empty() here to safe resources ASAP but if Join would fail
// we end up an uncommited transaction
BSTR bTemp = Join(psa, replace);
if (psa != NULL)
::SafeArrayDestroy(psa);
if (bTemp != NULL)
{ Empty();
m_str = bTemp;
}
else
hr = E_OUTOFMEMORY;
}
//// nSourceLen is in XCHARs
//int nSourceLen = StringTraits::SafeStringLen( pszOld );
//if( nSourceLen == 0 )
// return( 0 );
//// nReplacementLen is in XCHARs
//int nReplacementLen = StringTraits::SafeStringLen( pszNew );
//// loop once to figure out the size of the result string
//int nCount = 0;
//{
// PCXSTR pszStart = GetString();
// PCXSTR pszEnd = pszStart+GetLength();
// while( pszStart < pszEnd )
// {
// PCXSTR pszTarget;
// while( (pszTarget = StringTraits::StringFindString( pszStart,
pszOld ) ) != NULL)
// {
// nCount++;
// pszStart = pszTarget+nSourceLen;
// }
// pszStart += StringTraits::SafeStringLen( pszStart )+1;
// }
//}
//// if any changes were made, make them
//if( nCount > 0 )
//{
// // if the buffer is too small, just
// // allocate a new buffer (slow but sure)
// int nOldLength = GetLength();
// int nNewLength = nOldLength+(nReplacementLen-nSourceLen)*nCount;
// PXSTR pszBuffer = GetBuffer( max( nNewLength, nOldLength ) );
// PXSTR pszStart = pszBuffer;
// PXSTR pszEnd = pszStart+nOldLength;
// // loop again to actually do the work
// while( pszStart < pszEnd )
// {
// PXSTR pszTarget;
// while( (pszTarget = StringTraits::StringFindString( pszStart,
pszOld ) ) != NULL )
// {
// int nBalance = nOldLength-int(pszTarget-pszBuffer+nSourceLen);
// memmove( pszTarget+nReplacementLen, pszTarget+nSourceLen,
nBalance*sizeof( XCHAR ) );
// memcpy( pszTarget, pszNew, nReplacementLen*sizeof( XCHAR ) );
// pszStart = pszTarget+nReplacementLen;
// pszTarget[nReplacementLen+nBalance] = 0;
// nOldLength += (nReplacementLen-nSourceLen);
// }
// pszStart += StringTraits::SafeStringLen( pszStart )+1;
// }
// ATLASSERT( pszBuffer[nNewLength] == 0 );
// ReleaseBufferSetLength( nNewLength );
//}
return hr;
}
/// <summary>
/// Replaces a find token with a specified token
/// <param name="find">token to be replace</param>
/// <param name="replace">token that will replace</param>
/// </summary>
/// <example>
/// CComBSTR2 myReplace(L"the dog jumps over the");
/// myReplace(CComBSTR2(L"the"), CComBSTR2(L"big"));
/// </example>
/// <returns>The example would modify the string to "big dog jumps over
big" </returns>
HRESULT __stdcall Replace(const BSTR find, const BSTR replace) throw()
{
return Replace(find, replace, false);
}
SAFEARRAY* __stdcall Split(PCWSTR expression, const bool caseInsenstive)
throw()
{
return Split(CComBSTR(expression), caseInsenstive);
}
/// <summary>
/// Split and copies this instance of CComBSTR2 into a SAFEARRAY* of VTYPE
= VT_BSTR
/// </summary>
/// <example>
/// CComSafeArray<BSTR> myArray;
/// CComBSTR2 joined(L"John|Smith");
/// myArray.Attach(joined.Split(CComBSTR2(L"|")))
/// </example>
/// <returns>The example would return a safearray with 2 VT_BSTR elements
containing "John" and "Smith"</returns>
SAFEARRAY* __stdcall Split(const CComBSTR& expression, const bool
caseInsensitive)
{
SAFEARRAY* retval = NULL;
HRESULT hr = S_OK;
if (m_str == NULL)
AtlThrow(E_POINTER);
else
{
unsigned int exprLen = SysStringLen(expression);
unsigned int mLen = Length();
int x = 0;
//contains the number of found expression tokens
unsigned int found = mLen == 0 ? -1 : 0;
//find until no more...
if (expression != NULL && found >= 0)
{
for (;;)
{
x = IndexOf(expression, x, caseInsensitive);
if (x == -1) break;
found++;
x += exprLen;
}
}
SAFEARRAYBOUND rgsa = {found + 1, 0};
retval = ::SafeArrayCreate(VT_BSTR, 1, &rgsa);
//::SafeArrayCreateVector(VT_BSTR, 0, found + 1);
if (retval == NULL)
{
hr = E_OUTOFMEMORY;
AtlTrace(L"SafeArrayCreateVector\r\n");
}
else if (mLen > 0)
{
BSTR* paBSTR ;//(BSTR*)retval->pvData;
hr = SafeArrayAccessData(retval, (void**)&paBSTR);
int prevPos = 0;
x = 0;
for (unsigned int curEl = 0; curEl <= found; curEl++)
{
x = IndexOf(expression, x, caseInsensitive);
paBSTR[curEl] = x < 0 ? Substring(prevPos) : Substring(prevPos, x -
prevPos);
if (paBSTR[curEl] == NULL)
{
hr = E_OUTOFMEMORY;
break;
}
x += exprLen;
prevPos = x;
}
SafeArrayUnaccessData(retval);
}
if (FAILED(hr))
{
AtlTrace(L"general split fail %x", hr);
if (retval != NULL)
::SafeArrayDestroy(retval);
retval = NULL;
AtlThrow(hr);
}
}
return retval;
}
SAFEARRAY* __stdcall Split(PCWSTR expression) throw()
{
return Split(CComBSTR(expression), false);
}
/// <summary>
/// Added by E.N.
/// Joins a SAFEARRAY to a single BSTR
/// </summary>
/// <example>
/// CComSafeArray<BSTR> myArray;
/// myArray.Add(CComBSTR2(L"John"));
/// myArray.Add(CComBSTR2(L"Smith"));
/// CComBSTR2 joined;
/// joined.Attach(CComBSTR2::Join(myArray.m_psa, CComBSTR2(L"|") ) ); ///
/// </example>
/// <returns>The example would return "John|Smith"</returns>
static BSTR __stdcall Join(SAFEARRAY *psa, const BSTR delimiter) //throw()
{
BSTR retval = NULL;
HRESULT hr = S_OK;
if (psa != NULL && psa != NULL)
{
VARTYPE vt = VT_EMPTY;
unsigned int delLen = ::SysStringLen(delimiter);
hr = ::SafeArrayGetVartype(psa, &vt);
if (vt != VT_BSTR || psa->cDims != 1)
AtlThrow(E_INVALIDARG);
SAFEARRAYBOUND *rgsa = psa->rgsabound;
ULONG elements = rgsa->cElements - rgsa->lLbound;
unsigned int totalLen = 0;
BSTR* paBSTR = (BSTR*) psa->pvData;
ULONG els = elements;
while(els != 0)
{
if (paBSTR[--els] != NULL)
totalLen += ::SysStringLen(paBSTR[els]);
if (els != 0)
totalLen += delLen;
}
hr = _SetLength(&retval, totalLen);
if (FAILED(hr))
AtlThrow(hr);
else
{
totalLen = 0;
els = elements;
ULONG curel = 0;
while (els != 0)
{
els--;
if (paBSTR[curel] != NULL)
{
unsigned int curLen = ::SysStringLen(paBSTR[curel]);
CopyMemory(retval + totalLen, paBSTR[curel], curLen *
sizeof(OLECHAR));
totalLen += curLen;
}
curel++;
if (els != 0 && delLen != 0)
{
CopyMemory(retval + totalLen, delimiter, delLen * sizeof(OLECHAR));
totalLen += delLen;
}
}
} //success allocate string
}
return retval;
}
/// <summary>
/// Added by E.N.
/// Returns a new instance of a BSTR which is a Substring starting at the
'startindex' character
/// </summary>
/// <example>
/// CComBSTR2 john(L"John Smith"), subbed;
/// subbed.Attach(john.Substring(5));
/// </example>
/// <returns>The example would return "Smith"</returns>
BSTR __stdcall Substring(const unsigned int startIndex, unsigned int
length) throw()
{
unsigned int maxIdx = Length();
//if (length < 0) length = 0;
if (startIndex + length > maxIdx)
length = maxIdx - startIndex;
if (m_str != NULL && startIndex >= 0 && startIndex <= maxIdx)
{
return ::SysAllocStringLen(m_str + startIndex, length);
}
else
return NULL;
}
private:
bool __stdcall local_Test(PCWSTR src, unsigned int startIndex)
{
bool retval = false;
if (src != NULL)
{
unsigned int compLen = lstrlenW(src);
unsigned int thisLen = Length();
if (compLen <= thisLen)
{
DWORD dwCompFlags = 0;
retval = ::CompareStringW(::GetThreadLocale(), dwCompFlags,
&m_str[thisLen - startIndex], compLen, src, compLen) == CSTR_EQUAL;
}
}
return retval;
}
public:
bool __stdcall EndsWith(PCWSTR src) throw()
{
return local_Test(src, lstrlenW(src));
}
bool __stdcall StartsWith(PCWSTR src) throw()
{
return local_Test(src, Length());
}
int __stdcall LastIndexOf(const wchar_t src, const unsigned int startIndex
= 0, const bool caseInsensitive = false) throw()
{
wchar_t src2[] = {src, NULL}; //create zero terminated PWSTR
return LastIndexOf(src2, startIndex, caseInsensitive);
}
int __stdcall LastIndexOf(const wchar_t *src, const unsigned int startIndex
= 0, const bool caseInsensitive = false, unsigned int count = 0) throw()
{
int result = -1;
if (m_str != NULL && src != NULL)
{
LCID lcid = ::GetThreadLocale();
DWORD dwCmpFlags = caseInsensitive ? NORM_IGNORECASE : 0;
unsigned int compLen = (unsigned int)ocslen(src);
unsigned int maxLen = Length();
unsigned int examinedChars = 0;
if (compLen <= maxLen)
{
for(unsigned int x = maxLen - compLen; x >= startIndex; )
{
bool doCompare = caseInsensitive ? true : m_str[x] == src[0];
if (doCompare)
doCompare= ::CompareStringW(lcid, dwCmpFlags, &m_str[x],
compLen, src, compLen) == CSTR_EQUAL ;
if (doCompare)
{
result = x;
break;
}
if (x-- == 0 || (examinedChars++ == count && count != 0)) break;
}
}
}
return result;
}
int __stdcall IndexOf(const wchar_t src, const unsigned int startIndex = 0,
const bool caseInsensitive = false, unsigned int count = 0) throw()
{
wchar_t src2[] = {src, NULL}; //create zero terminated PWSTR
return IndexOf(src2, startIndex, caseInsensitive, count);
}
//
// Addded by E.N.
//
int __stdcall IndexOf(const PWSTR src, const unsigned int startIndex = 0,
const bool caseInsensitive = false, unsigned int count = 0) throw()
{
int result = -1;
if (m_str != NULL && src != NULL)
{
LCID lcid = ::GetThreadLocale();
DWORD dwCmpFlags = caseInsensitive ? NORM_IGNORECASE : 0;
unsigned int maxLen = Length();
unsigned int compLen = (unsigned int)ocslen(src);
unsigned int examinedChars = 0;
if (compLen <= maxLen && compLen > 0)
{
for(int x = startIndex; (x + compLen <= maxLen) || (examinedChars++ ==
count && count != 0); x++)
{
bool doCompare = caseInsensitive ? true :
m_str[x] == src[0];
if (doCompare)
doCompare= ::CompareStringW(lcid, dwCmpFlags, &m_str[x],
compLen, src, compLen) == CSTR_EQUAL ;
if (doCompare)
{
result = x;
break;
}
}
}
}
return result;
}
// copy BSTR to VARIANT
HRESULT __stdcall CopyTo(VARIANT *pvarDest) throw()
{
ATLASSERT(pvarDest != NULL);
HRESULT hRes = E_POINTER;
if (pvarDest != NULL)
{
pvarDest->vt = VT_BSTR;
pvarDest->bstrVal = Copy();
if (pvarDest->bstrVal == NULL && m_str != NULL)
hRes = E_OUTOFMEMORY;
else
hRes = S_OK;
}
return hRes;
}
void __stdcall Attach(BSTR src) throw()
{
if (m_str != src)
{
SysFreeString(m_str);
m_str = src;
}
}
BSTR __stdcall Detach() throw()
{
BSTR s = m_str;
m_str = NULL;
return s;
}
void __stdcall Empty() throw()
{
::SysFreeString(m_str);
m_str = NULL;
}
bool __stdcall operator!() const throw()
{
return (m_str == NULL);
}
HRESULT __stdcall Append(const CComBSTR2& bstrSrc) throw()
{
return AppendBSTR(bstrSrc.m_str);
}
/*HRESULT Append(const CComVariant2& pVarSrc) throw()
{
return Append(pVarSrc.pvarVal);
}*/
//Added by E.N.
HRESULT __stdcall Append(const VARIANT& pVar) throw()
{
HRESULT hr = S_OK;
if (pVar.vt != VT_BSTR)
{
VARIANT v = {0};
hr = ::VariantChangeTypeEx(&v,(VARIANT*)&pVar,
::GetThreadLocale(), 0, VT_BSTR);
if (hr == S_OK) hr = AppendBSTR(v.bstrVal);
VariantClear(&v);
}
else
hr = AppendBSTR(pVar.bstrVal);
return hr;
}
HRESULT __stdcall Append(LPCOLESTR lpsz) throw()
{
return Append(lpsz, UINT(ocslen(lpsz)));
}
// a BSTR is just a LPCOLESTR so we need a special version to signify
// that we are appending a BSTR
HRESULT __stdcall AppendBSTR(BSTR p) throw()
{
return Append((LPCOLESTR)p, ::SysStringLen(p));
}
HRESULT __stdcall Append(LPCOLESTR lpsz, int nLen) throw()
{
if (lpsz == NULL || (m_str != NULL && nLen == 0))
return S_OK;
int n1 = Length();
HRESULT hr = SetLength(n1 + nLen);
if ( FAILED(hr))
return hr;
CopyMemory(m_str+n1, lpsz, nLen*sizeof(OLECHAR));
return S_OK;
}
HRESULT __stdcall Append(char ch) throw()
{
OLECHAR chO = ch;
return( Append( &chO, 1 ) );
}
HRESULT __stdcall Append(wchar_t ch) throw()
{
return( Append( &ch, 1 ) );
}
HRESULT __stdcall AppendBytes(const char* lpsz, int nLen) throw()
{
if (lpsz == NULL || nLen == 0)
return S_OK;
int n1 = ByteLength();
BSTR b;
b = ::SysAllocStringByteLen(NULL, n1+nLen);
if (b == NULL)
return E_OUTOFMEMORY;
CopyMemory(b, m_str, n1);
CopyMemory(((char*)b)+n1, lpsz, nLen);
*((OLECHAR*)(((char*)b)+n1+nLen)) = NULL;
Empty();
m_str = b;
return S_OK;
}
static int __stdcall CountChar(BSTR a, wchar_t theChar) throw()
{
int retval = 0;
if (a != NULL)
{
unsigned int x = ::SysStringLen(a);
while (x != 0)
if (a[--x] == theChar) retval++;
}
return retval;
}
//returns -1 for lesser (<); 0 for equality and 1 for GT (>)
static int __stdcall Compare(BSTR a, BSTR b, bool ignoreCase, bool
ignoreDiacritics, bool ignoreSymbols) throw()
{
int retval = 0;
DWORD compareFlags = ignoreCase ? NORM_IGNORECASE : 0;
if (ignoreDiacritics) compareFlags |= NORM_IGNORENONSPACE;
if (ignoreSymbols) compareFlags |= NORM_IGNORESYMBOLS;
if (a == NULL && b == NULL)
retval = 0;
else if (a == NULL)
retval = -1;
else if (b == NULL)
retval = 1;
else
{
switch(::VarBstrCmp(a, b, ::GetThreadLocale(), compareFlags))
{
case VARCMP_LT:
retval = -1;
break;
case VARCMP_EQ:
retval = 0;
break;
case VARCMP_GT:
retval = 1;
break;
}
}
return retval;
}
int __stdcall CompareTo(BSTR otherBstr) throw()
{
return Compare(m_str, otherBstr, false, false, false);
}
int __stdcall CompareTo(BSTR otherBstr, bool ignoreCase) throw()
{
return Compare(m_str, otherBstr, ignoreCase, false, false);
}
int __stdcall CompareTo(BSTR otherBstr, bool ignoreCase, bool
ignoreDiacritics) throw()
{
return Compare(m_str, otherBstr, ignoreCase, ignoreDiacritics, false);
}
int __stdcall CompareTo(BSTR otherBstr, bool ignoreCase, bool
ignoreDiacritics, bool ignoreSymbols) throw()
{
return Compare(m_str, otherBstr, ignoreCase, ignoreDiacritics,
ignoreSymbols);
}
// added by e.n.
static void __stdcall StringReverse(/*in*/ BSTR s) throw()
{
//CComBSTR2 temp;
//HRESULT hr = temp.AssignBSTR(s); //create a copy
UINT slen = SysStringLen(s), y = 0;
while(y < slen--)
{
WCHAR swp = s[slen];
s[slen] = s[y];
s[y++] = swp;
}
}
void __stdcall Reverse() throw()
{
StringReverse(m_str);
}
GUID __stdcall ToGuid()
{
GUID retval = GUID_NULL;
HRESULT hr = IIDFromString(m_str, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
DATE __stdcall ToDate()
{
DATE retval = 0;
HRESULT hr = ::VarDateFromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
HRESULT __stdcall AssignDate(const DATE date) throw()
{
Empty();
return ::VarBstrFromDate(date, ::GetThreadLocale(), LOCALE_NOUSEROVERRIDE,
&m_str);
}
HRESULT __stdcall AssignBSTR(const BSTR bstrSrc) throw()
{
HRESULT hr = S_OK;
#ifndef SysReAllocStringByteLen
if (m_str != bstrSrc)
{
Empty();
if (bstrSrc != NULL)
{
m_str = ::SysAllocStringByteLen((PCSTR)bstrSrc,
::SysStringByteLen(bstrSrc)) ;
if (*this == NULL)
hr = E_OUTOFMEMORY;
}
else
Empty();
}
#else
if (m_str != bstrSrc)
{
if (bstrSrc == NULL)
Empty();
else
{
UINT ilen = ::SysStringByteLen(bstrSrc);
if (SysReAllocStringByteLen(&m_str, NULL, ilen) == FALSE)
hr = E_OUTOFMEMORY;
if (ilen > 0) //fix since SysReAllocStringByteLen measures in lstrlenA
memcpy(m_str, bstrSrc, ilen);
}
}
#endif
return hr;
}
//creates a copy to a byteencoded string
// optimal usage, attach to it...
BSTR ToByteString(UINT codePage=CP_UTF8)
{
if (!IsEmpty())
{
UINT len = Length();
UINT neededLen = len * 4;
UINT nRet = 0;
BSTR pszA = SysAllocStringByteLen(NULL, neededLen);
int _convert = WideCharToMultiByte(codePage, 0, m_str, len, (PSTR)pszA,
neededLen, NULL, NULL);
if (_convert == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
_convert = WideCharToMultiByte(codePage, 0, m_str, len, NULL, 0, NULL,
NULL);
_SetByteLength(&pszA, _convert);
_convert = WideCharToMultiByte(codePage, 0, m_str, len, (PSTR)pszA,
_convert, NULL, NULL);
}
if (_convert == 0 && GetLastError() > 0)
AtlThrowLastWin32();
_SetByteLength(&pszA, _convert);
return pszA;
}
else
return NULL;
}
//creates a copy to a wide-string
// optimal usage, attach to it...
BSTR ToWideString(UINT codePage=CP_UTF8) throw()
{
UINT len = ByteLength();
int _convert = MultiByteToWideChar(codePage, 0, (PSTR) m_str, len, NULL,
0);
BSTR pszW = SysAllocStringLen(NULL, _convert);
int nRet = MultiByteToWideChar(codePage, 0, (PSTR)m_str, len, pszW,
_convert);
return pszW;
}
HRESULT ToLower() throw()
{
if (m_str != NULL)
{
#ifdef _UNICODE
// Convert in place
CharLowerBuff(m_str, Length());
#else
// Cannot use conversion macros due to possible embedded NULLs
UINT _acp = _AtlGetConversionACP();
int _convert = WideCharToMultiByte(_acp, 0, m_str, Length(), NULL, 0,
NULL, NULL);
CTempBuffer<char> pszA;
ATLTRY(pszA.Allocate(_convert));
if (pszA == NULL)
return E_OUTOFMEMORY;
int nRet = WideCharToMultiByte(_acp, 0, m_str, Length(), pszA, _convert,
NULL, NULL);
if (nRet == 0)
{
ATLASSERT(0);
return AtlHresultFromLastError();
}
CharLowerBuff(pszA, nRet);
_convert = MultiByteToWideChar(_acp, 0, pszA, nRet, NULL, 0);
CTempBuffer<WCHAR> pszW;
ATLTRY(pszW.Allocate(_convert));
if (pszW == NULL)
return E_OUTOFMEMORY;
nRet = MultiByteToWideChar(_acp, 0, pszA, nRet, pszW, _convert);
if (nRet == 0)
{
ATLASSERT(0);
return AtlHresultFromLastError();
}
BSTR b = ::SysAllocStringByteLen((LPCSTR) (LPWSTR) pszW, nRet *
sizeof(OLECHAR));
if (b == NULL)
return E_OUTOFMEMORY;
SysFreeString(m_str);
m_str = b;
#endif
}
return S_OK;
}
HRESULT __stdcall ToUpper() throw()
{
if (m_str != NULL)
{
#ifdef _UNICODE
// Convert in place
CharUpperBuff(m_str, Length());
#else
// Cannot use conversion macros due to possible embedded NULLs
UINT _acp = _AtlGetConversionACP();
int _convert = WideCharToMultiByte(_acp, 0, m_str, Length(), NULL, 0,
NULL, NULL);
CTempBuffer<char> pszA;
ATLTRY(pszA.Allocate(_convert));
if (pszA == NULL)
return E_OUTOFMEMORY;
int nRet = WideCharToMultiByte(_acp, 0, m_str, Length(), pszA, _convert,
NULL, NULL);
if (nRet == 0)
{
ATLASSERT(0);
return AtlHresultFromLastError();
}
CharUpperBuff(pszA, nRet);
_convert = MultiByteToWideChar(_acp, 0, pszA, nRet, NULL, 0);
CTempBuffer<WCHAR> pszW;
ATLTRY(pszW.Allocate(_convert));
if (pszW == NULL)
return E_OUTOFMEMORY;
nRet = MultiByteToWideChar(_acp, 0, pszA, nRet, pszW, _convert);
if (nRet == 0)
{
ATLASSERT(0);
return AtlHresultFromLastError();
}
BSTR b = ::SysAllocStringByteLen((LPCSTR) (LPWSTR) pszW, nRet *
sizeof(OLECHAR));
if (b == NULL)
return E_OUTOFMEMORY;
SysFreeString(m_str);
m_str = b;
#endif
}
return S_OK;
}
bool __cdecl LoadNString(UINT uID, ...) throw()
{
va_list args;
va_start(args, uID);
bool res = _LoadNString(uID, _AtlBaseModule.GetResourceInstance(), args);
va_end(args);
return res;
}
bool __cdecl LoadNString2(UINT uID, HINSTANCE hInst, ...) throw()
{
va_list args;
va_start(args, hInst);
bool res = _LoadNString(uID, hInst, args);
va_end(args);
return res;
}
private:
bool __cdecl _LoadNString(UINT uID, HINSTANCE hInst, va_list args) throw()
{
bool result = true;
PWSTR myMessage = NULL;
LANGID langid = LANGIDFROMLCID(::GetThreadLocale());
LANGID id= PRIMARYLANGID(langid);
int trycnt = 0;
UINT bufSize =0;
DWORD dwerr;
::SetLastError(ERROR_SUCCESS); //fix
do
{
trycnt++;
bufSize = ::FormatMessageW(FORMAT_MESSAGE_FROM_HMODULE |
FORMAT_MESSAGE_ALLOCATE_BUFFER,
hInst, uID, id, (PWSTR) &myMessage, 0, &args);
id= SUBLANGID(langid);
dwerr = ::GetLastError();
} while (dwerr == ERROR_RESOURCE_LANG_NOT_FOUND && trycnt == 1);
if (dwerr != ERROR_SUCCESS)
{
AtlTrace(L"_LoadNString %d", dwerr);
result = false;
}
else
{
Empty();
if (bufSize > 0) bufSize -= 2;
m_str = ::SysAllocStringLen(myMessage, bufSize);
}
if (myMessage != NULL)
::GlobalFree(myMessage);
return result;
}
public:
bool __stdcall LoadString(HINSTANCE hInst, UINT nID) throw()
{
Empty();
return LoadStringResource(hInst, nID, m_str);
}
bool __stdcall LoadString(UINT nID) throw()
{
Empty();
return LoadStringResource(nID, m_str);
}
CComBSTR2& __stdcall operator+=(const CComBSTR2& bstrSrc)
{
HRESULT hr;
hr = AppendBSTR(bstrSrc.m_str);
if (FAILED(hr))
AtlThrow(hr);
return *this;
}
CComBSTR2& __stdcall operator+=(const VARIANT& pVar)
{
HRESULT hr = Append(pVar);
if (FAILED(hr))
AtlThrow(hr);
return *this;
}
CComBSTR2& __stdcall operator+=(LPCOLESTR pszSrc)
{
HRESULT hr = Append(pszSrc);
if (FAILED(hr))
AtlThrow(hr);
return *this;
}
bool __stdcall operator<(const CComBSTR2& bstrSrc) const throw()
{
return Compare(m_str, bstrSrc.m_str, true, true, true) == -1;
}
bool __stdcall operator<(LPCOLESTR pszSrc) const
{
CComBSTR2 bstr2(pszSrc);
return operator<(bstr2);
}
bool __stdcall operator<(LPOLESTR pszSrc) const throw()
{
return operator<((LPCOLESTR)pszSrc);
}
bool __stdcall operator>(const CComBSTR2& bstrSrc) const throw()
{
return Compare(m_str, bstrSrc.m_str, true, true, true) == -1;
}
bool operator>(LPCOLESTR pszSrc) const
{
CComBSTR2 bstr2(pszSrc);
return operator>(bstr2);
}
bool __stdcall operator>(LPOLESTR pszSrc) const throw()
{
return operator>((LPCOLESTR)pszSrc);
}
bool __stdcall operator!=(const CComBSTR2& bstrSrc) const throw()
{
return !operator==(bstrSrc);
}
bool __stdcall operator!=(LPCOLESTR pszSrc) const throw()
{
return !operator==(pszSrc);
}
bool operator!=(int nNull) const throw()
{
return !operator==(nNull);
}
bool __stdcall operator!=(LPOLESTR pszSrc) const throw()
{
return operator!=((LPCOLESTR)pszSrc);
}
bool __stdcall operator==(const CComBSTR2& bstrSrc) const throw()
{
return (Compare(m_str, bstrSrc.m_str, true, true, true) == 0);
}
bool __stdcall operator==(LPCOLESTR pszSrc) const throw()
{
CComBSTR2 bstr2(pszSrc);
return operator==(bstr2);
}
bool __stdcall operator==(LPOLESTR pszSrc) const throw()
{
return operator==((LPCOLESTR)pszSrc);
}
bool __stdcall operator==(int nNull) const throw()
{
ATLASSERT(nNull == NULL);
(void)nNull;
return (m_str == NULL);
}
CComBSTR2(LPCSTR pSrc)
{
if (pSrc != NULL)
{
m_str = A2WBSTR(pSrc);
if (m_str == NULL)
AtlThrow(E_OUTOFMEMORY);
}
else
m_str = NULL;
}
CComBSTR2(int nSize, LPCSTR sz)
{
if (nSize != 0 && sz == NULL)
{
HRESULT hr = SetLength(nSize);
if (FAILED(hr))
AtlThrow(hr);
}
else
{
m_str = A2WBSTR(sz, nSize);
if (m_str == NULL && nSize != 0)
AtlThrow(E_OUTOFMEMORY);
}
}
HRESULT __stdcall Append(LPCSTR lpsz) throw()
{
if (lpsz == NULL)
return S_OK;
CComBSTR2 bstrTemp;
ATLTRY(bstrTemp = lpsz);
if (bstrTemp.m_str == NULL)
return E_OUTOFMEMORY;
return Append(bstrTemp);
}
CComBSTR2& __stdcall operator=(ULONG ulong)
{
Empty();
HRESULT hr = ::VarBstrFromUI4(ulong, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
// Define assignment operator.
//A& A::operator=( const A& );
LONG __stdcall ToLong()
{
LONG retval = 0;
HRESULT hr = ::VarI4FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
HRESULT __stdcall AssignWordHex(WORD pVal, bool fixedLen = true) throw()
{
PCWSTR fmt = fixedLen ? L"%04x" : L"%x";
return Format(fmt, pVal);
}
HRESULT __stdcall AssignLongHex(LONG pVal, bool fixedLen = true) throw()
{
PCWSTR fmt = fixedLen ? L"%08x" : L"%x";
return Format(fmt, pVal) ;
}
CComBSTR2& __stdcall operator=(LONG pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromI4(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
CComBSTR2& __stdcall operator=(USHORT pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromUI2(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
SHORT __stdcall ToShort()
{
SHORT retval = 0;
HRESULT hr = ::VarI2FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
CComBSTR2& __stdcall operator=(SHORT pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromI2(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
BYTE __stdcall ToByte()
{
BYTE retval = 0;
HRESULT hr = ::VarUI1FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
CComBSTR2& __stdcall operator=(BYTE pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromUI1(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
#if (_WIN32_WINNT >= 0x0501) || defined(_ATL_SUPPORT_VT_I8)
CComBSTR2& operator =(LONG64 pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromI8(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
LONG64 ToVlong()
{
LONG64 retval = 0;
HRESULT hr = ::VarI8FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr)) AtlThrow(hr);
return retval;
}
#endif
FLOAT __stdcall ToFloat()
{
FLOAT retval = 0;
HRESULT hr = ::VarR4FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
CComBSTR2& __stdcall operator=(FLOAT pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromR4(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
DOUBLE __stdcall ToDouble()
{
DOUBLE retval = 0;
HRESULT hr = ::VarR8FromStr(m_str, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &retval);
if (FAILED(hr))
AtlThrow(hr);
return retval;
}
CComBSTR2& __stdcall operator=(DOUBLE pSrc)
{
Empty();
HRESULT hr = ::VarBstrFromR8(pSrc, ::GetThreadLocale(),
LOCALE_NOUSEROVERRIDE, &m_str);
if (FAILED(hr)) AtlThrow(hr);
return *this;
}
CComBSTR2& __stdcall operator=(LPCSTR pSrc)
{
Empty();
m_str = A2WBSTR(pSrc);
if (m_str == NULL && pSrc != NULL)
AtlThrow(E_OUTOFMEMORY);
return *this;
}
bool __stdcall operator<(LPCSTR pszSrc) const
{
CComBSTR2 bstr2(pszSrc);
return operator<(bstr2);
}
bool __stdcall operator>(LPCSTR pszSrc) const
{
CComBSTR2 bstr2(pszSrc);
return operator>(bstr2);
}
bool __stdcall operator!=(LPCSTR pszSrc) const
{
return !operator==(pszSrc);
}
bool __stdcall operator==(LPCSTR pszSrc) const
{
CComBSTR2 bstr2(pszSrc);
return operator==(bstr2);
}
HRESULT __stdcall WriteToStream(IStream* pStream) throw()
{
ATLASSERT(pStream != NULL);
if(pStream == NULL)
return E_INVALIDARG;
ULONG cb;
ULONG cbStrLen = ULONG(m_str ? SysStringByteLen(m_str)+sizeof(OLECHAR) :
0);
HRESULT hr = pStream->Write((void*) &cbStrLen, sizeof(cbStrLen), &cb);
if (FAILED(hr))
return hr;
return cbStrLen ? pStream->Write((void*) m_str, cbStrLen, &cb) : S_OK;
}
HRESULT __stdcall ReadFromStream(IStream* pStream) throw()
{
ATLASSERT(pStream != NULL);
if(pStream == NULL)
return E_INVALIDARG;
ATLASSERT(m_str == NULL); // should be empty
Empty();
ULONG cbStrLen = 0;
HRESULT hr = pStream->Read((void*) &cbStrLen, sizeof(cbStrLen), NULL);
if ((hr == S_OK) && (cbStrLen != 0))
{
//subtract size for terminating NULL which we wrote out
//since SysAllocStringByteLen overallocates for the NULL
m_str = SysAllocStringByteLen(NULL, cbStrLen-sizeof(OLECHAR));
if (m_str == NULL)
hr = E_OUTOFMEMORY;
else
hr = pStream->Read((void*) m_str, cbStrLen, NULL);
// If SysAllocStringByteLen or IStream::Read failed, reset seek
// pointer to start of BSTR size.
if (hr != S_OK)
{
LARGE_INTEGER nOffset;
nOffset.QuadPart = -(static_cast<LONGLONG>(sizeof(cbStrLen)));
pStream->Seek(nOffset, STREAM_SEEK_CUR, NULL);
}
}
if (hr == S_FALSE)
hr = E_FAIL;
return hr;
}
static bool __stdcall LoadStringResource(HINSTANCE hInstance, UINT uID,
BSTR& bstrText) throw()
{
const ATLSTRINGRESOURCEIMAGE* pImage;
ATLASSERT(bstrText == NULL);
pImage = AtlGetStringResourceImage(hInstance, uID);
if (pImage != NULL)
{
bstrText = ::SysAllocStringLen(pImage->achString, pImage->nLength);
}
return (bstrText != NULL) ? true : false;
}
static bool __stdcall LoadStringResource(UINT uID, BSTR& bstrText) throw()
{
const ATLSTRINGRESOURCEIMAGE* pImage;
ATLASSERT(bstrText == NULL);
pImage = AtlGetStringResourceImage(uID);
if (pImage != NULL)
{
bstrText = ::SysAllocStringLen(pImage->achString, pImage->nLength);
}
return (bstrText != NULL) ? true : false;
}
// each character in BSTR is copied to each element in SAFEARRAY
HRESULT __stdcall BSTRToArray(LPSAFEARRAY *ppArray) throw()
{
return VectorFromBstr(m_str, ppArray);
}
// first character of each element in SAFEARRAY is copied to BSTR
HRESULT __stdcall ArrayToBSTR(const SAFEARRAY *pSrc) throw()
{
Empty();
return BstrFromVector((LPSAFEARRAY)pSrc, &m_str);
}
};
/////////////////////////////////////////////////////////////
// Class to Adapt CComBSTR2 and CComPtr for use with STL containers
// the syntax to use it is
// std::vector< CAdapt <CComBSTR2> > vect;
/////////////////////////////////////////////////////////////////////////////
// CComVariant2
class CComVariant2 : public tagVARIANT
{
// Constructors
public:
CComVariant2() throw()
{
ZeroMemory(this, sizeof(VARIANT));
}
~CComVariant2() throw()
{
Clear();
}
CComVariant2(const VARIANT& varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CComVariant2(const CComVariant2& varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CComVariant2(LPCOLESTR lpszSrc)
{
vt = VT_EMPTY;
*this = lpszSrc;
}
CComVariant2(LPCSTR lpszSrc)
{
vt = VT_EMPTY;
*this = lpszSrc;
}
CComVariant2(bool bSrc)
{
vt = VT_BOOL;
boolVal = bSrc ? ATL_VARIANT_TRUE : ATL_VARIANT_FALSE;
}
CComVariant2(int nSrc, VARTYPE vtSrc = VT_I4) throw()
{
ATLASSERT(vtSrc == VT_I4 || vtSrc == VT_INT);
vt = vtSrc;
intVal = nSrc;
}
CComVariant2(BYTE nSrc) throw()
{
vt = VT_UI1;
bVal = nSrc;
}
CComVariant2(short nSrc) throw()
{
vt = VT_I2;
iVal = nSrc;
}
CComVariant2(long nSrc, VARTYPE vtSrc = VT_I4) throw()
{
ATLASSERT(vtSrc == VT_I4 || vtSrc == VT_ERROR);
vt = vtSrc;
lVal = nSrc;
}
CComVariant2(float fltSrc) throw()
{
vt = VT_R4;
fltVal = fltSrc;
}
CComVariant2(double dblSrc, VARTYPE vtSrc = VT_R8) throw()
{
ATLASSERT(vtSrc == VT_R8 || vtSrc == VT_DATE);
vt = vtSrc;
dblVal = dblSrc;
}
#if (_WIN32_WINNT >= 0x0501) || defined(_ATL_SUPPORT_VT_I8)
CComVariant2(LONG64 nSrc) throw()
{
vt = VT_I8;
llVal = nSrc;
}
CComVariant2(ULONGLONG nSrc) throw()
{
vt = VT_UI8;
ullVal = nSrc;
}
#endif
// by e.n. works like ADsBuildVarArrayStr
CComVariant2(PCWSTR theArray[], int elements) throw()
{
BuildVarArray(theArray, elements);
}
CComVariant2(CY cySrc) throw()
{
vt = VT_CY;
cyVal.Hi = cySrc.Hi;
cyVal.Lo = cySrc.Lo;
}
CComVariant2(IDispatch* pSrc) throw()
{
vt = VT_DISPATCH;
pdispVal = pSrc;
// Need to AddRef as VariantClear will Release
if (pdispVal != NULL)
pdispVal->AddRef();
}
CComVariant2(IUnknown* pSrc) throw()
{
vt = VT_UNKNOWN;
punkVal = pSrc;
// Need to AddRef as VariantClear will Release
if (punkVal != NULL)
punkVal->AddRef();
}
CComVariant2(char cSrc) throw()
{
vt = VT_I1;
cVal = cSrc;
}
CComVariant2(unsigned short nSrc) throw()
{
vt = VT_UI2;
uiVal = nSrc;
}
CComVariant2(unsigned long nSrc) throw()
{
vt = VT_UI4;
ulVal = nSrc;
}
CComVariant2(unsigned int nSrc, VARTYPE vtSrc = VT_UI4) throw()
{
ATLASSERT(vtSrc == VT_UI4 || vtSrc == VT_UINT);
vt = vtSrc;
uintVal= nSrc;
}
CComVariant2(const CComBSTR2& bstrSrc)
{
vt = VT_EMPTY;
*this = bstrSrc;
}
CComVariant2(const SAFEARRAY *pSrc)
{
LPSAFEARRAY pCopy;
if (pSrc != NULL)
{
HRESULT hRes = ::SafeArrayCopy((LPSAFEARRAY)pSrc, &pCopy);
if (SUCCEEDED(hRes) && pCopy != NULL)
{
::SafeArrayGetVartype((LPSAFEARRAY)pSrc, &vt);
vt |= VT_ARRAY;
parray = pCopy;
}
else
{
vt = VT_ERROR;
scode = hRes;
}
}
}
// Assignment Operators
public:
CComVariant2& operator=(const CComVariant2& varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CComVariant2& operator=(const VARIANT& varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CComVariant2& operator=(const CComBSTR2& bstrSrc)
{
if (vt != VT_BSTR)
{
Clear();
vt = VT_BSTR;
}
if (bstrSrc.m_str == NULL)
{
::SysFreeString(bstrVal);
bstrVal = NULL;
}
else if (::SysReAllocStringLen(&bstrVal, bstrSrc.m_str, bstrSrc.Length())
== FALSE)
{
vt = VT_ERROR;
scode = E_OUTOFMEMORY;
}
return *this;
}
CComVariant2& operator=(LPCOLESTR lpszSrc)
{
if (vt != VT_BSTR)
{
Clear();
vt = VT_BSTR;
}
if (::SysReAllocString(&bstrVal, lpszSrc) == FALSE)
{
vt = VT_ERROR;
scode = E_OUTOFMEMORY;
}
return *this;
}
CComVariant2& operator=(LPCSTR lpszSrc)
{
USES_CONVERSION_EX;
if (vt != VT_BSTR)
{
Clear();
vt = VT_BSTR;
}
if (::SysReAllocString(&bstrVal, A2COLE_EX(lpszSrc,
_ATL_SAFE_ALLOCA_DEF_THRESHOLD)) == FALSE)
{
vt = VT_ERROR;
scode = E_OUTOFMEMORY;
}
return *this;
}
CComVariant2& operator=(bool bSrc)
{
if (vt != VT_BOOL)
{
Clear();
vt = VT_BOOL;
}
boolVal = bSrc ? ATL_VARIANT_TRUE : ATL_VARIANT_FALSE;
return *this;
}
CComVariant2& operator=(int nSrc) throw()
{
if (vt != VT_I4)
{
Clear();
vt = VT_I4;
}
intVal = nSrc;
return *this;
}
CComVariant2& operator=(BYTE nSrc) throw()
{
if (vt != VT_UI1)
{
Clear();
vt = VT_UI1;
}
bVal = nSrc;
return *this;
}
CComVariant2& operator=(short nSrc) throw()
{
if (vt != VT_I2)
{
Clear();
vt = VT_I2;
}
iVal = nSrc;
return *this;
}
CComVariant2& operator=(long nSrc) throw()
{
if (vt != VT_I4)
{
Clear();
vt = VT_I4;
}
lVal = nSrc;
return *this;
}
CComVariant2& operator=(float fltSrc) throw()
{
if (vt != VT_R4)
{
Clear();
vt = VT_R4;
}
fltVal = fltSrc;
return *this;
}
CComVariant2& operator=(double dblSrc) throw()
{
if (vt != VT_R8)
{
Clear();
vt = VT_R8;
}
dblVal = dblSrc;
return *this;
}
CComVariant2& operator=(CY cySrc) throw()
{
if (vt != VT_CY)
{
Clear();
vt = VT_CY;
}
cyVal= cySrc;
return *this;
}
CComVariant2& operator=(IDispatch* pSrc) throw()
{
Clear();
vt = VT_DISPATCH;
if (pSrc != NULL)
pSrc->QueryInterface(IID_IDispatch, (void**)&pdispVal);
return *this;
}
CComVariant2& operator=(IUnknown* pSrc) throw()
{
Clear();
vt = VT_UNKNOWN;
pSrc->QueryInterface(IID_IUnknown, (void**)&punkVal);
return *this;
}
CComVariant2& operator=(char cSrc) throw()
{
if (vt != VT_I1)
{
Clear();
vt = VT_I1;
}
cVal = cSrc;
return *this;
}
CComVariant2& operator=(unsigned short nSrc) throw()
{
if (vt != VT_UI2)
{
Clear();
vt = VT_UI2;
}
uiVal = nSrc;
return *this;
}
CComVariant2& operator=(unsigned long nSrc) throw()
{
if (vt != VT_UI4)
{
Clear();
vt = VT_UI4;
}
ulVal = nSrc;
return *this;
}
CComVariant2& operator=(unsigned int nSrc) throw()
{
if (vt != VT_UI4)
{
Clear();
vt = VT_UI4;
}
uintVal= nSrc;
return *this;
}
CComVariant2& operator=(BYTE* pbSrc) throw()
{
if (vt != (VT_UI1|VT_BYREF))
{
Clear();
vt = VT_UI1|VT_BYREF;
}
pbVal = pbSrc;
return *this;
}
CComVariant2& operator=(short* pnSrc) throw()
{
if (vt != (VT_I2|VT_BYREF))
{
Clear();
vt = VT_I2|VT_BYREF;
}
piVal = pnSrc;
return *this;
}
#ifdef _NATIVE_WCHAR_T_DEFINED
CComVariant2& operator=(USHORT* pnSrc) throw()
{
if (vt != (VT_UI2|VT_BYREF))
{
Clear();
vt = VT_UI2|VT_BYREF;
}
puiVal = pnSrc;
return *this;
}
#endif
CComVariant2& operator=(int* pnSrc) throw()
{
if (vt != (VT_I4|VT_BYREF))
{
Clear();
vt = VT_I4|VT_BYREF;
}
pintVal = pnSrc;
return *this;
}
CComVariant2& operator=(UINT* pnSrc) throw()
{
if (vt != (VT_UI4|VT_BYREF))
{
Clear();
vt = VT_UI4|VT_BYREF;
}
puintVal = pnSrc;
return *this;
}
CComVariant2& operator=(long* pnSrc) throw()
{
if (vt != (VT_I4|VT_BYREF))
{
Clear();
vt = VT_I4|VT_BYREF;
}
plVal = pnSrc;
return *this;
}
CComVariant2& operator=(ULONG* pnSrc) throw()
{
if (vt != (VT_UI4|VT_BYREF))
{
Clear();
vt = VT_UI4|VT_BYREF;
}
pulVal = pnSrc;
return *this;
}
#if (_WIN32_WINNT >= 0x0501) || defined(_ATL_SUPPORT_VT_I8)
CComVariant2& operator=(LONG64 nSrc) throw()
{
if (vt != VT_I8)
{
Clear();
vt = VT_I8;
}
llVal = nSrc;
return *this;
}
CComVariant2& operator=(LONG64* pnSrc) throw()
{
if (vt != (VT_I8|VT_BYREF))
{
Clear();
vt = VT_I8|VT_BYREF;
}
pllVal = pnSrc;
return *this;
}
CComVariant2& operator=(ULONGLONG nSrc) throw()
{
if (vt != VT_UI8)
{
Clear();
vt = VT_UI8;
}
ullVal = nSrc;
return *this;
}
CComVariant2& operator=(ULONGLONG* pnSrc) throw()
{
if (vt != (VT_UI8|VT_BYREF))
{
Clear();
vt = VT_UI8|VT_BYREF;
}
pullVal = pnSrc;
return *this;
}
#endif
CComVariant2& operator=(float* pfSrc) throw()
{
if (vt != (VT_R4|VT_BYREF))
{
Clear();
vt = VT_R4|VT_BYREF;
}
pfltVal = pfSrc;
return *this;
}
CComVariant2& operator=(double* pfSrc) throw()
{
if (vt != (VT_R8|VT_BYREF))
{
Clear();
vt = VT_R8|VT_BYREF;
}
pdblVal = pfSrc;
return *this;
}
CComVariant2& operator=(const SAFEARRAY *pSrc) throw()
{
Clear();
LPSAFEARRAY pCopy;
if (pSrc != NULL)
{
HRESULT hRes = ::SafeArrayCopy((LPSAFEARRAY)pSrc, &pCopy);
if (SUCCEEDED(hRes) && pCopy != NULL)
{
::SafeArrayGetVartype((LPSAFEARRAY)pSrc, &vt);
vt |= VT_ARRAY;
parray = pCopy;
}
else
{
vt = VT_ERROR;
scode = hRes;
}
}
return *this;
}
// Comparison Operators
public:
bool operator==(const VARIANT& varSrc) const throw()
{
// For backwards compatibility
if (vt == VT_NULL && varSrc.vt == VT_NULL)
return true;
return VarCmp((VARIANT*)this, (VARIANT*)&varSrc, ::GetThreadLocale(), 0)
== VARCMP_EQ;
}
bool operator!=(const VARIANT& varSrc) const throw()
{
return !operator==(varSrc);
}
bool operator<(const VARIANT& varSrc) const throw()
{
if (vt == VT_NULL && varSrc.vt == VT_NULL)
return false;
return VarCmp((VARIANT*)this, (VARIANT*)&varSrc, ::GetThreadLocale(),
0)==VARCMP_LT;
}
bool operator>(const VARIANT& varSrc) const throw()
{
if (vt == VT_NULL && varSrc.vt == VT_NULL)
return false;
return VarCmp((VARIANT*)this, (VARIANT*)&varSrc, ::GetThreadLocale(),
0)==VARCMP_GT;
}
// Operations
public:
HRESULT Clear() throw()
{
HRESULT hr = ::VariantClear(this);
bstrVal = NULL;
return hr;
}
// behaves like ADsBuildVarArrayStr
// returns: VT_ARRAY | VT_VARIANT (BSTR)
HRESULT BuildVarArray(VARIANT theArray[], int elements) throw()
{
HRESULT hr = S_OK;
if (elements <= 0 || theArray == NULL)
hr = E_INVALIDARG;
else
{
SAFEARRAYBOUND rgsa = {elements, 0};
SAFEARRAY *psa = SafeArrayCreate(VT_VARIANT, 1, &rgsa);
if (psa == NULL)
hr = E_OUTOFMEMORY;
else
{
Clear();
parray = psa;
vt = VT_ARRAY | VT_VARIANT;
VARIANT* copydata;
hr = SafeArrayAccessData(psa, (void**)©data);
if (SUCCEEDED(hr))
{
while(elements-- != 0)
VariantCopy(©data[elements], &theArray[elements]);
SafeArrayUnaccessData(psa);
}
}
}
return hr;
}
// behaves like ADsBuildVarArrayStr
// returns: VT_ARRAY | VT_VARIANT (BSTR)
HRESULT BuildVarArray(PCWSTR theArray[], int elements) throw()
{
HRESULT hr = S_OK;
if (elements <= 0 || theArray == NULL)
hr = E_INVALIDARG;
else
{
SAFEARRAYBOUND rgsa = {elements, 0};
SAFEARRAY *psa = SafeArrayCreate(VT_VARIANT, 1, &rgsa);
if (psa == NULL)
hr = E_OUTOFMEMORY;
else
{
Clear();
parray = psa;
vt = VT_ARRAY | VT_VARIANT;
VARIANT* copydata;
hr = SafeArrayAccessData(psa, (void**)©data);
if (SUCCEEDED(hr))
{
while(elements-- != 0)
{
copydata[elements].vt = VT_BSTR;
copydata[elements].bstrVal = SysAllocString(theArray[elements]);
}
SafeArrayUnaccessData(psa);
}
}
}
return hr;
}
HRESULT Copy(const VARIANT* pSrc) throw() { return ::VariantCopy(this,
const_cast<VARIANT*>(pSrc)); }
// copy VARIANT to BSTR
HRESULT CopyTo(BSTR *pstrDest) throw()
{
ATLASSERT(pstrDest != NULL && vt == VT_BSTR);
HRESULT hRes = E_POINTER;
if (pstrDest != NULL && vt == VT_BSTR)
{
if (*pstrDest != NULL) //modified by e.n.
::SysFreeString(*pstrDest);
*pstrDest = ::SysAllocStringByteLen((char*)bstrVal,
::SysStringByteLen(bstrVal));
if (*pstrDest == NULL)
hRes = E_OUTOFMEMORY;
else
hRes = S_OK;
}
else if (vt != VT_BSTR)
hRes = DISP_E_TYPEMISMATCH;
return hRes;
}
//Added by e.n.
//attaches to a BSTR
// clears its contents first, then copies pointer, then assigns NULL
// to your pSrc
HRESULT Attach(BSTR* pSrc) throw()
{
if(pSrc == NULL)
return E_INVALIDARG;
// Clear out the variant
HRESULT hr = Clear();
if (hr == S_OK)
{
// Copy the pointer and give control to CComVariant2
bstrVal = *pSrc;
vt = VT_BSTR;
*pSrc = NULL;
hr = S_OK;
}
return hr;
}
HRESULT Attach(VARIANT* pSrc) throw()
{
if(pSrc == NULL)
return E_INVALIDARG;
// Clear out the variant
HRESULT hr = Clear();
if (hr == S_OK)
{
// Copy the contents and give control to CComVariant2
CopyMemory(this, pSrc, sizeof(VARIANT));
pSrc->vt = VT_EMPTY;
hr = S_OK;
}
return hr;
}
//Added by E.N.
void Detach() throw()
{
ZeroMemory(this, sizeof(VARIANT));
}
HRESULT Detach(BSTR* pDest) throw()
{
ATLASSERT(pDest != NULL);
if (*pDest != NULL)
SysFreeString(*pDest);
HRESULT hr = S_OK;
if (vt != VT_BSTR)
hr = ChangeType(VT_BSTR);
*pDest = bstrVal;
vt = VT_EMPTY;
bstrVal = NULL;
return hr;
}
HRESULT Detach(VARIANT* pDest) throw()
{
ATLASSERT(pDest != NULL);
if(pDest == NULL)
return E_POINTER;
// Clear out the variant
HRESULT hr = ::VariantClear(pDest);
if (!FAILED(hr))
{
// Copy the contents and remove control from CComVariant2
CopyMemory(pDest, this, sizeof(VARIANT));
vt = VT_EMPTY;
}
return hr;
}
HRESULT ChangeType(VARTYPE vtNew, const VARIANT* pSrc = NULL) throw()
{
// Convert in place if pSrc is NULL
VARIANT* pVar = pSrc == NULL ? this : const_cast<VARIANT*>(pSrc);
// Do nothing if doing in place convert and vts not different change by
E.N.
return ::VariantChangeTypeEx(this, pVar, ::GetThreadLocale(), 0, vtNew);
//return ::VariantChangeTypeEx(this, pVar, 0, vtNew);
}
template< typename T >
void SetByRef( T* pT ) throw()
{
Clear();
vt = CVarTypeInfo< T >::VT|VT_BYREF;
byref = pT;
}
HRESULT WriteToStream(IStream* pStream);
HRESULT ReadFromStream(IStream* pStream);
// Return the size in bytes of the current contents
ULONG GetSize() const;
// Implementation
public:
HRESULT InternalClear() throw()
{
HRESULT hr = Clear();
ATLASSERT(SUCCEEDED(hr));
if (FAILED(hr))
{
vt = VT_ERROR;
scode = hr;
}
return hr;
}
void InternalCopy(const VARIANT* pSrc) throw()
{
HRESULT hr = Copy(pSrc);
if (FAILED(hr))
{
vt = VT_ERROR;
scode = hr;
}
}
};
#pragma warning(push)
#pragma warning(disable: 4702)
inline HRESULT CComVariant2::WriteToStream(IStream* pStream) throw()
{
if(pStream == NULL)
return E_INVALIDARG;
HRESULT hr = pStream->Write(&vt, sizeof(VARTYPE), NULL);
if (FAILED(hr))
return hr;
int cbWrite = 0;
switch (vt)
{
case VT_UNKNOWN:
case VT_DISPATCH:
{
CComPtr<IPersistStream> spStream;
if (punkVal != NULL)
{
hr = punkVal->QueryInterface(__uuidof(IPersistStream),
(void**)&spStream);
if (FAILED(hr))
{
hr = punkVal->QueryInterface(__uuidof(IPersistStreamInit),
(void**)&spStream);
if (FAILED(hr))
return hr;
}
}
if (spStream != NULL)
return OleSaveToStream(spStream, pStream);
return WriteClassStm(pStream, CLSID_NULL);
}
case VT_UI1:
case VT_I1:
cbWrite = sizeof(BYTE);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
cbWrite = sizeof(short);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
cbWrite = sizeof(long);
break;
case VT_I8:
case VT_UI8:
cbWrite = sizeof(LONGLONG);
break;
case VT_R8:
case VT_CY:
case VT_DATE:
cbWrite = sizeof(double);
break;
default:
break;
}
if (cbWrite != 0)
return pStream->Write((void*) &bVal, cbWrite, NULL);
CComBSTR2 bstrWrite;
CComVariant2 varBSTR;
if (vt != VT_BSTR)
{
hr = ChangeType(VT_BSTR, this);
if (FAILED(hr))
return hr;
bstrWrite.Attach(varBSTR.bstrVal);
}
else
bstrWrite.Attach(bstrVal);
hr = bstrWrite.WriteToStream(pStream);
bstrWrite.Detach();
return hr;
}
#pragma warning(pop) // C4702
inline HRESULT CComVariant2::ReadFromStream(IStream* pStream) throw()
{
ATLASSERT(pStream != NULL);
if(pStream == NULL)
return E_INVALIDARG;
HRESULT hr;
hr = VariantClear(this);
if (FAILED(hr))
return hr;
VARTYPE vtRead = VT_EMPTY;
ULONG cbRead = 0;
hr = pStream->Read(&vtRead, sizeof(VARTYPE), &cbRead);
if (hr == S_FALSE || (cbRead != sizeof(VARTYPE) && hr == S_OK))
hr = E_FAIL;
if (FAILED(hr))
return hr;
vt = vtRead;
cbRead = 0;
switch (vtRead)
{
case VT_UNKNOWN:
case VT_DISPATCH:
{
punkVal = NULL;
hr = OleLoadFromStream(pStream,
(vtRead == VT_UNKNOWN) ? __uuidof(IUnknown) : __uuidof(IDispatch),
(void**)&punkVal);
// If IPictureDisp or IFontDisp property is not set,
// OleLoadFromStream() will return REGDB_E_CLASSNOTREG.
if (hr == REGDB_E_CLASSNOTREG)
hr = S_OK;
return hr;
}
case VT_UI1:
case VT_I1:
cbRead = sizeof(BYTE);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
cbRead = sizeof(short);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
cbRead = sizeof(long);
break;
case VT_I8:
case VT_UI8:
cbRead = sizeof(LONGLONG);
break;
case VT_R8:
case VT_CY:
case VT_DATE:
cbRead = sizeof(double);
break;
default:
break;
}
if (cbRead != 0)
{
hr = pStream->Read((void*) &bVal, cbRead, NULL);
if (hr == S_FALSE)
hr = E_FAIL;
return hr;
}
CComBSTR2 bstrRead;
hr = bstrRead.ReadFromStream(pStream);
if (FAILED(hr))
{
// If CComBSTR2::ReadFromStream failed, reset seek pointer to start of
// variant type.
LARGE_INTEGER nOffset;
nOffset.QuadPart = -(static_cast<LONGLONG>(sizeof(VARTYPE)));
pStream->Seek(nOffset, STREAM_SEEK_CUR, NULL);
return hr;
}
vt = VT_BSTR;
bstrVal = bstrRead.Detach();
if (vtRead != VT_BSTR)
hr = ChangeType(vtRead);
return hr;
}
inline ULONG CComVariant2::GetSize() const throw()
{
ULONG nSize = sizeof(VARTYPE);
HRESULT hr;
switch (vt)
{
case VT_UNKNOWN:
case VT_DISPATCH:
{
CComPtr<IPersistStream> spStream;
if (punkVal != NULL)
{
hr = punkVal->QueryInterface(__uuidof(IPersistStream),
(void**)&spStream);
if (FAILED(hr))
{
hr = punkVal->QueryInterface(__uuidof(IPersistStreamInit),
(void**)&spStream);
if (FAILED(hr))
break;
}
}
if (spStream != NULL)
{
ULARGE_INTEGER nPersistSize;
nPersistSize.QuadPart = 0;
spStream->GetSizeMax(&nPersistSize);
nSize += nPersistSize.LowPart + sizeof(CLSID);
}
else
nSize += sizeof(CLSID);
}
break;
case VT_UI1:
case VT_I1:
nSize += sizeof(BYTE);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
nSize += sizeof(short);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
nSize += sizeof(long);
break;
case VT_I8:
case VT_UI8:
nSize += sizeof(LONGLONG);
break;
case VT_R8:
case VT_CY:
case VT_DATE:
nSize += sizeof(double);
break;
default:
break;
}
if (nSize == sizeof(VARTYPE))
{
BSTR bstr = NULL;
CComVariant2 varBSTR;
if (vt != VT_BSTR)
{
if (SUCCEEDED(varBSTR.ChangeType(VT_BSTR, this)))
bstr = varBSTR.bstrVal;
}
else
bstr = bstrVal;
// Add the size of the length, the string itself and the NULL character
if (bstr != NULL)
nSize += sizeof(UINT) + SysStringByteLen(bstr) + sizeof(OLECHAR);
}
return nSize;
}
} //namespace ATL /hack