connectivity/source/drivers/ado/Aolevariant.cxx

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