vcs.maemo.org Git - physicsfs/blob - lzma/CPP/Windows/PropVariant.cpp

   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 }}