| /************************************************************** |
| * |
| * 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_comphelper.hxx" |
| #include <comphelper/types.hxx> |
| #include <comphelper/extract.hxx> |
| #include <com/sun/star/util/Date.hpp> |
| #include <com/sun/star/util/Time.hpp> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <com/sun/star/awt/FontUnderline.hpp> |
| #include <com/sun/star/awt/FontStrikeout.hpp> |
| #include <com/sun/star/awt/FontDescriptor.hpp> |
| #include <osl/diagnose.h> |
| #include <typelib/typedescription.hxx> |
| |
| #include <memory.h> |
| |
| |
| //......................................................................... |
| namespace comphelper |
| { |
| //......................................................................... |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::awt; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::lang; |
| |
| //------------------------------------------------------------------------- |
| sal_Bool operator ==(const DateTime& _rLeft, const DateTime& _rRight) |
| { |
| return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) && |
| ( _rLeft.Seconds == _rRight.Seconds) && |
| ( _rLeft.Minutes == _rRight.Minutes) && |
| ( _rLeft.Hours == _rRight.Hours) && |
| ( _rLeft.Day == _rRight.Day) && |
| ( _rLeft.Month == _rRight.Month) && |
| ( _rLeft.Year == _rRight.Year) ; |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool operator ==(const Date& _rLeft, const Date& _rRight) |
| { |
| return ( _rLeft.Day == _rRight.Day) && |
| ( _rLeft.Month == _rRight.Month) && |
| ( _rLeft.Year == _rRight.Year) ; |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool operator ==(const Time& _rLeft, const Time& _rRight) |
| { |
| return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) && |
| ( _rLeft.Seconds == _rRight.Seconds) && |
| ( _rLeft.Minutes == _rRight.Minutes) && |
| ( _rLeft.Hours == _rRight.Hours) ; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int32 getINT32(const Any& _rAny) |
| { |
| sal_Int32 nReturn = 0; |
| OSL_VERIFY( _rAny >>= nReturn ); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int16 getINT16(const Any& _rAny) |
| { |
| sal_Int16 nReturn = 0; |
| OSL_VERIFY( _rAny >>= nReturn ); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| double getDouble(const Any& _rAny) |
| { |
| double nReturn = 0.0; |
| OSL_VERIFY( _rAny >>= nReturn ); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| float getFloat(const Any& _rAny) |
| { |
| float nReturn = 0.0; |
| OSL_VERIFY( _rAny >>= nReturn ); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| ::rtl::OUString getString(const Any& _rAny) |
| { |
| ::rtl::OUString nReturn; |
| OSL_VERIFY( _rAny >>= nReturn ); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool getBOOL(const Any& _rAny) |
| { |
| sal_Bool nReturn = sal_False; |
| if (_rAny.getValueType() == ::getCppuBooleanType()) |
| nReturn = *(sal_Bool*)_rAny.getValue(); |
| else |
| OSL_ENSURE(sal_False, "comphelper::getBOOL : invalid argument !"); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException) |
| { |
| sal_Int32 nReturn = 0; |
| if (! ::cppu::enum2int(nReturn,_rAny) ) |
| throw IllegalArgumentException(); |
| return nReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| FontDescriptor getDefaultFont() |
| { |
| FontDescriptor aReturn; |
| aReturn.Slant = FontSlant_DONTKNOW; |
| aReturn.Underline = FontUnderline::DONTKNOW; |
| aReturn.Strikeout = FontStrikeout::DONTKNOW; |
| return aReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom) |
| { |
| // getthe type lib descriptions |
| typelib_TypeDescription* pAssignable = NULL; |
| _rAssignable.getDescription(&pAssignable); |
| |
| typelib_TypeDescription* pFrom = NULL; |
| _rFrom.getDescription(&pFrom); |
| |
| // and ask the type lib |
| return typelib_typedescription_isAssignableFrom(pAssignable, pFrom); |
| } |
| |
| //------------------------------------------------------------------ |
| template<class TYPE> |
| sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, TYPE& _rOut) |
| { |
| sal_Bool bSuccess = _rValue >>= _rOut; |
| _bIdentical = bSuccess && (_rOut == *reinterpret_cast<const TYPE*>(_pData)); |
| return bSuccess; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, sal_Unicode& _rOut) |
| { |
| sal_Bool bSuccess = ( _rValue.getValueTypeClass() == TypeClass_CHAR ); |
| if ( bSuccess ) |
| _rOut = *static_cast< const sal_Unicode* >( _rValue.getValue() ); |
| _bIdentical = bSuccess && ( _rOut == *static_cast< const sal_Unicode* >( _pData ) ); |
| return bSuccess; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_Bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue) |
| { |
| sal_Bool bRes = sal_True; |
| |
| if (_rType.getTypeClass() == TypeClass_ANY) |
| { |
| // beides AnyWerte |
| if (_rValue.getValueType().getTypeClass() == TypeClass_ANY) |
| bRes = compare_impl( |
| reinterpret_cast<const Any*>(pData)->getValueType(), |
| reinterpret_cast<const Any*>(pData)->getValue(), |
| *reinterpret_cast<const Any*>(_rValue.getValue())); |
| else |
| bRes = compare_impl( |
| reinterpret_cast<const Any*>(pData)->getValueType(), |
| reinterpret_cast<const Any*>(pData)->getValue(), |
| _rValue); |
| } |
| else if ( (_rType.getTypeClass() == TypeClass_VOID) |
| || (_rValue.getValueType().getTypeClass() == TypeClass_VOID) |
| ) |
| { |
| bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass(); |
| } |
| else |
| { |
| sal_Bool bConversionSuccess = sal_False; |
| switch (_rType.getTypeClass()) |
| { |
| case TypeClass_VOID: |
| bConversionSuccess = sal_True; |
| bRes = _rValue.getValueType().getTypeClass() == TypeClass_VOID; |
| break; |
| case TypeClass_BOOLEAN: |
| { |
| sal_Bool aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_CHAR: |
| { |
| sal_Unicode aDummy(0); |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_STRING: |
| { |
| ::rtl::OUString aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_FLOAT: |
| { |
| float aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_DOUBLE: |
| { |
| double aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_BYTE: |
| { |
| sal_Int8 aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_SHORT: |
| { |
| sal_Int16 aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_ENUM: |
| { |
| sal_Int32 nAsInt32 = 0; |
| bConversionSuccess = ::cppu::enum2int(nAsInt32, _rValue); |
| bRes = bConversionSuccess && (nAsInt32== *reinterpret_cast<const sal_Int32*>(pData)); |
| break; |
| } |
| case TypeClass_LONG: |
| { |
| sal_Int32 aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_UNSIGNED_SHORT: |
| { |
| sal_uInt16 aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_UNSIGNED_LONG: |
| { |
| sal_uInt32 aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_INTERFACE: |
| { |
| InterfaceRef aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| case TypeClass_STRUCT: |
| if (isA(_rType, static_cast<FontDescriptor*>(NULL))) |
| { |
| FontDescriptor aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| bRes = *(FontDescriptor*)pData == aTemp; |
| } |
| else |
| bRes = sal_False; |
| break; |
| } |
| if (isA(_rType, static_cast<Date*>(NULL))) |
| { |
| Date aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| if (isA(_rType, static_cast<Time*>(NULL))) |
| { |
| Time aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| if (isA(_rType, static_cast<DateTime*>(NULL))) |
| { |
| DateTime aDummy; |
| bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy); |
| break; |
| } |
| break; |
| case TypeClass_SEQUENCE: |
| if (isA(_rType, static_cast< Sequence<sal_Int8>* >(NULL))) |
| { |
| Sequence<sal_Int8> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_Int8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int8>*>(pData); |
| const Sequence<sal_Int8>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence<sal_uInt8>* >(NULL))) |
| { |
| Sequence<sal_uInt8> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_uInt8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt8>*>(pData); |
| const Sequence<sal_uInt8>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL))) |
| { |
| Sequence<sal_Int16> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_Int16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int16>*>(pData); |
| const Sequence<sal_Int16>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence<sal_uInt16>* >(NULL))) |
| { |
| Sequence<sal_uInt16> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_uInt16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt16>*>(pData); |
| const Sequence<sal_uInt16>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt16)) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence<sal_Int32>* >(NULL))) |
| { |
| Sequence<sal_Int32> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_Int32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int32>*>(pData); |
| const Sequence<sal_Int32>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int32)) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence<sal_uInt32>* >(NULL))) |
| { |
| Sequence<sal_uInt32> aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence<sal_uInt32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt32>*>(pData); |
| const Sequence<sal_uInt32>& rRightSeq = aTemp; |
| bRes = rLeftSeq.getLength() == rRightSeq.getLength() && |
| memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt32)) == 0; |
| } |
| } |
| else if (isA(_rType, static_cast< Sequence< ::rtl::OUString >* >(NULL))) |
| { |
| Sequence< ::rtl::OUString > aTemp; |
| bConversionSuccess = _rValue >>= aTemp; |
| if (bConversionSuccess) |
| { |
| const Sequence< ::rtl::OUString >& rLeftSeq = *reinterpret_cast<const Sequence< ::rtl::OUString>*>(pData); |
| const Sequence< ::rtl::OUString >& rRightSeq = aTemp; |
| sal_Int32 nSeqLen = rLeftSeq.getLength(); |
| bRes = ( nSeqLen == rRightSeq.getLength() ); |
| for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ ) |
| { |
| const ::rtl::OUString& rS1 = rLeftSeq.getConstArray()[n]; |
| const ::rtl::OUString& rS2 = rRightSeq.getConstArray()[n]; |
| bRes = ( rS1 == rS2 ); |
| } |
| } |
| } |
| break; |
| default: |
| bRes = sal_False; |
| } |
| |
| bRes = bRes && bConversionSuccess; |
| } |
| return bRes; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool compare(const Any& rLeft, const Any& rRight) |
| { |
| return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight); |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight) |
| { |
| return ( _rLeft.Name.equals( _rRight.Name ) ) && |
| ( _rLeft.Height == _rRight.Height ) && |
| ( _rLeft.Width == _rRight.Width ) && |
| ( _rLeft.StyleName.equals( _rRight.StyleName ) ) && |
| ( _rLeft.Family == _rRight.Family ) && |
| ( _rLeft.CharSet == _rRight.CharSet ) && |
| ( _rLeft.Pitch == _rRight.Pitch ) && |
| ( _rLeft.CharacterWidth == _rRight.CharacterWidth ) && |
| ( _rLeft.Weight == _rRight.Weight ) && |
| ( _rLeft.Slant == _rRight.Slant ) && |
| ( _rLeft.Underline == _rRight.Underline ) && |
| ( _rLeft.Strikeout == _rRight.Strikeout ) && |
| ( _rLeft.Orientation == _rRight.Orientation ) && |
| ( _rLeft.Kerning == _rRight.Kerning ) && |
| ( _rLeft.WordLineMode == _rRight.WordLineMode ) && |
| ( _rLeft.Type == _rRight.Type ) ; |
| } |
| |
| //------------------------------------------------------------------------- |
| Type getSequenceElementType(const Type& _rSequenceType) |
| { |
| OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE, |
| "getSequenceElementType: must be called with a sequence type!"); |
| |
| if (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE)) |
| return Type(); |
| |
| TypeDescription aTD(_rSequenceType); |
| typelib_IndirectTypeDescription* pSequenceTD = |
| reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get()); |
| |
| OSL_ASSERT(pSequenceTD); |
| OSL_ASSERT(pSequenceTD->pType); |
| |
| if (pSequenceTD && pSequenceTD->pType) |
| return Type(pSequenceTD->pType); |
| |
| return Type(); |
| } |
| //......................................................................... |
| } // namespace comphelper |
| //......................................................................... |
| |
