1 // Windows/PropVariant.cpp 2 3 #include "StdAfx.h" 4 5 #include "../Common/Defs.h" 6 7 #include "PropVariant.h" 8 9 namespace NWindows { 10 namespace NCOM { 11 12 BSTR AllocBstrFromAscii(const char *s) throw() 13 { 14 if (!s) 15 return NULL; 16 UINT len = (UINT)strlen(s); 17 BSTR p = ::SysAllocStringLen(NULL, len); 18 if (p) 19 { 20 for (UINT i = 0; i <= len; i++) 21 p[i] = (Byte)s[i]; 22 } 23 return p; 24 } 25 26 HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw() 27 { 28 p->bstrVal = ::SysAllocStringLen(NULL, numChars); 29 if (!p->bstrVal) 30 { 31 p->vt = VT_ERROR; 32 p->scode = E_OUTOFMEMORY; 33 return E_OUTOFMEMORY; 34 } 35 p->vt = VT_BSTR; 36 return S_OK; 37 } 38 39 HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw() 40 { 41 p->bstrVal = AllocBstrFromAscii(s); 42 if (p->bstrVal) 43 { 44 p->vt = VT_BSTR; 45 return S_OK; 46 } 47 p->vt = VT_ERROR; 48 p->scode = E_OUTOFMEMORY; 49 return E_OUTOFMEMORY; 50 } 51 52 CPropVariant::CPropVariant(const PROPVARIANT &varSrc) 53 { 54 vt = VT_EMPTY; 55 InternalCopy(&varSrc); 56 } 57 58 CPropVariant::CPropVariant(const CPropVariant &varSrc) 59 { 60 vt = VT_EMPTY; 61 InternalCopy(&varSrc); 62 } 63 64 CPropVariant::CPropVariant(BSTR bstrSrc) 65 { 66 vt = VT_EMPTY; 67 *this = bstrSrc; 68 } 69 70 CPropVariant::CPropVariant(LPCOLESTR lpszSrc) 71 { 72 vt = VT_EMPTY; 73 *this = lpszSrc; 74 } 75 76 CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc) 77 { 78 InternalCopy(&varSrc); 79 return *this; 80 } 81 82 CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc) 83 { 84 InternalCopy(&varSrc); 85 return *this; 86 } 87 88 CPropVariant& CPropVariant::operator=(BSTR bstrSrc) 89 { 90 *this = (LPCOLESTR)bstrSrc; 91 return *this; 92 } 93 94 static const char * const kMemException = "out of memory"; 95 96 CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc) 97 { 98 InternalClear(); 99 vt = VT_BSTR; 100 wReserved1 = 0; 101 bstrVal = ::SysAllocString(lpszSrc); 102 if (!bstrVal && lpszSrc) 103 { 104 throw kMemException; 105 // vt = VT_ERROR; 106 // scode = E_OUTOFMEMORY; 107 } 108 return *this; 109 } 110 111 CPropVariant& CPropVariant::operator=(const UString &s) 112 { 113 InternalClear(); 114 vt = VT_BSTR; 115 wReserved1 = 0; 116 bstrVal = ::SysAllocStringLen(s, s.Len()); 117 if (!bstrVal) 118 throw kMemException; 119 return *this; 120 } 121 122 CPropVariant& CPropVariant::operator=(const UString2 &s) 123 { 124 /* 125 if (s.IsEmpty()) 126 *this = L""; 127 else 128 */ 129 { 130 InternalClear(); 131 vt = VT_BSTR; 132 wReserved1 = 0; 133 bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len()); 134 if (!bstrVal) 135 throw kMemException; 136 /* SysAllocStringLen probably appends a null-terminating character for NULL string. 137 But it doesn't specified in MSDN. 138 But we suppose that it works 139 140 if (!s.GetRawPtr()) 141 { 142 *bstrVal = 0; 143 } 144 */ 145 146 /* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL) 147 pointers to this function causes an unexpected termination of the application. 148 Is it safe? Maybe we must chamnge the code for that case ? */ 149 } 150 return *this; 151 } 152 153 CPropVariant& CPropVariant::operator=(const char *s) 154 { 155 InternalClear(); 156 vt = VT_BSTR; 157 wReserved1 = 0; 158 bstrVal = AllocBstrFromAscii(s); 159 if (!bstrVal) 160 { 161 throw kMemException; 162 // vt = VT_ERROR; 163 // scode = E_OUTOFMEMORY; 164 } 165 return *this; 166 } 167 168 CPropVariant& CPropVariant::operator=(bool bSrc) throw() 169 { 170 if (vt != VT_BOOL) 171 { 172 InternalClear(); 173 vt = VT_BOOL; 174 } 175 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE; 176 return *this; 177 } 178 179 BSTR CPropVariant::AllocBstr(unsigned numChars) 180 { 181 if (vt != VT_EMPTY) 182 InternalClear(); 183 vt = VT_BSTR; 184 wReserved1 = 0; 185 bstrVal = ::SysAllocStringLen(NULL, numChars); 186 if (!bstrVal) 187 { 188 throw kMemException; 189 // vt = VT_ERROR; 190 // scode = E_OUTOFMEMORY; 191 } 192 return bstrVal; 193 } 194 195 #define SET_PROP_FUNC(type, id, dest) \ 196 CPropVariant& CPropVariant::operator=(type value) throw() \ 197 { if (vt != id) { InternalClear(); vt = id; } \ 198 dest = value; return *this; } 199 200 SET_PROP_FUNC(Byte, VT_UI1, bVal) 201 // SET_PROP_FUNC(Int16, VT_I2, iVal) 202 SET_PROP_FUNC(Int32, VT_I4, lVal) 203 SET_PROP_FUNC(UInt32, VT_UI4, ulVal) 204 SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart) 205 SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart) 206 SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime) 207 208 HRESULT PropVariant_Clear(PROPVARIANT *prop) throw() 209 { 210 switch (prop->vt) 211 { 212 case VT_EMPTY: 213 case VT_UI1: 214 case VT_I1: 215 case VT_I2: 216 case VT_UI2: 217 case VT_BOOL: 218 case VT_I4: 219 case VT_UI4: 220 case VT_R4: 221 case VT_INT: 222 case VT_UINT: 223 case VT_ERROR: 224 case VT_FILETIME: 225 case VT_UI8: 226 case VT_R8: 227 case VT_CY: 228 case VT_DATE: 229 prop->vt = VT_EMPTY; 230 prop->wReserved1 = 0; 231 prop->wReserved2 = 0; 232 prop->wReserved3 = 0; 233 prop->uhVal.QuadPart = 0; 234 return S_OK; 235 } 236 return ::VariantClear((VARIANTARG *)prop); 237 // return ::PropVariantClear(prop); 238 // PropVariantClear can clear VT_BLOB. 239 } 240 241 HRESULT CPropVariant::Clear() throw() 242 { 243 if (vt == VT_EMPTY) 244 return S_OK; 245 return PropVariant_Clear(this); 246 } 247 248 HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw() 249 { 250 ::VariantClear((tagVARIANT *)this); 251 switch (pSrc->vt) 252 { 253 case VT_UI1: 254 case VT_I1: 255 case VT_I2: 256 case VT_UI2: 257 case VT_BOOL: 258 case VT_I4: 259 case VT_UI4: 260 case VT_R4: 261 case VT_INT: 262 case VT_UINT: 263 case VT_ERROR: 264 case VT_FILETIME: 265 case VT_UI8: 266 case VT_R8: 267 case VT_CY: 268 case VT_DATE: 269 memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT)); 270 return S_OK; 271 } 272 return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc)); 273 } 274 275 276 HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw() 277 { 278 HRESULT hr = Clear(); 279 if (FAILED(hr)) 280 return hr; 281 memcpy(this, pSrc, sizeof(PROPVARIANT)); 282 pSrc->vt = VT_EMPTY; 283 return S_OK; 284 } 285 286 HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw() 287 { 288 if (pDest->vt != VT_EMPTY) 289 { 290 HRESULT hr = PropVariant_Clear(pDest); 291 if (FAILED(hr)) 292 return hr; 293 } 294 memcpy(pDest, this, sizeof(PROPVARIANT)); 295 vt = VT_EMPTY; 296 return S_OK; 297 } 298 299 HRESULT CPropVariant::InternalClear() throw() 300 { 301 if (vt == VT_EMPTY) 302 return S_OK; 303 HRESULT hr = Clear(); 304 if (FAILED(hr)) 305 { 306 vt = VT_ERROR; 307 scode = hr; 308 } 309 return hr; 310 } 311 312 void CPropVariant::InternalCopy(const PROPVARIANT *pSrc) 313 { 314 HRESULT hr = Copy(pSrc); 315 if (FAILED(hr)) 316 { 317 if (hr == E_OUTOFMEMORY) 318 throw kMemException; 319 vt = VT_ERROR; 320 scode = hr; 321 } 322 } 323 324 int CPropVariant::Compare(const CPropVariant &a) throw() 325 { 326 if (vt != a.vt) 327 return MyCompare(vt, a.vt); 328 switch (vt) 329 { 330 case VT_EMPTY: return 0; 331 // case VT_I1: return MyCompare(cVal, a.cVal); 332 case VT_UI1: return MyCompare(bVal, a.bVal); 333 case VT_I2: return MyCompare(iVal, a.iVal); 334 case VT_UI2: return MyCompare(uiVal, a.uiVal); 335 case VT_I4: return MyCompare(lVal, a.lVal); 336 case VT_UI4: return MyCompare(ulVal, a.ulVal); 337 // case VT_UINT: return MyCompare(uintVal, a.uintVal); 338 case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart); 339 case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart); 340 case VT_BOOL: return -MyCompare(boolVal, a.boolVal); 341 case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime); 342 case VT_BSTR: return 0; // Not implemented 343 default: return 0; 344 } 345 } 346 347 }} 348
