| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_connectivity.hxx" |
| #include "ado/Aolevariant.hxx" |
| #include "connectivity/dbconversion.hxx" |
| #include <com/sun/star/sdbc/SQLException.hpp> |
| #include <com/sun/star/util/Time.hpp> |
| #include <com/sun/star/util/Date.hpp> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include "diagnose_ex.h" |
| #include "resource/sharedresources.hxx" |
| #include "resource/ado_res.hrc" |
| #include "com/sun/star/bridge/oleautomation/Date.hpp" |
| #include "com/sun/star/bridge/oleautomation/Currency.hpp" |
| #include "com/sun/star/bridge/oleautomation/SCode.hpp" |
| #include "com/sun/star/bridge/oleautomation/Decimal.hpp" |
| |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::bridge::oleautomation; |
| using namespace connectivity::ado; |
| using ::rtl::OUString; |
| |
| OLEString::OLEString() |
| :m_sStr(NULL) |
| { |
| } |
| OLEString::OLEString(const BSTR& _sBStr) |
| :m_sStr(_sBStr) |
| { |
| } |
| OLEString::OLEString(const ::rtl::OUString& _sBStr) |
| { |
| m_sStr = ::SysAllocString(reinterpret_cast<LPCOLESTR>(_sBStr.getStr())); |
| } |
| OLEString::~OLEString() |
| { |
| if(m_sStr) |
| ::SysFreeString(m_sStr); |
| } |
| OLEString& OLEString::operator=(const ::rtl::OUString& _rSrc) |
| { |
| if(m_sStr) |
| ::SysFreeString(m_sStr); |
| m_sStr = ::SysAllocString(reinterpret_cast<LPCOLESTR>(_rSrc.getStr())); |
| return *this; |
| } |
| OLEString& OLEString::operator=(const OLEString& _rSrc) |
| { |
| if(this != &_rSrc) |
| { |
| if(m_sStr) |
| ::SysFreeString(m_sStr); |
| m_sStr = ::SysAllocString(_rSrc.m_sStr); |
| } |
| return *this; |
| } |
| OLEString& OLEString::operator=(const BSTR& _rSrc) |
| { |
| if(m_sStr) |
| ::SysFreeString(m_sStr); |
| m_sStr = _rSrc; |
| return *this; |
| } |
| OLEString::operator ::rtl::OUString() const |
| { |
| return (m_sStr != NULL) ? ::rtl::OUString(reinterpret_cast<const sal_Unicode*>(LPCOLESTR(m_sStr)),::SysStringLen(m_sStr)) : ::rtl::OUString(); |
| } |
| OLEString::operator BSTR() const |
| { |
| return m_sStr; |
| } |
| BSTR* OLEString::operator &() |
| { |
| return &m_sStr; |
| } |
| sal_Int32 OLEString::length() const |
| { |
| return (m_sStr != NULL) ? ::SysStringLen(m_sStr) : 0; |
| } |
| |
| OLEVariant::OLEVariant() |
| { |
| VariantInit(this); |
| } |
| OLEVariant::OLEVariant(const VARIANT& varSrc) |
| { |
| ::VariantInit(this); |
| HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(&varSrc)); |
| OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); |
| OSL_UNUSED(eRet); |
| } |
| OLEVariant::OLEVariant(const OLEVariant& varSrc) |
| { |
| ::VariantInit(this); |
| HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))); |
| OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); |
| OSL_UNUSED(eRet); |
| } |
| |
| OLEVariant::OLEVariant(sal_Bool x) { VariantInit(this); vt = VT_BOOL; boolVal = (x ? VARIANT_TRUE : VARIANT_FALSE);} |
| OLEVariant::OLEVariant(sal_Int8 n) { VariantInit(this); vt = VT_I1; bVal = n;} |
| OLEVariant::OLEVariant(sal_Int16 n) { VariantInit(this); vt = VT_I2; intVal = n;} |
| OLEVariant::OLEVariant(sal_Int32 n) { VariantInit(this); vt = VT_I4; lVal = n;} |
| OLEVariant::OLEVariant(sal_Int64 x) { VariantInit(this); vt = VT_I4; lVal = (LONG)x;} |
| |
| OLEVariant::OLEVariant(const rtl::OUString& us) |
| { |
| ::VariantInit(this); |
| vt = VT_BSTR; |
| bstrVal = SysAllocString(reinterpret_cast<LPCOLESTR>(us.getStr())); |
| } |
| OLEVariant::~OLEVariant() |
| { |
| HRESULT eRet = ::VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| } // clears all the memory that was allocated before |
| |
| OLEVariant::OLEVariant(const ::com::sun::star::util::Date& x ) |
| { |
| VariantInit(this); |
| vt = VT_DATE; |
| dblVal = ::dbtools::DBTypeConversion::toDouble(x,::com::sun::star::util::Date(30,12,1899)); |
| } |
| OLEVariant::OLEVariant(const ::com::sun::star::util::Time& x ) |
| { |
| VariantInit(this); |
| vt = VT_DATE; |
| dblVal = ::dbtools::DBTypeConversion::toDouble(x); |
| } |
| OLEVariant::OLEVariant(const ::com::sun::star::util::DateTime& x ) |
| { |
| VariantInit(this); |
| vt = VT_DATE; |
| dblVal = ::dbtools::DBTypeConversion::toDouble(x,::com::sun::star::util::Date(30,12,1899)); |
| } |
| OLEVariant::OLEVariant(const float &x) |
| { |
| VariantInit(this); |
| vt = VT_R4; |
| fltVal = x; |
| } |
| OLEVariant::OLEVariant(const double &x) |
| { |
| VariantInit(this); |
| vt = VT_R8; |
| dblVal = x; |
| } |
| |
| |
| OLEVariant::OLEVariant(IDispatch* pDispInterface) |
| { |
| VariantInit(this); |
| setIDispatch( pDispInterface ); |
| } |
| |
| OLEVariant::OLEVariant(const ::com::sun::star::uno::Sequence< sal_Int8 >& x) |
| { |
| VariantInit(this); |
| |
| vt = VT_ARRAY|VT_UI1; |
| |
| SAFEARRAYBOUND rgsabound[1]; |
| rgsabound[0].lLbound = 0; |
| rgsabound[0].cElements = x.getLength(); |
| // parray = SafeArrayCreate(VT_UI1,1,rgsabound); |
| parray = SafeArrayCreateVector(VT_UI1, 0, x.getLength()); |
| const sal_Int8* pBegin = x.getConstArray(); |
| const sal_Int8* pEnd = pBegin + x.getLength(); |
| |
| for(sal_Int32 i=0;pBegin != pEnd;++i,++pBegin) |
| { |
| sal_Int32 nData = *pBegin; |
| HRESULT rs = SafeArrayPutElement(parray,&i,&nData); |
| OSL_ENSURE(S_OK == rs,"Error while copy byte data"); |
| OSL_UNUSED(rs); |
| } |
| } |
| // |
| OLEVariant& OLEVariant::operator=(const OLEVariant& varSrc) |
| { |
| HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))); |
| OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); |
| OSL_UNUSED(eRet); |
| return *this; |
| } |
| // Assign a const VARIANT& (::VariantCopy handles everything) |
| // |
| OLEVariant& OLEVariant::operator=(const tagVARIANT& varSrc) |
| { |
| HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(&varSrc)); |
| OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); |
| OSL_UNUSED(eRet); |
| |
| return *this; |
| } |
| |
| // Assign a const VARIANT* (::VariantCopy handles everything) |
| // |
| OLEVariant& OLEVariant::operator=(const VARIANT* pSrc) |
| { |
| HRESULT eRet = ::VariantCopy(this, const_cast<VARIANT*>(pSrc)); |
| OSL_ENSURE(eRet == S_OK,"Error while copying an ado variant!"); |
| OSL_UNUSED(eRet); |
| |
| return *this; |
| } |
| |
| void OLEVariant::setByte(sal_uInt8 n) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_UI1; |
| bVal = n; |
| } |
| void OLEVariant::setInt16(sal_Int16 n) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_I2; |
| iVal = n; |
| } |
| void OLEVariant::setInt32(sal_Int32 n) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_I4; |
| lVal = n; |
| } |
| void OLEVariant::setFloat(float f) |
| { HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_R4; |
| fltVal = f; |
| } |
| void OLEVariant::setDouble(double d) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_R8; |
| dblVal = d; |
| } |
| void OLEVariant::setDate(DATE d) |
| { HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_DATE; |
| date = d; |
| } |
| void OLEVariant::setChar(unsigned char a) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_UI1; |
| bVal = a; |
| } |
| void OLEVariant::setCurrency(double aCur) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_CY; |
| set(aCur*10000); |
| } |
| void OLEVariant::setBool(sal_Bool b) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_BOOL; |
| boolVal = b ? VARIANT_TRUE : VARIANT_FALSE; |
| } |
| void OLEVariant::setString(const rtl::OUString& us) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_BSTR; |
| bstrVal = ::SysAllocString(reinterpret_cast<LPCOLESTR>(us.getStr())); |
| } |
| void OLEVariant::setNoArg() |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_ERROR; |
| scode = DISP_E_PARAMNOTFOUND; |
| } |
| |
| void OLEVariant::setNull() |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_NULL; |
| } |
| void OLEVariant::setEmpty() |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_EMPTY; |
| } |
| |
| void OLEVariant::setUI1SAFEARRAYPtr(SAFEARRAY* pSafeAr) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = VT_ARRAY|VT_UI1; parray = pSafeAr; |
| } |
| |
| void OLEVariant::setArray(SAFEARRAY* pSafeArray, VARTYPE vtType) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| vt = (VARTYPE)(VT_ARRAY|vtType); |
| parray = pSafeArray; |
| } |
| |
| void OLEVariant::setIDispatch(IDispatch* pDispInterface) |
| { |
| HRESULT eRet = VariantClear(this); |
| OSL_ENSURE(eRet == S_OK,"Error while clearing an ado variant!"); |
| OSL_UNUSED(eRet); |
| |
| vt = VT_DISPATCH; |
| pdispVal = pDispInterface; |
| |
| if ( pDispInterface ) |
| pDispInterface->AddRef(); |
| } |
| |
| |
| sal_Bool OLEVariant::isNull() const { return (vt == VT_NULL); } |
| sal_Bool OLEVariant::isEmpty() const { return (vt == VT_EMPTY); } |
| |
| VARTYPE OLEVariant::getType() const { return vt; } |
| |
| OLEVariant::operator ::com::sun::star::util::Date() const |
| { |
| return isNull() ? ::com::sun::star::util::Date(30,12,1899) : ::dbtools::DBTypeConversion::toDate(getDate(),::com::sun::star::util::Date(30,12,1899)); |
| } |
| OLEVariant::operator ::com::sun::star::util::Time() const |
| { |
| return isNull() ? ::com::sun::star::util::Time() : ::dbtools::DBTypeConversion::toTime(getDate()); |
| } |
| OLEVariant::operator ::com::sun::star::util::DateTime()const |
| { |
| return isNull() ? ::com::sun::star::util::DateTime() : ::dbtools::DBTypeConversion::toDateTime(getDate(),::com::sun::star::util::Date(30,12,1899)); |
| } |
| |
| VARIANT_BOOL OLEVariant::VariantBool(sal_Bool bEinBoolean) |
| { |
| return (bEinBoolean ? VARIANT_TRUE : VARIANT_FALSE); |
| } |
| |
| void OLEVariant::CHS() |
| { |
| cyVal.Lo ^= (sal_uInt32)-1; |
| cyVal.Hi ^= -1; |
| cyVal.Lo++; |
| if( !cyVal.Lo ) |
| cyVal.Hi++; |
| } |
| |
| void OLEVariant::set(double n) |
| { |
| if( n >= 0 ) |
| { |
| cyVal.Hi = (sal_Int32)(n / (double)4294967296.0); |
| cyVal.Lo = (sal_uInt32)(n - ((double)cyVal.Hi * (double)4294967296.0)); |
| } |
| else { |
| cyVal.Hi = (sal_Int32)(-n / (double)4294967296.0); |
| cyVal.Lo = (sal_uInt32)(-n - ((double)cyVal.Hi * (double)4294967296.0)); |
| CHS(); |
| } |
| } |
| |
| OLEVariant::operator rtl::OUString() const |
| { |
| if (V_VT(this) == VT_BSTR) |
| return reinterpret_cast<const sal_Unicode*>(LPCOLESTR(V_BSTR(this))); |
| |
| if(isNull()) |
| return ::rtl::OUString(); |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_BSTR, this); |
| |
| return reinterpret_cast<const sal_Unicode*>(LPCOLESTR(V_BSTR(&varDest))); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void OLEVariant::ChangeType(VARTYPE vartype, const OLEVariant* pSrc) |
| { |
| // |
| // If pDest is NULL, convert type in place |
| // |
| if (pSrc == NULL) |
| pSrc = this; |
| |
| if ( ( this != pSrc ) |
| || ( vartype != V_VT( this ) ) |
| ) |
| { |
| if ( FAILED( ::VariantChangeType( static_cast< VARIANT* >( this ), |
| const_cast< VARIANT* >( static_cast< const VARIANT* >( pSrc ) ), |
| 0, |
| vartype ) ) ) |
| { |
| ::connectivity::SharedResources aResources; |
| const ::rtl::OUString sError( aResources.getResourceString(STR_TYPE_NOT_CONVERT)); |
| throw ::com::sun::star::sdbc::SQLException( |
| sError, |
| NULL, |
| ::rtl::OUString::createFromAscii( "S1000" ), |
| 1000, |
| ::com::sun::star::uno::Any() |
| ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| OLEVariant::operator ::com::sun::star::uno::Sequence< sal_Int8 >() const |
| { |
| ::com::sun::star::uno::Sequence< sal_Int8 > aRet; |
| if(V_VT(this) == VT_BSTR) |
| { |
| OLEString sStr(V_BSTR(this)); |
| aRet = ::com::sun::star::uno::Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>((const wchar_t*)sStr),sizeof(sal_Unicode)*sStr.length()); |
| } |
| else if(!isNull()) |
| { |
| SAFEARRAY* pArray = getUI1SAFEARRAYPtr(); |
| |
| if(pArray) |
| { |
| HRESULT hresult1,hresult2; |
| long lBound,uBound; |
| // Verify that the SafeArray is the proper shape. |
| hresult1 = ::SafeArrayGetLBound(pArray, 1, &lBound); |
| hresult2 = ::SafeArrayGetUBound(pArray, 1, &uBound); |
| if ( SUCCEEDED(hresult1) && SUCCEEDED(hresult2) ) |
| { |
| long nCount = uBound-lBound+1; |
| aRet.realloc(nCount); |
| sal_Int8* pData = aRet.getArray(); |
| for(long i=0; SUCCEEDED(hresult1) && lBound <= uBound ;++i,++lBound) |
| { |
| sal_Int32 nData = 0; |
| hresult1 = ::SafeArrayGetElement(pArray,&lBound,&nData); |
| if ( SUCCEEDED(hresult1) ) |
| { |
| *pData = static_cast<sal_Int8>(nData); |
| ++pData; |
| } |
| } |
| } |
| } |
| } |
| |
| return aRet; |
| } |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString OLEVariant::getString() const |
| { |
| if(isNull()) |
| return ::rtl::OUString(); |
| else |
| return *this; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OLEVariant::getBool() const |
| { |
| if (V_VT(this) == VT_BOOL) |
| return V_BOOL(this) == VARIANT_TRUE ? sal_True : sal_False; |
| if(isNull()) |
| return sal_False; |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_BOOL, this); |
| |
| return V_BOOL(&varDest) == VARIANT_TRUE ? sal_True : sal_False; |
| } |
| // ----------------------------------------------------------------------------- |
| IUnknown* OLEVariant::getIUnknown() const |
| { |
| if (V_VT(this) == VT_UNKNOWN) |
| { |
| return V_UNKNOWN(this); |
| } |
| if(isNull()) |
| return NULL; |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_UNKNOWN, this); |
| |
| V_UNKNOWN(&varDest)->AddRef(); |
| return V_UNKNOWN(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| IDispatch* OLEVariant::getIDispatch() const |
| { |
| if (V_VT(this) == VT_DISPATCH) |
| { |
| return V_DISPATCH(this); |
| } |
| |
| if(isNull()) |
| return NULL; |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_DISPATCH, this); |
| |
| V_DISPATCH(&varDest)->AddRef(); |
| return V_DISPATCH(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_uInt8 OLEVariant::getByte() const |
| { |
| if (V_VT(this) == VT_UI1) |
| return V_UI1(this); |
| |
| if(isNull()) |
| return sal_Int8(0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_UI1, this); |
| |
| return V_UI1(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Int16 OLEVariant::getInt16() const |
| { |
| if (V_VT(this) == VT_I2) |
| return V_I2(this); |
| |
| if(isNull()) |
| return sal_Int16(0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_I2, this); |
| |
| return V_I2(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Int8 OLEVariant::getInt8() const |
| { |
| if (V_VT(this) == VT_I1) |
| return V_I1(this); |
| |
| if(isNull()) |
| return sal_Int8(0); |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_I1, this); |
| |
| return V_I1(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Int32 OLEVariant::getInt32() const |
| { |
| if (V_VT(this) == VT_I4) |
| return V_I4(this); |
| |
| if(isNull()) |
| return sal_Int32(0); |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_I4, this); |
| |
| return V_I4(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_uInt32 OLEVariant::getUInt32() const |
| { |
| if (V_VT(this) == VT_UI4) |
| return V_UI4(this); |
| |
| if(isNull()) |
| return sal_uInt32(0); |
| |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_UI4, this); |
| |
| return V_UI4(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| float OLEVariant::getFloat() const |
| { |
| if (V_VT(this) == VT_R4) |
| return V_R4(this); |
| |
| if(isNull()) |
| return float(0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_R4, this); |
| |
| return V_R4(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| double OLEVariant::getDouble() const |
| { |
| if (V_VT(this) == VT_R8) |
| return V_R8(this); |
| |
| if(isNull()) |
| return double(0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_R8, this); |
| |
| return V_R8(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| double OLEVariant::getDate() const |
| { |
| if (V_VT(this) == VT_DATE) |
| return V_DATE(this); |
| |
| if(isNull()) |
| return double(0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_DATE, this); |
| |
| return V_DATE(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| CY OLEVariant::getCurrency() const |
| { |
| if (V_VT(this) == VT_CY) |
| return V_CY(this); |
| |
| if(isNull()) |
| { |
| CY aVar; |
| aVar.int64 = sal_Int64(0); |
| return aVar; |
| } |
| OLEVariant varDest; |
| |
| varDest.ChangeType(VT_CY, this); |
| |
| return V_CY(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| SAFEARRAY* OLEVariant::getUI1SAFEARRAYPtr() const |
| { |
| if (V_VT(this) == (VT_ARRAY|VT_UI1)) |
| return V_ARRAY(this); |
| |
| if(isNull()) |
| return (0); |
| OLEVariant varDest; |
| |
| varDest.ChangeType((VT_ARRAY|VT_UI1), this); |
| |
| return V_ARRAY(&varDest); |
| } |
| // ----------------------------------------------------------------------------- |
| ::com::sun::star::uno::Any OLEVariant::makeAny() const |
| { |
| ::com::sun::star::uno::Any aValue; |
| switch (V_VT(this)) |
| { |
| case VT_EMPTY: |
| case VT_NULL: |
| aValue.setValue(NULL, Type()); |
| break; |
| case VT_I2: |
| aValue.setValue( & iVal, getCppuType( (sal_Int16*)0)); |
| break; |
| case VT_I4: |
| aValue.setValue( & lVal, getCppuType( (sal_Int32*)0)); |
| break; |
| case VT_R4: |
| aValue.setValue( & fltVal, getCppuType( (float*)0)); |
| break; |
| case VT_R8: |
| aValue.setValue(& dblVal, getCppuType( (double*)0)); |
| break; |
| case VT_CY: |
| { |
| Currency cy(cyVal.int64); |
| aValue <<= cy; |
| break; |
| } |
| case VT_DATE: |
| { |
| aValue <<= (::com::sun::star::util::Date)*this; |
| break; |
| } |
| case VT_BSTR: |
| { |
| OUString b(reinterpret_cast<const sal_Unicode*>(bstrVal)); |
| aValue.setValue( &b, getCppuType( &b)); |
| break; |
| } |
| case VT_BOOL: |
| { |
| sal_Bool b= boolVal == VARIANT_TRUE; |
| aValue.setValue( &b, getCppuType( &b)); |
| break; |
| } |
| case VT_I1: |
| aValue.setValue( & cVal, getCppuType((sal_Int8*)0)); |
| break; |
| case VT_UI1: // there is no unsigned char in UNO |
| aValue.setValue( & bVal, getCppuType( (sal_Int8*)0)); |
| break; |
| case VT_UI2: |
| aValue.setValue( & uiVal, getCppuType( (sal_uInt16*)0)); |
| break; |
| case VT_UI4: |
| aValue.setValue( & ulVal, getCppuType( (sal_uInt32*)0)); |
| break; |
| case VT_INT: |
| aValue.setValue( & intVal, getCppuType( (sal_Int32*)0)); |
| break; |
| case VT_UINT: |
| aValue.setValue( & uintVal, getCppuType( (sal_uInt32*)0)); |
| break; |
| case VT_VOID: |
| aValue.setValue( NULL, Type()); |
| break; |
| case VT_DECIMAL: |
| { |
| Decimal dec; |
| dec.Scale = decVal.scale; |
| dec.Sign = decVal.sign; |
| dec.LowValue = decVal.Lo32; |
| dec.MiddleValue = decVal.Mid32; |
| dec.HighValue = decVal.Hi32; |
| aValue <<= dec; |
| break; |
| } |
| |
| default: |
| break; |
| } |
| return aValue; |
| } |
| // ----------------------------------------------------------------------------- |
| // ----------------------------------------------------------------------------- |
| // ----------------------------------------------------------------------------- |