00001
00002 #include "stdafx.h"
00003 #include "DecoratorSmart.h"
00004
00005
00006
00007 int CComBstrObj::Compare(BSTR q) const
00008 {
00009 unsigned int pl = p ? SysStringLen(p) : 0;
00010 unsigned int ql = q ? SysStringLen(q) : 0;
00011
00012 if( pl != ql )
00013 return pl - ql;
00014
00015 return wcsncmp(p, q, pl);
00016 }
00017
00018 void CopyTo(const char *p, int len, BSTR *b)
00019 {
00020 ASSERT( len >= 0 );
00021 ASSERT( b != NULL );
00022
00023 if(*b)
00024 {
00025 SysFreeString(*b);
00026 *b = NULL;
00027 }
00028
00029 if( len <= 0 )
00030 return;
00031
00032 UINT acp = GetACP();
00033 int blen = MultiByteToWideChar(acp, 0, p, len, NULL, 0);
00034
00035 if( blen <= 0 )
00036 HR_THROW(E_CONVERSION);
00037
00038 *b = SysAllocStringLen(NULL, blen);
00039 if( *b == NULL )
00040 HR_THROW(E_OUTOFMEMORY);
00041
00042 int tlen = MultiByteToWideChar(acp, 0, p, len, *b, blen);
00043
00044 if( tlen <= 0 )
00045 HR_THROW(E_CONVERSION);
00046
00047 ASSERT( tlen == blen );
00048
00049 (*b)[blen] = '\0';
00050 }
00051
00052 int GetCharLength(const OLECHAR *p, int olelen)
00053 {
00054 ASSERT( olelen >= -1 );
00055
00056 if( olelen == 0 )
00057 return 0;
00058
00059 UINT acp = GetACP();
00060
00061 int charlen = WideCharToMultiByte(acp, 0, p, olelen,
00062 NULL, 0, NULL, NULL);
00063
00064
00065 ASSERT( charlen > 0 );
00066
00067 return charlen;
00068 }
00069
00070 void CopyTo(const OLECHAR *p, int olelen, char *s, int charlen)
00071 {
00072 ASSERT( olelen >= -1 && charlen >= 0 );
00073 ASSERT( charlen == 0 || p != NULL );
00074
00075 if( charlen <= 0 )
00076 return;
00077
00078 UINT acp = GetACP();
00079
00080 int len = WideCharToMultiByte(acp, 0, p, olelen,
00081 s, charlen, NULL, NULL);
00082
00083
00084 ASSERT( len > 0 );
00085
00086 ASSERT( len == charlen );
00087 }
00088
00089 void CopyTo(const OLECHAR *p, GUID &guid)
00090 {
00091 ASSERT( p != NULL );
00092
00093 if( FAILED(IIDFromString(const_cast<OLECHAR*>(p), static_cast<IID*>(&guid))) )
00094 HR_THROW(E_CONVERSION);
00095 }
00096
00097 void CopyTo(const GUID &guid, BSTR *p)
00098 {
00099 ASSERT( p != NULL );
00100
00101 OLECHAR *q = NULL;
00102
00103 if( FAILED(StringFromIID(static_cast<IID>(guid), &q)) )
00104 HR_THROW(E_CONVERSION);
00105
00106 if(*p != NULL)
00107 SysFreeString(*p);
00108
00109 *p = SysAllocString(q);
00110 CoTaskMemFree(q);
00111 }
00112
00113
00114
00115 void CopyTo(const CComBstrObj *start, const CComBstrObj *end, SAFEARRAY **p)
00116 {
00117 ASSERT( p != NULL && *p == NULL );
00118 ASSERT( start <= end );
00119
00120 *p = SafeArrayCreateVector(VT_BSTR, 1, end - start);
00121 if( *p == NULL )
00122 HR_THROW(E_OUTOFMEMORY);
00123
00124 try
00125 {
00126 BSTR *q = NULL;
00127
00128 COMTHROW( SafeArrayAccessData(*p, (void**)&q) );
00129 ASSERT( q != NULL );
00130
00131 while( start < end )
00132 {
00133 CopyTo(*start, q);
00134
00135 ++q;
00136 ++start;
00137 }
00138
00139 COMTHROW( SafeArrayUnaccessData(*p) );
00140 }
00141 catch(hresult_exception &)
00142 {
00143 SafeArrayDestroy(*p);
00144 *p = NULL;
00145
00146 throw;
00147 }
00148 }
00149
00150 void MoveTo(CComBstrObj *start, CComBstrObj *end, SAFEARRAY **p)
00151 {
00152 ASSERT( p != NULL && *p == NULL );
00153 ASSERT( start <= end );
00154
00155 *p = SafeArrayCreateVector(VT_BSTR, 1, end - start);
00156 if( *p == NULL )
00157 HR_THROW(E_OUTOFMEMORY);
00158
00159 try
00160 {
00161 BSTR *q = NULL;
00162
00163 COMTHROW( SafeArrayAccessData(*p, (void**)&q) );
00164 ASSERT( q != NULL );
00165
00166 while( start < end )
00167 {
00168 MoveTo(*start, q);
00169
00170 ++q;
00171 ++start;
00172 }
00173
00174 COMTHROW( SafeArrayUnaccessData(*p) );
00175 }
00176 catch(hresult_exception &)
00177 {
00178 SafeArrayDestroy(*p);
00179 *p = NULL;
00180
00181 throw;
00182 }
00183 }
00184
00185 void CopyTo(const unsigned char *start, const unsigned char *end, SAFEARRAY **p)
00186 {
00187 ASSERT( p != NULL && *p == NULL );
00188 ASSERT( start <= end );
00189
00190 *p = SafeArrayCreateVector(VT_UI1, 1, end - start);
00191 if( *p == NULL )
00192 HR_THROW(E_OUTOFMEMORY);
00193
00194 try
00195 {
00196 unsigned char *q = NULL;
00197
00198 COMTHROW( SafeArrayAccessData(*p, (void**)&q) );
00199 ASSERT( q != NULL );
00200
00201 while( start < end )
00202 {
00203 *q = *start;
00204
00205 ++q;
00206 ++start;
00207 }
00208
00209 COMTHROW( SafeArrayUnaccessData(*p) );
00210 }
00211 catch(hresult_exception &)
00212 {
00213 SafeArrayDestroy(*p);
00214 *p = NULL;
00215
00216 throw;
00217 }
00218 }
00219
00220 void CopyTo(const long *start, const long *end, SAFEARRAY **p)
00221 {
00222 ASSERT( p != NULL && *p == NULL );
00223 ASSERT( start <= end );
00224
00225 *p = SafeArrayCreateVector(VT_I4, 1, end - start);
00226 if( *p == NULL )
00227 HR_THROW(E_OUTOFMEMORY);
00228
00229 try
00230 {
00231 long *q = NULL;
00232
00233 COMTHROW( SafeArrayAccessData(*p, (void**)&q) );
00234 ASSERT( q != NULL );
00235
00236 while( start < end )
00237 {
00238 *q = *start;
00239
00240 ++q;
00241 ++start;
00242 }
00243
00244 COMTHROW( SafeArrayUnaccessData(*p) );
00245 }
00246 catch(hresult_exception &)
00247 {
00248 SafeArrayDestroy(*p);
00249 *p = NULL;
00250
00251 throw;
00252 }
00253 }
00254
00255 void CopyTo(const GUID *start, const GUID *end, SAFEARRAY **p)
00256 {
00257 ASSERT( p != NULL && *p == NULL );
00258 ASSERT( start <= end );
00259
00260 SAFEARRAYBOUND bounds[2];
00261 bounds[0].cElements = end - start;
00262 bounds[0].lLbound = 1;
00263 bounds[1].cElements = sizeof(GUID);
00264 bounds[1].lLbound = 0;
00265
00266 *p = SafeArrayCreate(VT_UI1, 2, bounds);
00267 if( *p == NULL )
00268 HR_THROW(E_OUTOFMEMORY);
00269
00270 try
00271 {
00272 GUID *q = NULL;
00273
00274 COMTHROW( SafeArrayAccessData(*p, (void**)&q) );
00275 ASSERT( q != NULL );
00276
00277 while( start < end )
00278 {
00279 *q = *start;
00280
00281 ++q;
00282 ++start;
00283 }
00284
00285 COMTHROW( SafeArrayUnaccessData(*p) );
00286 }
00287 catch(hresult_exception &)
00288 {
00289 SafeArrayDestroy(*p);
00290 *p = NULL;
00291
00292 throw;
00293 }
00294 }
00295
00296 long GetArrayLength(SAFEARRAY *p)
00297 {
00298 ASSERT( p != NULL );
00299
00300 if( !(p->cDims == 1 || p->cDims == 2) )
00301 HR_THROW(E_INVALIDARG);
00302
00303 ASSERT( p->rgsabound[0].cElements >= 0 );
00304 return p->rgsabound[0].cElements;
00305 }
00306
00307 void GetArrayStart(SAFEARRAY *p, CComBstrObj *&start)
00308 {
00309 ASSERT( p != NULL );
00310
00311 if( (p->fFeatures & FADF_BSTR) != FADF_BSTR )
00312 HR_THROW(E_INVALIDARG);
00313
00314 start = (CComBstrObj*)p->pvData;
00315 }
00316
00317 void GetArrayStart(SAFEARRAY *p, long *&start)
00318 {
00319 ASSERT( p != NULL );
00320
00321 if( p->cbElements != 4 )
00322 HR_THROW(E_INVALIDARG);
00323
00324 start = (long*)p->pvData;
00325 }
00326
00327 void GetArrayStart(SAFEARRAY *p, unsigned char *&start)
00328 {
00329 ASSERT( p != NULL );
00330
00331 if( p->cbElements != 1 )
00332 HR_THROW(E_INVALIDARG);
00333
00334 start = (unsigned char*)p->pvData;
00335 }
00336
00337 void GetArrayStart(SAFEARRAY *p, GUID *&start)
00338 {
00339 ASSERT( p != NULL );
00340
00341 if( p->cbElements != 1 || p->cDims != 2 || p->rgsabound[1].cElements != sizeof(GUID) )
00342 HR_THROW(E_INVALIDARG);
00343
00344 start = (GUID*)p->pvData;
00345 }
00346
00347 void CopyTo(SAFEARRAY *p, CComBstrObj *start, CComBstrObj *end)
00348 {
00349 ASSERT( p != NULL );
00350 ASSERT( start <= end );
00351
00352 ASSERT( (p->fFeatures & FADF_BSTR) == FADF_BSTR );
00353
00354 BSTR *q = NULL;
00355
00356 COMTHROW( SafeArrayAccessData(p, (void**)&q) );
00357 ASSERT( q != NULL );
00358
00359 try
00360 {
00361 ASSERT( GetArrayLength(p) == (end - start) );
00362
00363 while( start < end )
00364 {
00365 CopyTo(*q, *start);
00366
00367 ++q;
00368 ++start;
00369 }
00370 }
00371 catch(hresult_exception &)
00372 {
00373 SafeArrayUnaccessData(p);
00374 throw;
00375 }
00376
00377 COMTHROW( SafeArrayUnaccessData(p) );
00378 }
00379
00380 void MoveTo(SAFEARRAY *p, CComBstrObj *start, CComBstrObj *end)
00381 {
00382 ASSERT( p != NULL );
00383 ASSERT( start <= end );
00384
00385 ASSERT( (p->fFeatures & FADF_BSTR) == FADF_BSTR );
00386
00387 BSTR *q = NULL;
00388
00389 COMTHROW( SafeArrayAccessData(p, (void**)&q) );
00390 ASSERT( q != NULL );
00391
00392 try
00393 {
00394 ASSERT( GetArrayLength(p) == (end - start) );
00395
00396 while( start < end )
00397 {
00398 MoveTo(q, *start);
00399
00400 ++q;
00401 ++start;
00402 }
00403 }
00404 catch(hresult_exception &)
00405 {
00406 SafeArrayUnaccessData(p);
00407 throw;
00408 }
00409
00410 COMTHROW( SafeArrayUnaccessData(p) );
00411 }
00412
00413 void CopyTo(SAFEARRAY *p, unsigned char *start, unsigned char *end)
00414 {
00415 ASSERT( p != NULL );
00416 ASSERT( start <= end );
00417
00418 ASSERT( p->cbElements == 1 );
00419
00420 const unsigned char *q = NULL;
00421
00422 COMTHROW( SafeArrayAccessData(p, (void**)&q) );
00423 ASSERT( q != NULL );
00424
00425 ASSERT( GetArrayLength(p) == (end - start) );
00426 memcpy( start, q, (end - start) * sizeof(unsigned char) );
00427
00428 COMTHROW( SafeArrayUnaccessData(p) );
00429 }
00430
00431 void CopyTo(SAFEARRAY *p, long *start, long *end)
00432 {
00433 ASSERT( p != NULL );
00434 ASSERT( start <= end );
00435
00436 ASSERT( p->cbElements == 4 );
00437
00438 const long *q = NULL;
00439
00440 COMTHROW( SafeArrayAccessData(p, (void**)&q) );
00441 ASSERT( q != NULL );
00442
00443 ASSERT( GetArrayLength(p) == (end - start) );
00444 memcpy( start, q, (end - start) * sizeof(long) );
00445
00446 COMTHROW( SafeArrayUnaccessData(p) );
00447 }
00448
00449 void CopyTo(SAFEARRAY *p, GUID *start, GUID *end)
00450 {
00451 ASSERT( p != NULL );
00452 ASSERT( start <= end );
00453
00454 ASSERT( p->cbElements == 1 );
00455
00456 const GUID *q = NULL;
00457
00458 COMTHROW( SafeArrayAccessData(p, (void**)&q) );
00459 ASSERT( q != NULL );
00460
00461 ASSERT( GetArrayLength(p) == (end - start) );
00462 memcpy( start, q, (end - start) * sizeof(GUID) );
00463
00464 COMTHROW( SafeArrayUnaccessData(p) );
00465 }
00466
00467
00468
00469 void CopyTo(unsigned char a, VARIANT *v)
00470 {
00471 ASSERT( v != NULL );
00472
00473 if( v->vt != VT_UI1 )
00474 {
00475 if( v->vt != VT_EMPTY )
00476 COMTHROW( VariantClear(v) );
00477
00478 v->vt = VT_UI1;
00479 }
00480 v->bVal = a;
00481 }
00482
00483 void CopyTo(short a, VARIANT *v)
00484 {
00485 ASSERT( v != NULL );
00486
00487 if( v->vt != VT_I2 )
00488 {
00489 if( v->vt != VT_EMPTY )
00490 COMTHROW( VariantClear(v) );
00491
00492 v->vt = VT_I2;
00493 }
00494 v->iVal = a;
00495 }
00496
00497 void CopyTo(long a, VARIANT *v)
00498 {
00499 ASSERT( v != NULL );
00500
00501 if( v->vt != VT_I4 )
00502 {
00503 if( v->vt != VT_EMPTY )
00504 COMTHROW( VariantClear(v) );
00505
00506 v->vt = VT_I4;
00507 }
00508 v->lVal = a;
00509 }
00510
00511 void CopyTo(double a, VARIANT *v)
00512 {
00513 ASSERT( v != NULL );
00514
00515 if( v->vt != VT_R8 )
00516 {
00517 if( v->vt != VT_EMPTY )
00518 COMTHROW( VariantClear(v) );
00519
00520 v->vt = VT_R8;
00521 }
00522 v->dblVal = a;
00523 }
00524
00525 void CopyTo(BSTR b, VARIANT *v)
00526 {
00527 ASSERT( v != NULL );
00528
00529 if( v->vt != VT_EMPTY )
00530 COMTHROW( VariantClear(v) );
00531
00532 v->bstrVal = SysAllocStringLen(b, SysStringLen(b));
00533 v->vt = VT_BSTR;
00534 }
00535
00536 void CopyTo(IDispatch *p, VARIANT *v)
00537 {
00538 ASSERT( v != NULL );
00539
00540 if( v->vt != VT_EMPTY )
00541 COMTHROW( VariantClear(v) );
00542
00543 v->pdispVal = p;
00544 if(p) p->AddRef();
00545 v->vt = VT_DISPATCH;
00546 }
00547
00548 void MoveTo(IDispatch **p, VARIANT *v)
00549 {
00550 ASSERT( p != NULL );
00551 ASSERT( v != NULL );
00552
00553 if( v->vt != VT_EMPTY )
00554 COMTHROW( VariantClear(v) );
00555
00556 v->pdispVal = *p;
00557 *p = NULL;
00558 v->vt = VT_DISPATCH;
00559 }
00560
00561 void CopyTo(const VARIANT &v, unsigned char &a)
00562 {
00563 if( v.vt == VT_UI1 )
00564 a = v.bVal;
00565 else if( v.vt == VT_EMPTY )
00566 a = 0;
00567 else
00568 {
00569 CComVariant w;
00570 COMTHROW( w.ChangeType(VT_UI1, &v) );
00571 ASSERT( w.vt == VT_UI1 );
00572 a = w.bVal;
00573 }
00574 }
00575
00576 void CopyTo(const VARIANT &v, short &a)
00577 {
00578 if( v.vt == VT_I2 )
00579 a = v.iVal;
00580 else if( v.vt == VT_EMPTY )
00581 a = 0;
00582 else
00583 {
00584 CComVariant w;
00585 COMTHROW( w.ChangeType(VT_I2, &v) );
00586 ASSERT( w.vt == VT_I2 );
00587 a = w.iVal;
00588 }
00589 }
00590
00591 void CopyTo(const VARIANT &v, long &a)
00592 {
00593 if( v.vt == VT_I4 )
00594 a = v.lVal;
00595 else if( v.vt == VT_EMPTY )
00596 a = 0;
00597 else
00598 {
00599 CComVariant w;
00600 COMTHROW( w.ChangeType(VT_I4, &v) );
00601 ASSERT( w.vt == VT_I4 );
00602 a = w.lVal;
00603 }
00604 }
00605
00606 void CopyTo(const VARIANT &v, double &a)
00607 {
00608 if( v.vt == VT_R8 )
00609 a = v.dblVal;
00610 else if( v.vt == VT_EMPTY )
00611 a = 0.0;
00612 else
00613 {
00614 CComVariant w;
00615 COMTHROW( w.ChangeType(VT_R8, &v) );
00616 ASSERT( w.vt == VT_R8 );
00617 a = w.dblVal;
00618 }
00619 }
00620
00621 void CopyTo(const VARIANT &v, BSTR *a)
00622 {
00623 ASSERT( a != NULL );
00624
00625 if( *a != NULL )
00626 {
00627 SysFreeString(*a);
00628 *a = NULL;
00629 }
00630
00631 if( v.vt == VT_BSTR )
00632 *a = SysAllocStringLen(v.bstrVal, SysStringLen(v.bstrVal));
00633 else if( v.vt != VT_EMPTY )
00634 {
00635 CComVariant w;
00636 COMTHROW( w.ChangeType(VT_BSTR, &v) );
00637 ASSERT( w.vt == VT_BSTR );
00638
00639 *a = w.bstrVal;
00640 w.vt = VT_EMPTY;
00641 }
00642 }
00643
00644 void CopyTo(const char *p, int len, VARIANT *v)
00645 {
00646 ASSERT( v != NULL );
00647
00648 if( v->vt != VT_EMPTY )
00649 COMTHROW( VariantClear(v) );
00650
00651 v->bstrVal = NULL;
00652 CopyTo(p, len, &v->bstrVal);
00653 v->vt = VT_BSTR;
00654 }
00655
00656 int GetCharLength(VARIANT &v)
00657 {
00658 if( v.vt == VT_EMPTY )
00659 return 0;
00660 else if( v.vt == VT_DISPATCH )
00661 {
00662
00663 COMTHROW( VariantChangeType(&v, &v, 0, VT_BSTR) );
00664 ASSERT( v.vt == VT_BSTR );
00665 }
00666
00667 if( v.vt == VT_BSTR )
00668 return GetCharLength(v.bstrVal);
00669
00670 HR_THROW(E_INVALIDARG);
00671 }
00672
00673 void CopyTo(const VARIANT &v, char *s, int charlen)
00674 {
00675 if( v.vt == VT_EMPTY )
00676 {
00677 ASSERT( charlen == 0 );
00678 return;
00679 }
00680
00681 ASSERT( v.vt == VT_BSTR );
00682 CopyTo(v.bstrVal, s, charlen);
00683 }
00684
00685 long GetArrayLength(const VARIANT &v)
00686 {
00687 if( (v.vt & VT_ARRAY) == VT_ARRAY )
00688 return GetArrayLength(v.parray);
00689 else if( v.vt == VT_EMPTY )
00690 return 0;
00691
00692 HR_THROW(E_INVALIDARG);
00693 }
00694
00695 void GetArrayStart(const VARIANT &v, CComBstrObj *&start)
00696 {
00697 if( (v.vt & VT_ARRAY) != VT_ARRAY )
00698 HR_THROW(E_INVALIDARG);
00699
00700 GetArrayStart(v.parray, start);
00701 }
00702
00703 void GetArrayStart(const VARIANT &v, unsigned char *&start)
00704 {
00705 if( (v.vt & VT_ARRAY) != VT_ARRAY )
00706 HR_THROW(E_INVALIDARG);
00707
00708 GetArrayStart(v.parray, start);
00709 }
00710
00711 void GetArrayStart(const VARIANT &v, long *&start)
00712 {
00713 if( (v.vt & VT_ARRAY) != VT_ARRAY )
00714 HR_THROW(E_INVALIDARG);
00715
00716 GetArrayStart(v.parray, start);
00717 }
00718
00719 void CopyTo(const CComBstrObj *start, const CComBstrObj *end, VARIANT *v)
00720 {
00721 ASSERT( v != NULL );
00722
00723 if( v->vt != VT_EMPTY )
00724 COMTHROW( VariantClear(v) );
00725
00726 v->parray = NULL;
00727 CopyTo(start, end, &v->parray);
00728 v->vt = VT_BSTR | VT_ARRAY;
00729 }
00730
00731 void MoveTo(CComBstrObj *start, CComBstrObj *end, VARIANT *v)
00732 {
00733 ASSERT( v != NULL );
00734
00735 if( v->vt != VT_EMPTY )
00736 COMTHROW( VariantClear(v) );
00737
00738 v->parray = NULL;
00739 MoveTo(start, end, &v->parray);
00740 v->vt = VT_BSTR | VT_ARRAY;
00741 }
00742
00743 void CopyTo(const unsigned char *start, const unsigned char *end, VARIANT *v)
00744 {
00745 ASSERT( v != NULL );
00746
00747 if( v->vt != VT_EMPTY )
00748 COMTHROW( VariantClear(v) );
00749
00750 v->parray = NULL;
00751 CopyTo(start, end, &v->parray);
00752 v->vt = VT_UI1 | VT_ARRAY;
00753 }
00754
00755 void CopyTo(const long *start, const long *end, VARIANT *v)
00756 {
00757 ASSERT( v != NULL );
00758
00759 if( v->vt != VT_EMPTY )
00760 COMTHROW( VariantClear(v) );
00761
00762 v->parray = NULL;
00763 CopyTo(start, end, &v->parray);
00764 v->vt = VT_I4 | VT_ARRAY;
00765 }
00766
00767 void CopyTo(const VARIANT &v, CComBstrObj *start, CComBstrObj *end)
00768 {
00769 ASSERT( start <= end );
00770
00771 if( v.vt == VT_EMPTY && start == end )
00772 return;
00773
00774 if( v.vt != (VT_BSTR | VT_ARRAY) )
00775 HR_THROW(E_INVALIDARG);
00776
00777 CopyTo(v.parray, start, end);
00778 }
00779
00780 void MoveTo(VARIANT *v, CComBstrObj *start, CComBstrObj *end)
00781 {
00782 ASSERT( v != NULL );
00783 ASSERT( start <= end );
00784
00785 if( v->vt == VT_EMPTY && start == end )
00786 return;
00787
00788 if( v->vt != (VT_BSTR | VT_ARRAY) )
00789 HR_THROW(E_INVALIDARG);
00790
00791 MoveTo(v->parray, start, end);
00792 COMTHROW( VariantClear(v) );
00793 }
00794
00795 void CopyTo(const VARIANT &v, unsigned char *start, unsigned char *end)
00796 {
00797 ASSERT( start <= end );
00798
00799 if( v.vt == VT_EMPTY && start == end )
00800 return;
00801
00802 if( v.vt != (VT_UI1 | VT_ARRAY) )
00803 HR_THROW(E_INVALIDARG);
00804
00805 CopyTo(v.parray, start, end);
00806 }
00807
00808 void CopyTo(const VARIANT &v, long *start, long *end)
00809 {
00810 ASSERT( start <= end );
00811
00812 if( v.vt == VT_EMPTY && start == end )
00813 return;
00814
00815 if( v.vt != (VT_I4 | VT_ARRAY) )
00816 HR_THROW(E_INVALIDARG);
00817
00818 CopyTo(v.parray, start, end);
00819 }
00820
00821 void CopyTo(const VARIANT &v, GUID &guid)
00822 {
00823 if( v.vt != (VT_UI1 | VT_ARRAY) || GetArrayLength(v) != sizeof(GUID) )
00824 HR_THROW(E_CONVERSION);
00825
00826 CopyTo(v, (unsigned char*)&guid, (unsigned char*)(&guid+1));
00827 }
00828
00829
00830
00831 bool IsEqualObject(IUnknown *p, IUnknown *q)
00832 {
00833 if( p == q )
00834 return true;
00835 else if( p == NULL || q == NULL )
00836 return false;
00837
00838 CComObjPtr<IUnknown> a;
00839 CComObjPtr<IUnknown> b;
00840 COMTHROW( p->QueryInterface(IID_IUnknown, (void**)PutOut(a)) );
00841 COMTHROW( q->QueryInterface(IID_IUnknown, (void**)PutOut(b)) );
00842
00843 return a == b;
00844 }
00845
