1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_connectivity.hxx" 26 #include "ado/Aolevariant.hxx" 27 #include "connectivity/dbconversion.hxx" 28 #include <com/sun/star/sdbc/SQLException.hpp> 29 #include <com/sun/star/util/Time.hpp> 30 #include <com/sun/star/util/Date.hpp> 31 #include <com/sun/star/util/DateTime.hpp> 32 #include "diagnose_ex.h" 33 #include "resource/sharedresources.hxx" 34 #include "resource/ado_res.hrc" 35 #include "com/sun/star/bridge/oleautomation/Date.hpp" 36 #include "com/sun/star/bridge/oleautomation/Currency.hpp" 37 #include "com/sun/star/bridge/oleautomation/SCode.hpp" 38 #include "com/sun/star/bridge/oleautomation/Decimal.hpp" 39 40 using namespace com::sun::star::beans; 41 using namespace com::sun::star::uno; 42 using namespace com::sun::star::bridge::oleautomation; 43 using namespace connectivity::ado; 44 using ::rtl::OUString; 45 46 OLEString::OLEString() 47 :m_sStr(NULL) 48 { 49 } 50 OLEString::OLEString(const BSTR& _sBStr) 51 :m_sStr(_sBStr) 52 { 53 } 54 OLEString::OLEString(const ::rtl::OUString& _sBStr) 55 { 56 m_sStr = ::SysAllocString(reinterpret_cast<LPCOLESTR>(_sBStr.getStr())); 57 } 58 OLEString::~OLEString() 59 { 60 if(m_sStr) 61 ::SysFreeString(m_sStr); 62 } 63 OLEString& OLEString::operator=(const ::rtl::OUString& _rSrc) 64 { 65 if(m_sStr) 66 ::SysFreeString(m_sStr); 67 m_sStr = ::SysAllocString(reinterpret_cast<LPCOLESTR>(_rSrc.getStr())); 68 return *this; 69 } 70 OLEString& OLEString::operator=(const OLEString& _rSrc) 71 { 72 if(this != &_rSrc) 73 { 74 if(m_sStr) 75 ::SysFreeString(m_sStr); 76 m_sStr = ::SysAllocString(_rSrc.m_sStr); 77 } 78 return *this; 79 } 80 OLEString& OLEString::operator=(const BSTR& _rSrc) 81 { 82 if(m_sStr) 83 ::SysFreeString(m_sStr); 84 m_sStr = _rSrc; 85 return *this; 86 } 87 OLEString::operator ::rtl::OUString() const 88 { 89 return (m_sStr != NULL) ? ::rtl::OUString(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(m_sStr)),::SysStringLen(m_sStr)) : ::rtl::OUString(); 90 } 91 OLEString::operator BSTR() const 92 { 93 return m_sStr; 94 } 95 BSTR* OLEString::operator &() 96 { 97 return &m_sStr; 98 } 99 sal_Int32 OLEString::length() const 100 { 101 return (m_sStr != NULL) ? ::SysStringLen(m_sStr) : 0; 102 } 103 104 OLEVariant::OLEVariant() 105 { 106 VariantInit(this); 107 } 108 OLEVariant::OLEVariant(const VARIANT& varSrc) 109 { 110 ::VariantInit(this); 111 HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(&varSrc)); 112 OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); 113 OSL_UNUSED(eRet); 114 } 115 OLEVariant::OLEVariant(const OLEVariant& varSrc) 116 { 117 ::VariantInit(this); 118 HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))); 119 OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); 120 OSL_UNUSED(eRet); 121 } 122 123 OLEVariant::OLEVariant(sal_Bool x) { VariantInit(this); vt = VT_BOOL; boolVal = (x ? VARIANT_TRUE : VARIANT_FALSE);} 124 OLEVariant::OLEVariant(sal_Int8 n) { VariantInit(this); vt = VT_I1; bVal = n;} 125 OLEVariant::OLEVariant(sal_Int16 n) { VariantInit(this); vt = VT_I2; intVal = n;} 126 OLEVariant::OLEVariant(sal_Int32 n) { VariantInit(this); vt = VT_I4; lVal = n;} 127 OLEVariant::OLEVariant(sal_Int64 x) { VariantInit(this); vt = VT_I4; lVal = (LONG)x;} 128 129 OLEVariant::OLEVariant(const rtl::OUString& us) 130 { 131 ::VariantInit(this); 132 vt = VT_BSTR; 133 bstrVal = SysAllocString(reinterpret_cast<LPCOLESTR>(us.getStr())); 134 } 135 OLEVariant::~OLEVariant() 136 { 137 HRESULT eRet = ::VariantClear(this); 138 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 139 OSL_UNUSED(eRet); 140 } // clears all the memory that was allocated before 141 142 OLEVariant::OLEVariant(const ::com::sun::star::util::Date& x ) 143 { 144 VariantInit(this); 145 vt = VT_DATE; 146 dblVal = ::dbtools::DBTypeConversion::toDouble(x,::com::sun::star::util::Date(30,12,1899)); 147 } 148 OLEVariant::OLEVariant(const ::com::sun::star::util::Time& x ) 149 { 150 VariantInit(this); 151 vt = VT_DATE; 152 dblVal = ::dbtools::DBTypeConversion::toDouble(x); 153 } 154 OLEVariant::OLEVariant(const ::com::sun::star::util::DateTime& x ) 155 { 156 VariantInit(this); 157 vt = VT_DATE; 158 dblVal = ::dbtools::DBTypeConversion::toDouble(x,::com::sun::star::util::Date(30,12,1899)); 159 } 160 OLEVariant::OLEVariant(const float &x) 161 { 162 VariantInit(this); 163 vt = VT_R4; 164 fltVal = x; 165 } 166 OLEVariant::OLEVariant(const double &x) 167 { 168 VariantInit(this); 169 vt = VT_R8; 170 dblVal = x; 171 } 172 173 174 OLEVariant::OLEVariant(IDispatch* pDispInterface) 175 { 176 VariantInit(this); 177 setIDispatch( pDispInterface ); 178 } 179 180 OLEVariant::OLEVariant(const ::com::sun::star::uno::Sequence< sal_Int8 >& x) 181 { 182 VariantInit(this); 183 184 vt = VT_ARRAY|VT_UI1; 185 186 SAFEARRAYBOUND rgsabound[1]; 187 rgsabound[0].lLbound = 0; 188 rgsabound[0].cElements = x.getLength(); 189 // parray = SafeArrayCreate(VT_UI1,1,rgsabound); 190 parray = SafeArrayCreateVector(VT_UI1, 0, x.getLength()); 191 const sal_Int8* pBegin = x.getConstArray(); 192 const sal_Int8* pEnd = pBegin + x.getLength(); 193 194 for(sal_Int32 i=0;pBegin != pEnd;++i,++pBegin) 195 { 196 sal_Int32 nData = *pBegin; 197 HRESULT rs = SafeArrayPutElement(parray,&i,&nData); 198 OSL_ENSURE(S_OK == rs,"Error while copy byte data"); 199 OSL_UNUSED(rs); 200 } 201 } 202 // 203 OLEVariant& OLEVariant::operator=(const OLEVariant& varSrc) 204 { 205 HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))); 206 OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); 207 OSL_UNUSED(eRet); 208 return *this; 209 } 210 // Assign a const VARIANT& (::VariantCopy handles everything) 211 // 212 OLEVariant& OLEVariant::operator=(const tagVARIANT& varSrc) 213 { 214 HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(&varSrc)); 215 OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); 216 OSL_UNUSED(eRet); 217 218 return *this; 219 } 220 221 // Assign a const VARIANT* (::VariantCopy handles everything) 222 // 223 OLEVariant& OLEVariant::operator=(const VARIANT* pSrc) 224 { 225 HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(pSrc)); 226 OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); 227 OSL_UNUSED(eRet); 228 229 return *this; 230 } 231 232 void OLEVariant::setByte(sal_uInt8 n) 233 { 234 HRESULT eRet = VariantClear(this); 235 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 236 OSL_UNUSED(eRet); 237 vt = VT_UI1; 238 bVal = n; 239 } 240 void OLEVariant::setInt16(sal_Int16 n) 241 { 242 HRESULT eRet = VariantClear(this); 243 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 244 OSL_UNUSED(eRet); 245 vt = VT_I2; 246 iVal = n; 247 } 248 void OLEVariant::setInt32(sal_Int32 n) 249 { 250 HRESULT eRet = VariantClear(this); 251 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 252 OSL_UNUSED(eRet); 253 vt = VT_I4; 254 lVal = n; 255 } 256 void OLEVariant::setFloat(float f) 257 { HRESULT eRet = VariantClear(this); 258 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 259 OSL_UNUSED(eRet); 260 vt = VT_R4; 261 fltVal = f; 262 } 263 void OLEVariant::setDouble(double d) 264 { 265 HRESULT eRet = VariantClear(this); 266 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 267 OSL_UNUSED(eRet); 268 vt = VT_R8; 269 dblVal = d; 270 } 271 void OLEVariant::setDate(DATE d) 272 { HRESULT eRet = VariantClear(this); 273 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 274 OSL_UNUSED(eRet); 275 vt = VT_DATE; 276 date = d; 277 } 278 void OLEVariant::setChar(unsigned char a) 279 { 280 HRESULT eRet = VariantClear(this); 281 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 282 OSL_UNUSED(eRet); 283 vt = VT_UI1; 284 bVal = a; 285 } 286 void OLEVariant::setCurrency(double aCur) 287 { 288 HRESULT eRet = VariantClear(this); 289 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 290 OSL_UNUSED(eRet); 291 vt = VT_CY; 292 set(aCur*10000); 293 } 294 void OLEVariant::setBool(sal_Bool b) 295 { 296 HRESULT eRet = VariantClear(this); 297 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 298 OSL_UNUSED(eRet); 299 vt = VT_BOOL; 300 boolVal = b ? VARIANT_TRUE : VARIANT_FALSE; 301 } 302 void OLEVariant::setString(const rtl::OUString& us) 303 { 304 HRESULT eRet = VariantClear(this); 305 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 306 OSL_UNUSED(eRet); 307 vt = VT_BSTR; 308 bstrVal = ::SysAllocString(reinterpret_cast<LPCOLESTR>(us.getStr())); 309 } 310 void OLEVariant::setNoArg() 311 { 312 HRESULT eRet = VariantClear(this); 313 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 314 OSL_UNUSED(eRet); 315 vt = VT_ERROR; 316 scode = DISP_E_PARAMNOTFOUND; 317 } 318 319 void OLEVariant::setNull() 320 { 321 HRESULT eRet = VariantClear(this); 322 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 323 OSL_UNUSED(eRet); 324 vt = VT_NULL; 325 } 326 void OLEVariant::setEmpty() 327 { 328 HRESULT eRet = VariantClear(this); 329 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 330 OSL_UNUSED(eRet); 331 vt = VT_EMPTY; 332 } 333 334 void OLEVariant::setUI1SAFEARRAYPtr(SAFEARRAY* pSafeAr) 335 { 336 HRESULT eRet = VariantClear(this); 337 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 338 OSL_UNUSED(eRet); 339 vt = VT_ARRAY|VT_UI1; parray = pSafeAr; 340 } 341 342 void OLEVariant::setArray(SAFEARRAY* pSafeArray, VARTYPE vtType) 343 { 344 HRESULT eRet = VariantClear(this); 345 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 346 OSL_UNUSED(eRet); 347 vt = (VARTYPE)(VT_ARRAY|vtType); 348 parray = pSafeArray; 349 } 350 351 void OLEVariant::setIDispatch(IDispatch* pDispInterface) 352 { 353 HRESULT eRet = VariantClear(this); 354 OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); 355 OSL_UNUSED(eRet); 356 357 vt = VT_DISPATCH; 358 pdispVal = pDispInterface; 359 360 if ( pDispInterface ) 361 pDispInterface->AddRef(); 362 } 363 364 365 sal_Bool OLEVariant::isNull() const { return (vt == VT_NULL); } 366 sal_Bool OLEVariant::isEmpty() const { return (vt == VT_EMPTY); } 367 368 VARTYPE OLEVariant::getType() const { return vt; } 369 370 OLEVariant::operator ::com::sun::star::util::Date() const 371 { 372 return isNull() ? ::com::sun::star::util::Date(30,12,1899) : ::dbtools::DBTypeConversion::toDate(getDate(),::com::sun::star::util::Date(30,12,1899)); 373 } 374 OLEVariant::operator ::com::sun::star::util::Time() const 375 { 376 return isNull() ? ::com::sun::star::util::Time() : ::dbtools::DBTypeConversion::toTime(getDate()); 377 } 378 OLEVariant::operator ::com::sun::star::util::DateTime()const 379 { 380 return isNull() ? ::com::sun::star::util::DateTime() : ::dbtools::DBTypeConversion::toDateTime(getDate(),::com::sun::star::util::Date(30,12,1899)); 381 } 382 383 VARIANT_BOOL OLEVariant::VariantBool(sal_Bool bEinBoolean) 384 { 385 return (bEinBoolean ? VARIANT_TRUE : VARIANT_FALSE); 386 } 387 388 void OLEVariant::CHS() 389 { 390 cyVal.Lo ^= (sal_uInt32)-1; 391 cyVal.Hi ^= -1; 392 cyVal.Lo++; 393 if( !cyVal.Lo ) 394 cyVal.Hi++; 395 } 396 397 void OLEVariant::set(double n) 398 { 399 if( n >= 0 ) 400 { 401 cyVal.Hi = (sal_Int32)(n / (double)4294967296.0); 402 cyVal.Lo = (sal_uInt32)(n - ((double)cyVal.Hi * (double)4294967296.0)); 403 } 404 else { 405 cyVal.Hi = (sal_Int32)(-n / (double)4294967296.0); 406 cyVal.Lo = (sal_uInt32)(-n - ((double)cyVal.Hi * (double)4294967296.0)); 407 CHS(); 408 } 409 } 410 411 OLEVariant::operator rtl::OUString() const 412 { 413 if (V_VT(this) == VT_BSTR) 414 return reinterpret_cast<const sal_Unicode*>(LPCOLESTR(V_BSTR(this))); 415 416 if(isNull()) 417 return ::rtl::OUString(); 418 419 OLEVariant varDest; 420 421 varDest.ChangeType(VT_BSTR, this); 422 423 return reinterpret_cast<const sal_Unicode*>(LPCOLESTR(V_BSTR(&varDest))); 424 } 425 426 // ----------------------------------------------------------------------------- 427 void OLEVariant::ChangeType(VARTYPE vartype, const OLEVariant* pSrc) 428 { 429 // 430 // If pDest is NULL, convert type in place 431 // 432 if (pSrc == NULL) 433 pSrc = this; 434 435 if ( ( this != pSrc ) 436 || ( vartype != V_VT( this ) ) 437 ) 438 { 439 if ( FAILED( ::VariantChangeType( static_cast< VARIANT* >( this ), 440 const_cast< VARIANT* >( static_cast< const VARIANT* >( pSrc ) ), 441 0, 442 vartype ) ) ) 443 { 444 ::connectivity::SharedResources aResources; 445 const ::rtl::OUString sError( aResources.getResourceString(STR_TYPE_NOT_CONVERT)); 446 throw ::com::sun::star::sdbc::SQLException( 447 sError, 448 NULL, 449 ::rtl::OUString::createFromAscii( "S1000" ), 450 1000, 451 ::com::sun::star::uno::Any() 452 ); 453 } 454 } 455 } 456 457 // ----------------------------------------------------------------------------- 458 OLEVariant::operator ::com::sun::star::uno::Sequence< sal_Int8 >() const 459 { 460 ::com::sun::star::uno::Sequence< sal_Int8 > aRet; 461 if(V_VT(this) == VT_BSTR) 462 { 463 OLEString sStr(V_BSTR(this)); 464 aRet = ::com::sun::star::uno::Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>((const wchar_t*)sStr),sizeof(sal_Unicode)*sStr.length()); 465 } 466 else if(!isNull()) 467 { 468 SAFEARRAY* pArray = getUI1SAFEARRAYPtr(); 469 470 if(pArray) 471 { 472 HRESULT hresult1,hresult2; 473 long lBound,uBound; 474 // Verify that the SafeArray is the proper shape. 475 hresult1 = ::SafeArrayGetLBound(pArray, 1, &lBound); 476 hresult2 = ::SafeArrayGetUBound(pArray, 1, &uBound); 477 if ( SUCCEEDED(hresult1) && SUCCEEDED(hresult2) ) 478 { 479 long nCount = uBound-lBound+1; 480 aRet.realloc(nCount); 481 sal_Int8* pData = aRet.getArray(); 482 for(long i=0; SUCCEEDED(hresult1) && lBound <= uBound ;++i,++lBound) 483 { 484 sal_Int32 nData = 0; 485 hresult1 = ::SafeArrayGetElement(pArray,&lBound,&nData); 486 if ( SUCCEEDED(hresult1) ) 487 { 488 *pData = static_cast<sal_Int8>(nData); 489 ++pData; 490 } 491 } 492 } 493 } 494 } 495 496 return aRet; 497 } 498 // ----------------------------------------------------------------------------- 499 ::rtl::OUString OLEVariant::getString() const 500 { 501 if(isNull()) 502 return ::rtl::OUString(); 503 else 504 return *this; 505 } 506 // ----------------------------------------------------------------------------- 507 sal_Bool OLEVariant::getBool() const 508 { 509 if (V_VT(this) == VT_BOOL) 510 return V_BOOL(this) == VARIANT_TRUE ? sal_True : sal_False; 511 if(isNull()) 512 return sal_False; 513 514 OLEVariant varDest; 515 516 varDest.ChangeType(VT_BOOL, this); 517 518 return V_BOOL(&varDest) == VARIANT_TRUE ? sal_True : sal_False; 519 } 520 // ----------------------------------------------------------------------------- 521 IUnknown* OLEVariant::getIUnknown() const 522 { 523 if (V_VT(this) == VT_UNKNOWN) 524 { 525 return V_UNKNOWN(this); 526 } 527 if(isNull()) 528 return NULL; 529 530 OLEVariant varDest; 531 532 varDest.ChangeType(VT_UNKNOWN, this); 533 534 V_UNKNOWN(&varDest)->AddRef(); 535 return V_UNKNOWN(&varDest); 536 } 537 // ----------------------------------------------------------------------------- 538 IDispatch* OLEVariant::getIDispatch() const 539 { 540 if (V_VT(this) == VT_DISPATCH) 541 { 542 return V_DISPATCH(this); 543 } 544 545 if(isNull()) 546 return NULL; 547 548 OLEVariant varDest; 549 550 varDest.ChangeType(VT_DISPATCH, this); 551 552 V_DISPATCH(&varDest)->AddRef(); 553 return V_DISPATCH(&varDest); 554 } 555 // ----------------------------------------------------------------------------- 556 sal_uInt8 OLEVariant::getByte() const 557 { 558 if (V_VT(this) == VT_UI1) 559 return V_UI1(this); 560 561 if(isNull()) 562 return sal_Int8(0); 563 OLEVariant varDest; 564 565 varDest.ChangeType(VT_UI1, this); 566 567 return V_UI1(&varDest); 568 } 569 // ----------------------------------------------------------------------------- 570 sal_Int16 OLEVariant::getInt16() const 571 { 572 if (V_VT(this) == VT_I2) 573 return V_I2(this); 574 575 if(isNull()) 576 return sal_Int16(0); 577 OLEVariant varDest; 578 579 varDest.ChangeType(VT_I2, this); 580 581 return V_I2(&varDest); 582 } 583 // ----------------------------------------------------------------------------- 584 sal_Int8 OLEVariant::getInt8() const 585 { 586 if (V_VT(this) == VT_I1) 587 return V_I1(this); 588 589 if(isNull()) 590 return sal_Int8(0); 591 592 OLEVariant varDest; 593 594 varDest.ChangeType(VT_I1, this); 595 596 return V_I1(&varDest); 597 } 598 // ----------------------------------------------------------------------------- 599 sal_Int32 OLEVariant::getInt32() const 600 { 601 if (V_VT(this) == VT_I4) 602 return V_I4(this); 603 604 if(isNull()) 605 return sal_Int32(0); 606 607 OLEVariant varDest; 608 609 varDest.ChangeType(VT_I4, this); 610 611 return V_I4(&varDest); 612 } 613 // ----------------------------------------------------------------------------- 614 sal_uInt32 OLEVariant::getUInt32() const 615 { 616 if (V_VT(this) == VT_UI4) 617 return V_UI4(this); 618 619 if(isNull()) 620 return sal_uInt32(0); 621 622 OLEVariant varDest; 623 624 varDest.ChangeType(VT_UI4, this); 625 626 return V_UI4(&varDest); 627 } 628 // ----------------------------------------------------------------------------- 629 float OLEVariant::getFloat() const 630 { 631 if (V_VT(this) == VT_R4) 632 return V_R4(this); 633 634 if(isNull()) 635 return float(0); 636 OLEVariant varDest; 637 638 varDest.ChangeType(VT_R4, this); 639 640 return V_R4(&varDest); 641 } 642 // ----------------------------------------------------------------------------- 643 double OLEVariant::getDouble() const 644 { 645 if (V_VT(this) == VT_R8) 646 return V_R8(this); 647 648 if(isNull()) 649 return double(0); 650 OLEVariant varDest; 651 652 varDest.ChangeType(VT_R8, this); 653 654 return V_R8(&varDest); 655 } 656 // ----------------------------------------------------------------------------- 657 double OLEVariant::getDate() const 658 { 659 if (V_VT(this) == VT_DATE) 660 return V_DATE(this); 661 662 if(isNull()) 663 return double(0); 664 OLEVariant varDest; 665 666 varDest.ChangeType(VT_DATE, this); 667 668 return V_DATE(&varDest); 669 } 670 // ----------------------------------------------------------------------------- 671 CY OLEVariant::getCurrency() const 672 { 673 if (V_VT(this) == VT_CY) 674 return V_CY(this); 675 676 if(isNull()) 677 { 678 CY aVar; 679 aVar.int64 = sal_Int64(0); 680 return aVar; 681 } 682 OLEVariant varDest; 683 684 varDest.ChangeType(VT_CY, this); 685 686 return V_CY(&varDest); 687 } 688 // ----------------------------------------------------------------------------- 689 SAFEARRAY* OLEVariant::getUI1SAFEARRAYPtr() const 690 { 691 if (V_VT(this) == (VT_ARRAY|VT_UI1)) 692 return V_ARRAY(this); 693 694 if(isNull()) 695 return (0); 696 OLEVariant varDest; 697 698 varDest.ChangeType((VT_ARRAY|VT_UI1), this); 699 700 return V_ARRAY(&varDest); 701 } 702 // ----------------------------------------------------------------------------- 703 ::com::sun::star::uno::Any OLEVariant::makeAny() const 704 { 705 ::com::sun::star::uno::Any aValue; 706 switch (V_VT(this)) 707 { 708 case VT_EMPTY: 709 case VT_NULL: 710 aValue.setValue(NULL, Type()); 711 break; 712 case VT_I2: 713 aValue.setValue( & iVal, getCppuType( (sal_Int16*)0)); 714 break; 715 case VT_I4: 716 aValue.setValue( & lVal, getCppuType( (sal_Int32*)0)); 717 break; 718 case VT_R4: 719 aValue.setValue( & fltVal, getCppuType( (float*)0)); 720 break; 721 case VT_R8: 722 aValue.setValue(& dblVal, getCppuType( (double*)0)); 723 break; 724 case VT_CY: 725 { 726 Currency cy(cyVal.int64); 727 aValue <<= cy; 728 break; 729 } 730 case VT_DATE: 731 { 732 aValue <<= (::com::sun::star::util::Date)*this; 733 break; 734 } 735 case VT_BSTR: 736 { 737 OUString b(reinterpret_cast<const sal_Unicode*>(bstrVal)); 738 aValue.setValue( &b, getCppuType( &b)); 739 break; 740 } 741 case VT_BOOL: 742 { 743 sal_Bool b= boolVal == VARIANT_TRUE; 744 aValue.setValue( &b, getCppuType( &b)); 745 break; 746 } 747 case VT_I1: 748 aValue.setValue( & cVal, getCppuType((sal_Int8*)0)); 749 break; 750 case VT_UI1: // there is no unsigned char in UNO 751 aValue.setValue( & bVal, getCppuType( (sal_Int8*)0)); 752 break; 753 case VT_UI2: 754 aValue.setValue( & uiVal, getCppuType( (sal_uInt16*)0)); 755 break; 756 case VT_UI4: 757 aValue.setValue( & ulVal, getCppuType( (sal_uInt32*)0)); 758 break; 759 case VT_INT: 760 aValue.setValue( & intVal, getCppuType( (sal_Int32*)0)); 761 break; 762 case VT_UINT: 763 aValue.setValue( & uintVal, getCppuType( (sal_uInt32*)0)); 764 break; 765 case VT_VOID: 766 aValue.setValue( NULL, Type()); 767 break; 768 case VT_DECIMAL: 769 { 770 Decimal dec; 771 dec.Scale = decVal.scale; 772 dec.Sign = decVal.sign; 773 dec.LowValue = decVal.Lo32; 774 dec.MiddleValue = decVal.Mid32; 775 dec.HighValue = decVal.Hi32; 776 aValue <<= dec; 777 break; 778 } 779 780 default: 781 break; 782 } 783 return aValue; 784 } 785 // ----------------------------------------------------------------------------- 786 // ----------------------------------------------------------------------------- 787 // ----------------------------------------------------------------------------- 788