connectivity/source/drivers/ado/Aolevariant.cxx

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