src/dsutil/DSMPropertyBag.cpp

   1 #include "StdAfx.h"
   2 #include "DSUtil.h"
   3 #include "DSMPropertyBag.h"
   4
   5 //
   6 // IDSMPropertyBagImpl
   7 //
   8
   9 IDSMPropertyBagImpl::IDSMPropertyBagImpl()
  10 {
  11 }
  12
  13 IDSMPropertyBagImpl::~IDSMPropertyBagImpl()
  14 {
  15 }
  16
  17 // IPropertyBag
  18
  19 STDMETHODIMP IDSMPropertyBagImpl::Read(LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog)
  20 {
  21         CheckPointer(pVar, E_POINTER);
  22         if(pVar->vt != VT_EMPTY) return E_INVALIDARG;
  23         CStringW value = Lookup(pszPropName);
  24         if(value.IsEmpty()) return E_FAIL;
  25         CComVariant(value).Detach(pVar);
  26         return S_OK;
  27 }
  28
  29 STDMETHODIMP IDSMPropertyBagImpl::Write(LPCOLESTR pszPropName, VARIANT* pVar)
  30 {
  31         return SetProperty(pszPropName, pVar);
  32 }
  33
  34 // IPropertyBag2
  35
  36 STDMETHODIMP IDSMPropertyBagImpl::Read(ULONG cProperties, PROPBAG2* pPropBag, IErrorLog* pErrLog, VARIANT* pvarValue, HRESULT* phrError)
  37 {
  38         CheckPointer(pPropBag, E_POINTER);
  39         CheckPointer(pvarValue, E_POINTER);
  40         CheckPointer(phrError, E_POINTER);
  41         for(ULONG i = 0; i < cProperties; phrError[i] = S_OK, i++)
  42                 CComVariant(Lookup(pPropBag[i].pstrName)).Detach(pvarValue);
  43         return S_OK;
  44 }
  45
  46 STDMETHODIMP IDSMPropertyBagImpl::Write(ULONG cProperties, PROPBAG2* pPropBag, VARIANT* pvarValue)
  47 {
  48         CheckPointer(pPropBag, E_POINTER);
  49         CheckPointer(pvarValue, E_POINTER);
  50         for(ULONG i = 0; i < cProperties; i++)
  51                 SetProperty(pPropBag[i].pstrName, &pvarValue[i]);
  52         return S_OK;
  53 }
  54
  55 STDMETHODIMP IDSMPropertyBagImpl::CountProperties(ULONG* pcProperties)
  56 {
  57         CheckPointer(pcProperties, E_POINTER);
  58         *pcProperties = GetSize();
  59         return S_OK;
  60 }
  61
  62 STDMETHODIMP IDSMPropertyBagImpl::GetPropertyInfo(ULONG iProperty, ULONG cProperties, PROPBAG2* pPropBag, ULONG* pcProperties)
  63 {
  64         CheckPointer(pPropBag, E_POINTER);
  65         CheckPointer(pcProperties, E_POINTER);
  66         for(ULONG i = 0; i < cProperties; i++, iProperty++, (*pcProperties)++)
  67         {
  68                 CStringW key = GetKeyAt(iProperty);
  69                 pPropBag[i].pstrName = (BSTR)CoTaskMemAlloc((key.GetLength()+1)*sizeof(WCHAR));
  70                 if(!pPropBag[i].pstrName) return E_FAIL;
  71         wcscpy(pPropBag[i].pstrName, key);
  72         }
  73         return S_OK;
  74 }
  75
  76 STDMETHODIMP IDSMPropertyBagImpl::LoadObject(LPCOLESTR pstrName, DWORD dwHint, IUnknown* pUnkObject, IErrorLog* pErrLog)
  77 {
  78         return E_NOTIMPL;
  79 }
  80
  81 // IDSMProperyBag
  82
  83 HRESULT IDSMPropertyBagImpl::SetProperty(LPCWSTR key, LPCWSTR value)
  84 {
  85         CheckPointer(key, E_POINTER);
  86         CheckPointer(value, E_POINTER);
  87         if(!Lookup(key).IsEmpty()) SetAt(key, value);
  88         else Add(key, value);
  89         return S_OK;
  90 }
  91
  92 HRESULT IDSMPropertyBagImpl::SetProperty(LPCWSTR key, VARIANT* var)
  93 {
  94         CheckPointer(key, E_POINTER);
  95         CheckPointer(var, E_POINTER);
  96         if((var->vt & (VT_BSTR | VT_BYREF)) != VT_BSTR) return E_INVALIDARG;
  97         return SetProperty(key, var->bstrVal);
  98 }
  99
 100 HRESULT IDSMPropertyBagImpl::GetProperty(LPCWSTR key, BSTR* value)
 101 {
 102         CheckPointer(key, E_POINTER);
 103         CheckPointer(value, E_POINTER);
 104         int i = FindKey(key);
 105         if(i < 0) return E_FAIL;
 106         *value = GetValueAt(i).AllocSysString();
 107         return S_OK;
 108 }
 109
 110 HRESULT IDSMPropertyBagImpl::DelAllProperties()
 111 {
 112         RemoveAll();
 113         return S_OK;
 114 }
 115
 116 HRESULT IDSMPropertyBagImpl::DelProperty(LPCWSTR key)
 117 {
 118         return Remove(key) ? S_OK : S_FALSE;
 119 }
 120
 121 //
 122 // CDSMResource
 123 //
 124
 125 CCritSec CDSMResource::m_csResources;
 126 CAtlMap<DWORD, CDSMResource*> CDSMResource::m_resources;
 127
 128 CDSMResource::CDSMResource()
 129         : mime(_T("application/octet-stream"))
 130         , tag(0)
 131 {
 132         CAutoLock cAutoLock(&m_csResources);
 133         m_resources.SetAt((DWORD)this, this);
 134 }
 135
 136 CDSMResource::CDSMResource(const CDSMResource& r)
 137 {
 138         *this = r;
 139
 140         CAutoLock cAutoLock(&m_csResources);
 141         m_resources.SetAt((DWORD)this, this);
 142 }
 143
 144 CDSMResource::CDSMResource(LPCWSTR name, LPCWSTR desc, LPCWSTR mime, BYTE* pData, int len, DWORD_PTR tag)
 145 {
 146         this->name = name;
 147         this->desc = desc;
 148         this->mime = mime;
 149         data.SetCount(len);
 150         memcpy(data.GetData(), pData, data.GetCount());
 151         this->tag = tag;
 152
 153         CAutoLock cAutoLock(&m_csResources);
 154         m_resources.SetAt((DWORD)this, this);
 155 }
 156
 157 CDSMResource::~CDSMResource()
 158 {
 159         CAutoLock cAutoLock(&m_csResources);
 160         m_resources.RemoveKey((DWORD)this);
 161 }
 162
 163 void CDSMResource::operator = (const CDSMResource& r)
 164 {
 165         tag = r.tag;
 166         name = r.name;
 167         desc = r.desc;
 168         mime = r.mime;
 169         data.Copy(r.data);
 170 }
 171
 172 //
 173 // IDSMResourceBagImpl
 174 //
 175
 176 IDSMResourceBagImpl::IDSMResourceBagImpl()
 177 {
 178 }
 179
 180 // IDSMResourceBag
 181
 182 STDMETHODIMP_(DWORD) IDSMResourceBagImpl::ResGetCount()
 183 {
 184         return m_resources.GetCount();
 185 }
 186
 187 STDMETHODIMP IDSMResourceBagImpl::ResGet(DWORD iIndex, BSTR* ppName, BSTR* ppDesc, BSTR* ppMime, BYTE** ppData, DWORD* pDataLen, DWORD_PTR* pTag)
 188 {
 189         if(ppData) CheckPointer(pDataLen, E_POINTER);
 190
 191         if((INT_PTR)iIndex >= m_resources.GetCount())
 192                 return E_INVALIDARG;
 193
 194         CDSMResource& r = m_resources[iIndex];
 195
 196         if(ppName) *ppName = r.name.AllocSysString();
 197         if(ppDesc) *ppDesc = r.desc.AllocSysString();
 198         if(ppMime) *ppMime = r.mime.AllocSysString();
 199         if(ppData) {*pDataLen = r.data.GetCount(); memcpy(*ppData = (BYTE*)CoTaskMemAlloc(*pDataLen), r.data.GetData(), *pDataLen);}
 200         if(pTag) *pTag = r.tag;
 201
 202         return S_OK;
 203 }
 204
 205 STDMETHODIMP IDSMResourceBagImpl::ResSet(DWORD iIndex, LPCWSTR pName, LPCWSTR pDesc, LPCWSTR pMime, BYTE* pData, DWORD len, DWORD_PTR tag)
 206 {
 207         if((INT_PTR)iIndex >= m_resources.GetCount())
 208                 return E_INVALIDARG;
 209
 210         CDSMResource& r = m_resources[iIndex];
 211
 212         if(pName) r.name = pName;
 213         if(pDesc) r.desc = pDesc;
 214         if(pMime) r.mime = pMime;
 215         if(pData || len == 0) {r.data.SetCount(len); if(pData) memcpy(r.data.GetData(), pData, r.data.GetCount());}
 216         r.tag = tag;
 217
 218         return S_OK;
 219 }
 220
 221 STDMETHODIMP IDSMResourceBagImpl::ResAppend(LPCWSTR pName, LPCWSTR pDesc, LPCWSTR pMime, BYTE* pData, DWORD len, DWORD_PTR tag)
 222 {
 223         return ResSet(m_resources.Add(CDSMResource()), pName, pDesc, pMime, pData, len, tag);
 224 }
 225
 226 STDMETHODIMP IDSMResourceBagImpl::ResRemoveAt(DWORD iIndex)
 227 {
 228         if((INT_PTR)iIndex >= m_resources.GetCount())
 229                 return E_INVALIDARG;
 230
 231         m_resources.RemoveAt(iIndex);
 232
 233         return S_OK;
 234 }
 235
 236 STDMETHODIMP IDSMResourceBagImpl::ResRemoveAll(DWORD_PTR tag)
 237 {
 238         if(tag)
 239         {
 240                 for(int i = m_resources.GetCount() - 1; i >= 0; i--)
 241                         if(m_resources[i].tag == tag)
 242                                 m_resources.RemoveAt(i);
 243         }
 244         else
 245         {
 246                 m_resources.RemoveAll();
 247         }
 248
 249         return S_OK;
 250 }
 251
 252 //
 253 // CDSMChapter
 254 //
 255
 256 CDSMChapter::CDSMChapter()
 257 {
 258         order = counter++;
 259         rt = 0;
 260 }
 261
 262 CDSMChapter::CDSMChapter(REFERENCE_TIME rt, LPCWSTR name)
 263 {
 264         order = counter++;
 265         this->rt = rt;
 266         this->name = name;
 267 }
 268
 269 void CDSMChapter::operator = (const CDSMChapter& c)
 270 {
 271         order = c.counter;
 272         rt = c.rt;
 273         name = c.name;
 274 }
 275
 276 int CDSMChapter::counter = 0;
 277
 278 int CDSMChapter::Compare(const void* a, const void* b)
 279 {
 280         const CDSMChapter* ca = (const CDSMChapter*)a;
 281         const CDSMChapter* cb = (const CDSMChapter*)b;
 282
 283         if(ca->rt > cb->rt) return 1;
 284         else if(ca->rt < cb->rt) return -1;
 285
 286         return ca->order - cb->order;
 287 }
 288
 289 //
 290 // IDSMChapterBagImpl
 291 //
 292
 293 IDSMChapterBagImpl::IDSMChapterBagImpl()
 294 {
 295         m_fSorted = false;
 296 }
 297
 298 // IDSMRChapterBag
 299
 300 STDMETHODIMP_(DWORD) IDSMChapterBagImpl::ChapGetCount()
 301 {
 302         return m_chapters.GetCount();
 303 }
 304
 305 STDMETHODIMP IDSMChapterBagImpl::ChapGet(DWORD iIndex, REFERENCE_TIME* prt, BSTR* ppName)
 306 {
 307         if((INT_PTR)iIndex >= m_chapters.GetCount())
 308                 return E_INVALIDARG;
 309
 310         CDSMChapter& c = m_chapters[iIndex];
 311
 312         if(prt) *prt = c.rt;
 313         if(ppName) *ppName = c.name.AllocSysString();
 314
 315         return S_OK;
 316 }
 317
 318 STDMETHODIMP IDSMChapterBagImpl::ChapSet(DWORD iIndex, REFERENCE_TIME rt, LPCWSTR pName)
 319 {
 320         if((INT_PTR)iIndex >= m_chapters.GetCount())
 321                 return E_INVALIDARG;
 322
 323         CDSMChapter& c = m_chapters[iIndex];
 324
 325         c.rt = rt;
 326         if(pName) c.name = pName;
 327
 328         m_fSorted = false;
 329
 330         return S_OK;
 331 }
 332
 333 STDMETHODIMP IDSMChapterBagImpl::ChapAppend(REFERENCE_TIME rt, LPCWSTR pName)
 334 {
 335         return ChapSet(m_chapters.Add(CDSMChapter()), rt, pName);
 336 }
 337
 338 STDMETHODIMP IDSMChapterBagImpl::ChapRemoveAt(DWORD iIndex)
 339 {
 340         if((INT_PTR)iIndex >= m_chapters.GetCount())
 341                 return E_INVALIDARG;
 342
 343         m_chapters.RemoveAt(iIndex);
 344
 345         return S_OK;
 346 }
 347
 348 STDMETHODIMP IDSMChapterBagImpl::ChapRemoveAll()
 349 {
 350         m_chapters.RemoveAll();
 351
 352         m_fSorted = false;
 353
 354         return S_OK;
 355 }
 356
 357 STDMETHODIMP_(long) IDSMChapterBagImpl::ChapLookup(REFERENCE_TIME* prt, BSTR* ppName)
 358 {
 359         CheckPointer(prt, -1);
 360
 361         ChapSort();
 362
 363         int i = range_bsearch(m_chapters, *prt);
 364         if(i < 0) return -1;
 365
 366         *prt = m_chapters[i].rt;
 367         if(ppName) *ppName = m_chapters[i].name.AllocSysString();
 368
 369         return i;
 370 }
 371
 372 STDMETHODIMP IDSMChapterBagImpl::ChapSort()
 373 {
 374         if(m_fSorted) return S_FALSE;
 375         qsort(m_chapters.GetData(), m_chapters.GetCount(), sizeof(CDSMChapter), CDSMChapter::Compare);
 376         m_fSorted = true;
 377         return S_OK;
 378 }
 379
 380 //
 381 // CDSMChapterBag
 382 //
 383
 384 CDSMChapterBag::CDSMChapterBag(LPUNKNOWN pUnk, HRESULT* phr)
 385         : CUnknown(_T("CDSMChapterBag"), NULL)
 386 {
 387 }
 388
 389 STDMETHODIMP CDSMChapterBag::NonDelegatingQueryInterface(REFIID riid, void** ppv)
 390 {
 391     CheckPointer(ppv, E_POINTER);
 392
 393         return
 394                 QI(IDSMChapterBag)
 395                  __super::NonDelegatingQueryInterface(riid, ppv);
 396 }