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