cWinString.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWinString_H
#define _INC_cWinString_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/StrU.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cDebugAssert.h"
#ifdef _WIN32
#include "GrayCore/include/HResult.h"
// #include <oaidl.h>
#include <oleauto.h>
#endif
 
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cWinString);
 
#if defined(_WIN32) && ! defined(_MFC_VER)
        class cWinString
        {
 
        public:
                BSTR m_str;     
        public:
                cWinString()
                : m_str(nullptr)
                {
                }
                cWinString(const wchar_t* pSrc)
                {
                        if (pSrc == nullptr)
                        {
                                m_str = nullptr;
                                return;
                        }
                        m_str = ::SysAllocString(pSrc);
                }
                cWinString(StrLen_t nLenChars, const wchar_t* pSrc)
                {
                        if (pSrc == nullptr)
                        {
                                m_str = nullptr;
                                return;
                        }
                        m_str = ::SysAllocStringLen(pSrc, nLenChars);
                }
                cWinString(const char* pSrc)
                {
                        if (pSrc == nullptr)
                        {
                                m_str = nullptr;
                                return;
                        }
                        // DONT use ::SysAllocStringByteLen( pSrc, StrT::Len(pSrc)); does not convert to unicode.
                        StrLen_t iLenChars = StrU::UTF8toUNICODELen(pSrc) + 1;  // estimate size first. + null
                        m_str = ::SysAllocStringLen(nullptr, iLenChars);
                        StrU::UTF8toUNICODE(m_str, iLenChars, pSrc);
                }
                cWinString(const cWinString& src)
                {
                        m_str = src.MakeCopy();
                }
                ~cWinString()
                {
                        ::SysFreeString(m_str);
                }
 
                const cWinString& operator=(const cWinString& src)
                {
                        if (m_str != src.m_str)
                        {
                                ::SysFreeString(m_str);
                                m_str = src.MakeCopy();
                        }
                        return *this;
                }
 
                const cWinString& operator=(const wchar_t* pSrc)
                {
                        if (pSrc != m_str)
                        {
                                ::SysFreeString(m_str);
                                if (pSrc != nullptr)
                                        m_str = ::SysAllocString(pSrc);
                                else
                                        m_str = nullptr;
                        }
                        return *this;
                }
 
                StrLen_t Length() const throw()
                {
#if defined (_WIN32)
                        return (m_str == nullptr) ? 0 : ::SysStringLen(m_str);
#endif
                }
                size_t ByteLength() const throw()
                {
#if defined (_WIN32)
                        return (m_str == nullptr) ? 0 : ::SysStringByteLen(m_str);
#endif
                }
                StrLen_t get_Length() const throw()
                {
                        return Length();
                }
                const wchar_t* get_CPtr() const
                {
                        return m_str;
                }
                operator BSTR() const throw()
                {
                        return m_str;
                }
                BSTR MakeCopy() const throw()
                {
                        if (m_str == nullptr)
                                return nullptr;
                        // just do a binary copy.
                        return ::SysAllocStringByteLen((const char*)m_str, ::SysStringByteLen(m_str));
                }
                BSTR Copy() const throw()
                {
                        return MakeCopy();
                }
                BSTR* ref_BStr() throw()
                {
                        // A pointer to the string used as an output argument to a function call.
                        Empty();
                        return &m_str;
                }
                BSTR* operator&() throw()
                {
                        return ref_BStr();
                }
                void Attach(BSTR src) throw()
                {
                        if (m_str != src)
                        {
                                ::SysFreeString(m_str);
                                m_str = src;
                        }
                }
                BSTR Detach() throw()
                {
                        BSTR s = m_str;
                        m_str = nullptr;
                        return s;
                }
                void Empty() throw()
                {
                        ::SysFreeString(m_str);
                        m_str = nullptr;
                }
                HRESULT CopyTo(VARIANT* pvarDest) const throw()
                {
                        HRESULT hRes = E_POINTER;
                        if (pvarDest != nullptr)
                        {
                                pvarDest->vt = VT_BSTR;
                                pvarDest->bstrVal = MakeCopy();
                                if (pvarDest->bstrVal == nullptr && m_str != nullptr)
                                        hRes = E_OUTOFMEMORY;
                                else
                                        hRes = S_OK;
                        }
                        return hRes;
                }
                HRESULT WriteToStream(IStream* pStream) throw()
                {
                        ASSERT(pStream != nullptr);
                        if (pStream == nullptr)
                                return E_INVALIDARG;
 
                        ULONG cb;
                        ULONG cbStrLen = ULONG(m_str ? ::SysStringByteLen(m_str) + sizeof(OLECHAR) : 0);
                        HRESULT hRes = pStream->Write((void*)&cbStrLen, sizeof(cbStrLen), &cb);
                        if (FAILED(hRes))
                                return hRes;
                        return cbStrLen ? pStream->Write((void*)m_str, cbStrLen, &cb) : S_OK;
                }
                HRESULT ReadFromStream(IStream* pStream) throw()
                {
                        ASSERT(pStream != nullptr);
                        if (pStream == nullptr)
                                return E_INVALIDARG;
 
                        ASSERT(m_str == nullptr); // should be empty
                        Empty();
 
                        ULONG cbStrLen = 0;
                        HRESULT hRes = pStream->Read((void*)&cbStrLen, sizeof(cbStrLen), nullptr);
                        if ((hRes == S_OK) && (cbStrLen != 0))
                        {
                                // subtract size for terminating '\0' which we wrote out
                                // since SysAllocStringByteLen over-allocates for the '\0'
                                m_str = ::SysAllocStringByteLen(nullptr, cbStrLen - sizeof(OLECHAR));
                                if (m_str == nullptr)
                                        hRes = E_OUTOFMEMORY;
                                else
                                        hRes = pStream->Read((void*)m_str, cbStrLen, nullptr);
                                // If SysAllocStringByteLen or IStream::Read failed, reset seek
                                // pointer to start of BSTR size.
                                if (hRes != S_OK)
                                {
                                        LARGE_INTEGER nOffset;
                                        nOffset.QuadPart = -(static_cast<LONGLONG>(sizeof(cbStrLen)));
                                        pStream->Seek(nOffset, STREAM_SEEK_CUR, nullptr);
                                }
                        }
                        if (hRes == S_FALSE)
                                hRes = HRESULT_WIN32_C(ERROR_READ_FAULT);
                        return hRes;
                }
 
                UNITTEST2_PREDEF(cWinString);
        };
#endif // _MFC_VER
 
#ifdef _MFC_VER // using MFC.
        typedef CComBSTR cWinString;
#elif defined(_WIN32)
        typedef cWinString CComBSTR;
#else
        typedef cStringW cWinString;
        // typedef cStringW CComBSTR;
#endif // _WIN32
};
#endif // _INC_cWinString_H