_bstr_t::Data_t Class Reference

Public Member Functions
	Data_t (const char *s)
	Data_t (const wchar_t *s)
	Data_t (BSTR bstr, bool fCopy)
	Data_t (const _bstr_t &s1, const _bstr_t &s2)
unsigned long	AddRef () throw ()
unsigned long	Release () throw ()
unsigned long	RefCount () const throw ()
	operator const wchar_t * () const throw ()
	operator const char * () const
const wchar_t *	GetWString () const throw ()
wchar_t *&	GetWString () throw ()
const char *	GetString () const
BSTR	Copy () const
void	Assign (BSTR s)
void	Attach (BSTR s) throw ()
unsigned int	Length () const throw ()
int	Compare (const Data_t &str) const throw ()
void *	operator new (size_t sz)

Private Member Functions
	Data_t () throw ()
	Data_t (const Data_t &s) throw ()
	~Data_t () throw ()
void	_Free () throw ()

Private Attributes
BSTR	m_wstr
char *	m_str
unsigned long	m_RefCount

Constructor & Destructor Documentation

_bstr_t::Data_t::Data_t ( const char *  s )

inline

    : m_str(NULL), m_RefCount(1)
{
    m_wstr = _com_util::ConvertStringToBSTR(s);
}

_bstr_t::Data_t::Data_t ( const wchar_t *  s )

inline

    : m_str(NULL), m_RefCount(1)
{
    m_wstr = ::SysAllocString(s);

    if (m_wstr == NULL && s != NULL) {
        _com_issue_error(E_OUTOFMEMORY);
    }
}

_bstr_t::Data_t::Data_t ( BSTR  bstr, bool  fCopy  )

inline

    : m_str(NULL), m_RefCount(1)
{
    if (fCopy && bstr != NULL) {
        m_wstr = ::SysAllocStringByteLen(reinterpret_cast<char*>(bstr),
                                         ::SysStringByteLen(bstr));

        if (m_wstr == NULL) {
            _com_issue_error(E_OUTOFMEMORY);
        }
    }
    else {
        m_wstr = bstr;
    }
}

_bstr_t::Data_t::Data_t ( const _bstr_t &  s1, const _bstr_t &  s2  )

inline

    : m_str(NULL), m_RefCount(1)
{
    const unsigned int l1 = s1.length();
    const unsigned int l2 = s2.length();
    unsigned int l3;

    if (FAILED(_com_util::UIntAdd(l1, l2, &l3)) ||
        FAILED(_com_util::UIntMult(l3, sizeof(wchar_t), &l3)))
    {
        _com_issue_error(E_OUTOFMEMORY);
        return;
    }
    
    m_wstr = ::SysAllocStringByteLen(NULL, (l1 + l2) * sizeof(wchar_t));
    if (m_wstr == NULL) 
    {
        if (l1 + l2 == 0)
        {
            return;
        }
        _com_issue_error(E_OUTOFMEMORY);
        return;
    }

    const wchar_t* wstr1 = static_cast<const wchar_t*>(s1);

    if (wstr1 != NULL) 
    {
        _COM_MEMCPY_S(m_wstr, (l1 + l2 + 1) * sizeof(wchar_t), wstr1, (l1 + 1) * sizeof(wchar_t));
    }

    const wchar_t* wstr2 = static_cast<const wchar_t*>(s2);

    if (wstr2 != NULL) 
    {
        _COM_MEMCPY_S(m_wstr + l1, (l2 + 1) * sizeof(wchar_t), wstr2, (l2 + 1) * sizeof(wchar_t));
    }
}

_bstr_t::Data_t::Data_t ( ) throw ( )

private

_bstr_t::Data_t::Data_t ( const Data_t &  s ) throw ( )

private

_bstr_t::Data_t::~Data_t ( ) throw ( )

inlineprivate

{
    _Free();
}

Member Function Documentation

void _bstr_t::Data_t::_Free ( ) throw ( )

inlineprivate

{
    if (m_wstr != NULL) {
        ::SysFreeString(m_wstr);
        m_wstr = NULL;
    }

    if (m_str != NULL) {
        delete [] m_str;
        m_str = NULL;
    }
}

unsigned long _bstr_t::Data_t::AddRef ( ) throw ( )

inline

{
    InterlockedIncrement(reinterpret_cast<long*>(&m_RefCount));
    return m_RefCount;
}

void _bstr_t::Data_t::Assign ( BSTR  s )

inline

{
    _Free();

    if (s != NULL) {
        m_wstr = ::SysAllocStringByteLen(reinterpret_cast<char*>(s), ::SysStringByteLen(s));
        m_str = 0;
    }
}

void _bstr_t::Data_t::Attach ( BSTR  s ) throw ( )

inline

{
    _Free();

    m_wstr = s;
    m_str = 0;
    m_RefCount = 1;
}

int _bstr_t::Data_t::Compare ( const Data_t &  str ) const throw ( )

inline

{
    // Dont need to check for NULL here, because 
    // SysStringLen will return 0 if you pass in NULL
    const unsigned int l1 = ::SysStringLen(m_wstr);
    const unsigned int l2 = ::SysStringLen(str.m_wstr);

    unsigned int len = l1;
    if (len > l2) {
        len = l2;
    }

    BSTR bstr1 = m_wstr;
    BSTR bstr2 = str.m_wstr;

    while (len-- > 0) {
        if (*bstr1++ != *bstr2++) {
            return bstr1[-1] - bstr2[-1];
        }
    }

    return (l1 < l2) ? -1 : (l1 == l2) ? 0 : 1;
}

BSTR _bstr_t::Data_t::Copy ( ) const

inline

{
    if (m_wstr != NULL) {
        BSTR bstr = ::SysAllocStringByteLen(reinterpret_cast<char*>(m_wstr), ::SysStringByteLen(m_wstr));

        if (bstr == NULL) {
            _com_issue_error(E_OUTOFMEMORY);
        }

        return bstr;
    }

    return NULL;
}

const char * _bstr_t::Data_t::GetString ( ) const

inline

{
    if (m_str == NULL) {
        m_str = _com_util::ConvertBSTRToString(m_wstr);
    }

    return m_str;
}

const wchar_t * _bstr_t::Data_t::GetWString ( ) const throw ( )

inline

{
    return m_wstr;
}

wchar_t *& _bstr_t::Data_t::GetWString ( ) throw ( )

inline

{
    return m_wstr;
}

unsigned int _bstr_t::Data_t::Length ( ) const throw ( )

inline

{
    return m_wstr ? ::SysStringLen(m_wstr) : 0;
}

_bstr_t::Data_t::operator const char * ( ) const

inline

{
    return GetString();
}

_bstr_t::Data_t::operator const wchar_t * ( ) const throw ( )

inline

{
    return m_wstr;
}

void * _bstr_t::Data_t::operator new ( size_t  sz )

inline

{
    return ::operator new(sz);
}

unsigned long _bstr_t::Data_t::RefCount ( ) const throw ( )

inline

{
    return m_RefCount;
}

unsigned long _bstr_t::Data_t::Release ( ) throw ( )

inline

{
    unsigned long cRef = InterlockedDecrement(reinterpret_cast<long*>(&m_RefCount));
    if (cRef == 0) {
        delete this;
    }

    return cRef;
}

Member Data Documentation

unsigned long _bstr_t::Data_t::m_RefCount

private

char* _bstr_t::Data_t::m_str

mutableprivate

BSTR _bstr_t::Data_t::m_wstr

private

---

The documentation for this class was generated from the following file:

• VS2015/inc/comutil.h