| OLD | NEW |
|---|
| (Empty) |
| 1 // Windows/PropVariant.cpp | |
| 2 | |
| 3 #include "StdAfx.h" | |
| 4 | |
| 5 #include "PropVariant.h" | |
| 6 | |
| 7 #include "../Common/Defs.h" | |
| 8 | |
| 9 namespace NWindows { | |
| 10 namespace NCOM { | |
| 11 | |
| 12 CPropVariant::CPropVariant(const PROPVARIANT& varSrc) | |
| 13 { | |
| 14 vt = VT_EMPTY; | |
| 15 InternalCopy(&varSrc); | |
| 16 } | |
| 17 | |
| 18 CPropVariant::CPropVariant(const CPropVariant& varSrc) | |
| 19 { | |
| 20 vt = VT_EMPTY; | |
| 21 InternalCopy(&varSrc); | |
| 22 } | |
| 23 | |
| 24 CPropVariant::CPropVariant(BSTR bstrSrc) | |
| 25 { | |
| 26 vt = VT_EMPTY; | |
| 27 *this = bstrSrc; | |
| 28 } | |
| 29 | |
| 30 CPropVariant::CPropVariant(LPCOLESTR lpszSrc) | |
| 31 { | |
| 32 vt = VT_EMPTY; | |
| 33 *this = lpszSrc; | |
| 34 } | |
| 35 | |
| 36 CPropVariant& CPropVariant::operator=(const CPropVariant& varSrc) | |
| 37 { | |
| 38 InternalCopy(&varSrc); | |
| 39 return *this; | |
| 40 } | |
| 41 CPropVariant& CPropVariant::operator=(const PROPVARIANT& varSrc) | |
| 42 { | |
| 43 InternalCopy(&varSrc); | |
| 44 return *this; | |
| 45 } | |
| 46 | |
| 47 CPropVariant& CPropVariant::operator=(BSTR bstrSrc) | |
| 48 { | |
| 49 *this = (LPCOLESTR)bstrSrc; | |
| 50 return *this; | |
| 51 } | |
| 52 | |
| 53 CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc) | |
| 54 { | |
| 55 InternalClear(); | |
| 56 vt = VT_BSTR; | |
| 57 wReserved1 = 0; | |
| 58 bstrVal = ::SysAllocString(lpszSrc); | |
| 59 if (bstrVal == NULL && lpszSrc != NULL) | |
| 60 { | |
| 61 vt = VT_ERROR; | |
| 62 scode = E_OUTOFMEMORY; | |
| 63 } | |
| 64 return *this; | |
| 65 } | |
| 66 | |
| 67 | |
| 68 CPropVariant& CPropVariant::operator=(bool bSrc) | |
| 69 { | |
| 70 if (vt != VT_BOOL) | |
| 71 { | |
| 72 InternalClear(); | |
| 73 vt = VT_BOOL; | |
| 74 } | |
| 75 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE; | |
| 76 return *this; | |
| 77 } | |
| 78 | |
| 79 CPropVariant& CPropVariant::operator=(UInt32 value) | |
| 80 { | |
| 81 if (vt != VT_UI4) | |
| 82 { | |
| 83 InternalClear(); | |
| 84 vt = VT_UI4; | |
| 85 } | |
| 86 ulVal = value; | |
| 87 return *this; | |
| 88 } | |
| 89 | |
| 90 CPropVariant& CPropVariant::operator=(UInt64 value) | |
| 91 { | |
| 92 if (vt != VT_UI8) | |
| 93 { | |
| 94 InternalClear(); | |
| 95 vt = VT_UI8; | |
| 96 } | |
| 97 uhVal.QuadPart = value; | |
| 98 return *this; | |
| 99 } | |
| 100 | |
| 101 CPropVariant& CPropVariant::operator=(const FILETIME &value) | |
| 102 { | |
| 103 if (vt != VT_FILETIME) | |
| 104 { | |
| 105 InternalClear(); | |
| 106 vt = VT_FILETIME; | |
| 107 } | |
| 108 filetime = value; | |
| 109 return *this; | |
| 110 } | |
| 111 | |
| 112 CPropVariant& CPropVariant::operator=(Int32 value) | |
| 113 { | |
| 114 if (vt != VT_I4) | |
| 115 { | |
| 116 InternalClear(); | |
| 117 vt = VT_I4; | |
| 118 } | |
| 119 lVal = value; | |
| 120 | |
| 121 return *this; | |
| 122 } | |
| 123 | |
| 124 CPropVariant& CPropVariant::operator=(Byte value) | |
| 125 { | |
| 126 if (vt != VT_UI1) | |
| 127 { | |
| 128 InternalClear(); | |
| 129 vt = VT_UI1; | |
| 130 } | |
| 131 bVal = value; | |
| 132 return *this; | |
| 133 } | |
| 134 | |
| 135 CPropVariant& CPropVariant::operator=(Int16 value) | |
| 136 { | |
| 137 if (vt != VT_I2) | |
| 138 { | |
| 139 InternalClear(); | |
| 140 vt = VT_I2; | |
| 141 } | |
| 142 iVal = value; | |
| 143 return *this; | |
| 144 } | |
| 145 | |
| 146 /* | |
| 147 CPropVariant& CPropVariant::operator=(LONG value) | |
| 148 { | |
| 149 if (vt != VT_I4) | |
| 150 { | |
| 151 InternalClear(); | |
| 152 vt = VT_I4; | |
| 153 } | |
| 154 lVal = value; | |
| 155 return *this; | |
| 156 } | |
| 157 */ | |
| 158 | |
| 159 static HRESULT MyPropVariantClear(PROPVARIANT *propVariant) | |
| 160 { | |
| 161 switch(propVariant->vt) | |
| 162 { | |
| 163 case VT_UI1: | |
| 164 case VT_I1: | |
| 165 case VT_I2: | |
| 166 case VT_UI2: | |
| 167 case VT_BOOL: | |
| 168 case VT_I4: | |
| 169 case VT_UI4: | |
| 170 case VT_R4: | |
| 171 case VT_INT: | |
| 172 case VT_UINT: | |
| 173 case VT_ERROR: | |
| 174 case VT_FILETIME: | |
| 175 case VT_UI8: | |
| 176 case VT_R8: | |
| 177 case VT_CY: | |
| 178 case VT_DATE: | |
| 179 propVariant->vt = VT_EMPTY; | |
| 180 propVariant->wReserved1 = 0; | |
| 181 return S_OK; | |
| 182 } | |
| 183 return ::VariantClear((VARIANTARG *)propVariant); | |
| 184 } | |
| 185 | |
| 186 HRESULT CPropVariant::Clear() | |
| 187 { | |
| 188 return MyPropVariantClear(this); | |
| 189 } | |
| 190 | |
| 191 HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) | |
| 192 { | |
| 193 ::VariantClear((tagVARIANT *)this); | |
| 194 switch(pSrc->vt) | |
| 195 { | |
| 196 case VT_UI1: | |
| 197 case VT_I1: | |
| 198 case VT_I2: | |
| 199 case VT_UI2: | |
| 200 case VT_BOOL: | |
| 201 case VT_I4: | |
| 202 case VT_UI4: | |
| 203 case VT_R4: | |
| 204 case VT_INT: | |
| 205 case VT_UINT: | |
| 206 case VT_ERROR: | |
| 207 case VT_FILETIME: | |
| 208 case VT_UI8: | |
| 209 case VT_R8: | |
| 210 case VT_CY: | |
| 211 case VT_DATE: | |
| 212 memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT)); | |
| 213 return S_OK; | |
| 214 } | |
| 215 return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)(pSrc)); | |
| 216 } | |
| 217 | |
| 218 | |
| 219 HRESULT CPropVariant::Attach(PROPVARIANT* pSrc) | |
| 220 { | |
| 221 HRESULT hr = Clear(); | |
| 222 if (FAILED(hr)) | |
| 223 return hr; | |
| 224 memcpy(this, pSrc, sizeof(PROPVARIANT)); | |
| 225 pSrc->vt = VT_EMPTY; | |
| 226 return S_OK; | |
| 227 } | |
| 228 | |
| 229 HRESULT CPropVariant::Detach(PROPVARIANT* pDest) | |
| 230 { | |
| 231 HRESULT hr = MyPropVariantClear(pDest); | |
| 232 if (FAILED(hr)) | |
| 233 return hr; | |
| 234 memcpy(pDest, this, sizeof(PROPVARIANT)); | |
| 235 vt = VT_EMPTY; | |
| 236 return S_OK; | |
| 237 } | |
| 238 | |
| 239 HRESULT CPropVariant::InternalClear() | |
| 240 { | |
| 241 HRESULT hr = Clear(); | |
| 242 if (FAILED(hr)) | |
| 243 { | |
| 244 vt = VT_ERROR; | |
| 245 scode = hr; | |
| 246 } | |
| 247 return hr; | |
| 248 } | |
| 249 | |
| 250 void CPropVariant::InternalCopy(const PROPVARIANT* pSrc) | |
| 251 { | |
| 252 HRESULT hr = Copy(pSrc); | |
| 253 if (FAILED(hr)) | |
| 254 { | |
| 255 vt = VT_ERROR; | |
| 256 scode = hr; | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 int CPropVariant::Compare(const CPropVariant &a) | |
| 261 { | |
| 262 if (vt != a.vt) | |
| 263 return 0; // it's mean some bug | |
| 264 switch (vt) | |
| 265 { | |
| 266 case VT_EMPTY: | |
| 267 return 0; | |
| 268 | |
| 269 /* | |
| 270 case VT_I1: | |
| 271 return MyCompare(cVal, a.cVal); | |
| 272 */ | |
| 273 case VT_UI1: | |
| 274 return MyCompare(bVal, a.bVal); | |
| 275 | |
| 276 case VT_I2: | |
| 277 return MyCompare(iVal, a.iVal); | |
| 278 case VT_UI2: | |
| 279 return MyCompare(uiVal, a.uiVal); | |
| 280 | |
| 281 case VT_I4: | |
| 282 return MyCompare(lVal, a.lVal); | |
| 283 /* | |
| 284 case VT_INT: | |
| 285 return MyCompare(intVal, a.intVal); | |
| 286 */ | |
| 287 case VT_UI4: | |
| 288 return MyCompare(ulVal, a.ulVal); | |
| 289 /* | |
| 290 case VT_UINT: | |
| 291 return MyCompare(uintVal, a.uintVal); | |
| 292 */ | |
| 293 case VT_I8: | |
| 294 return MyCompare(hVal.QuadPart, a.hVal.QuadPart); | |
| 295 case VT_UI8: | |
| 296 return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart); | |
| 297 | |
| 298 case VT_BOOL: | |
| 299 return -MyCompare(boolVal, a.boolVal); | |
| 300 | |
| 301 case VT_FILETIME: | |
| 302 return ::CompareFileTime(&filetime, &a.filetime); | |
| 303 case VT_BSTR: | |
| 304 return 0; // Not implemented | |
| 305 // return MyCompare(aPropVarint.cVal); | |
| 306 | |
| 307 default: | |
| 308 return 0; | |
| 309 } | |
| 310 } | |
| 311 | |
| 312 }} | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 624713003:
Keep only base/extractor.[cc|h]. (Closed)
Base URL: https://chromium.googlesource.com/external/omaha.git@master