comphelper/source/misc/types.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 <comphelper/types.hxx>
  21 #include <comphelper/extract.hxx>
  22 #include <com/sun/star/util/Date.hpp>
  23 #include <com/sun/star/util/Time.hpp>
  24 #include <com/sun/star/util/DateTime.hpp>
  25 #include <com/sun/star/awt/FontUnderline.hpp>
  26 #include <com/sun/star/awt/FontStrikeout.hpp>
  27 #include <com/sun/star/awt/FontDescriptor.hpp>
  28 #include <osl/diagnose.h>
  29 #include <typelib/typedescription.hxx>
  30
  31 #include <memory.h>
  32
  33
  34
  35 namespace comphelper
  36 {
  37
  38
  39 using namespace ::com::sun::star::uno;
  40 using namespace ::com::sun::star::awt;
  41 using namespace ::com::sun::star::util;
  42 using namespace ::com::sun::star::lang;
  43
  44
  45 bool operator ==(const DateTime& _rLeft, const DateTime& _rRight)
  46 {
  47     return ( _rLeft.NanoSeconds == _rRight.NanoSeconds) &&
  48     ( _rLeft.Seconds == _rRight.Seconds) &&
  49     ( _rLeft.Minutes == _rRight.Minutes) &&
  50     ( _rLeft.Hours == _rRight.Hours) &&
  51     ( _rLeft.Day == _rRight.Day) &&
  52     ( _rLeft.Month == _rRight.Month) &&
  53     ( _rLeft.Year == _rRight.Year) ;
  54 }
  55
  56
  57 bool operator ==(const Date& _rLeft, const Date& _rRight)
  58 {
  59     return ( _rLeft.Day == _rRight.Day) &&
  60     ( _rLeft.Month == _rRight.Month) &&
  61     ( _rLeft.Year == _rRight.Year) ;
  62 }
  63
  64
  65 bool operator ==(const Time& _rLeft, const Time& _rRight)
  66 {
  67     return ( _rLeft.NanoSeconds == _rRight.NanoSeconds) &&
  68     ( _rLeft.Seconds == _rRight.Seconds) &&
  69     ( _rLeft.Minutes == _rRight.Minutes) &&
  70     ( _rLeft.Hours == _rRight.Hours) ;
  71 }
  72
  73
  74 sal_Int64 getINT64(const Any& _rAny)
  75 {
  76     sal_Int64 nReturn = 0;
  77     OSL_VERIFY( _rAny >>= nReturn );
  78     return nReturn;
  79 }
  80
  81
  82 sal_Int32 getINT32(const Any& _rAny)
  83 {
  84     sal_Int32 nReturn = 0;
  85     OSL_VERIFY( _rAny >>= nReturn );
  86     return nReturn;
  87 }
  88
  89
  90 sal_Int16 getINT16(const Any& _rAny)
  91 {
  92     sal_Int16 nReturn = 0;
  93     OSL_VERIFY( _rAny >>= nReturn );
  94     return nReturn;
  95 }
  96
  97
  98 double getDouble(const Any& _rAny)
  99 {
 100     double nReturn = 0.0;
 101     OSL_VERIFY( _rAny >>= nReturn );
 102     return nReturn;
 103 }
 104
 105
 106 float getFloat(const Any& _rAny)
 107 {
 108     float nReturn = 0.0;
 109     OSL_VERIFY( _rAny >>= nReturn );
 110     return nReturn;
 111 }
 112
 113
 114 OUString getString(const Any& _rAny)
 115 {
 116     OUString nReturn;
 117     OSL_VERIFY( _rAny >>= nReturn );
 118     return nReturn;
 119 }
 120
 121
 122 bool getBOOL(const Any& _rAny)
 123 {
 124     bool nReturn = false;
 125     if (_rAny.getValueType() == cppu::UnoType<bool>::get())
 126         nReturn = *static_cast<sal_Bool const *>(_rAny.getValue());
 127     else
 128         OSL_FAIL("comphelper::getBOOL : invalid argument !");
 129     return nReturn;
 130 }
 131
 132
 133 sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException)
 134 {
 135     sal_Int32 nReturn = 0;
 136     if (! ::cppu::enum2int(nReturn,_rAny) )
 137         throw IllegalArgumentException();
 138     return nReturn;
 139 }
 140
 141
 142 FontDescriptor  getDefaultFont()
 143 {
 144     FontDescriptor aReturn;
 145     aReturn.Slant = FontSlant_DONTKNOW;
 146     aReturn.Underline = FontUnderline::DONTKNOW;
 147     aReturn.Strikeout = FontStrikeout::DONTKNOW;
 148     return aReturn;
 149 }
 150
 151
 152 bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
 153 {
 154     // getthe type lib descriptions
 155     typelib_TypeDescription* pAssignable = NULL;
 156     _rAssignable.getDescription(&pAssignable);
 157
 158     typelib_TypeDescription* pFrom = NULL;
 159     _rFrom.getDescription(&pFrom);
 160
 161     // and ask the type lib
 162     return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
 163 }
 164
 165
 166 template<class TYPE>
 167 bool tryCompare(const void* _pData, const Any& _rValue, bool& _bIdentical, TYPE& _rOut)
 168 {
 169     bool bSuccess = _rValue >>= _rOut;
 170     _bIdentical = bSuccess && (_rOut == *static_cast<const TYPE*>(_pData));
 171     return bSuccess;
 172 }
 173
 174
 175 bool tryCompare(const void* _pData, const Any& _rValue, bool& _bIdentical, sal_Unicode& _rOut)
 176 {
 177     bool bSuccess = ( _rValue.getValueTypeClass() == TypeClass_CHAR );
 178     if ( bSuccess )
 179         _rOut = *static_cast< const sal_Unicode* >( _rValue.getValue() );
 180     _bIdentical = bSuccess && ( _rOut == *static_cast< const sal_Unicode* >( _pData ) );
 181     return bSuccess;
 182 }
 183
 184
 185 bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue)
 186 {
 187     bool bRes = true;
 188
 189     if (_rType.getTypeClass() == TypeClass_ANY)
 190     {
 191         // beides AnyWerte
 192         if (_rValue.getValueType().getTypeClass() == TypeClass_ANY)
 193             bRes = compare_impl(
 194                 static_cast<const Any*>(pData)->getValueType(),
 195                 static_cast<const Any*>(pData)->getValue(),
 196                 *static_cast<const Any*>(_rValue.getValue()));
 197         else
 198             bRes = compare_impl(
 199                 static_cast<const Any*>(pData)->getValueType(),
 200                 static_cast<const Any*>(pData)->getValue(),
 201                 _rValue);
 202     }
 203     else if (   (_rType.getTypeClass() == TypeClass_VOID)
 204             ||  (_rValue.getValueType().getTypeClass() == TypeClass_VOID)
 205             )
 206     {
 207         bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass();
 208     }
 209     else
 210     {
 211         bool bConversionSuccess = false;
 212         switch (_rType.getTypeClass())
 213         {
 214             case TypeClass_VOID:
 215                 bConversionSuccess = true;
 216                 bRes = _rValue.getValueType().getTypeClass() == TypeClass_VOID;
 217                 break;
 218             case TypeClass_BOOLEAN:
 219             {
 220                 bool aDummy;
 221                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 222                 break;
 223             }
 224             case TypeClass_CHAR:
 225             {
 226                 sal_Unicode aDummy(0);
 227                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 228                 break;
 229             }
 230             case TypeClass_STRING:
 231             {
 232                 OUString aDummy;
 233                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 234                 break;
 235             }
 236             case TypeClass_FLOAT:
 237             {
 238                 float aDummy;
 239                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 240                 break;
 241             }
 242             case TypeClass_DOUBLE:
 243             {
 244                 double aDummy;
 245                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 246                 break;
 247             }
 248             case TypeClass_BYTE:
 249             {
 250                 sal_Int8 aDummy;
 251                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 252                 break;
 253             }
 254             case TypeClass_SHORT:
 255             {
 256                 sal_Int16 aDummy;
 257                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 258                 break;
 259             }
 260             case TypeClass_ENUM:
 261             {
 262                 sal_Int32 nAsInt32 = 0;
 263                 bConversionSuccess = ::cppu::enum2int(nAsInt32, _rValue);
 264                 bRes = bConversionSuccess && (nAsInt32== *static_cast<const sal_Int32*>(pData));
 265                 break;
 266             }
 267             case TypeClass_LONG:
 268             {
 269                 sal_Int32 aDummy;
 270                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 271                 break;
 272             }
 273             case TypeClass_UNSIGNED_SHORT:
 274             {
 275                 sal_uInt16 aDummy;
 276                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 277                 break;
 278             }
 279             case TypeClass_UNSIGNED_LONG:
 280             {
 281                 sal_uInt32 aDummy;
 282                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 283                 break;
 284             }
 285             case TypeClass_INTERFACE:
 286             {
 287                 InterfaceRef aDummy;
 288                 bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 289                 break;
 290             }
 291             case TypeClass_STRUCT:
 292                 if (isA(_rType, static_cast<FontDescriptor*>(NULL)))
 293                 {
 294                     FontDescriptor aTemp;
 295                     bConversionSuccess = _rValue >>= aTemp;
 296                     if (bConversionSuccess)
 297                     {
 298                         bRes = *static_cast<FontDescriptor const *>(pData) == aTemp;
 299                     }
 300                     else
 301                         bRes = false;
 302                     break;
 303                 }
 304                 if (isA(_rType, static_cast<Date*>(NULL)))
 305                 {
 306                     Date aDummy;
 307                     bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 308                     break;
 309                 }
 310                 if (isA(_rType, static_cast<Time*>(NULL)))
 311                 {
 312                     Time aDummy;
 313                     bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 314                     break;
 315                 }
 316                 if (isA(_rType, static_cast<DateTime*>(NULL)))
 317                 {
 318                     DateTime aDummy;
 319                     bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
 320                     break;
 321                 }
 322                 break;
 323             case TypeClass_SEQUENCE:
 324                 if (isA(_rType, static_cast< Sequence<sal_Int8>* >(NULL)))
 325                 {
 326                     Sequence<sal_Int8> aTemp;
 327                     bConversionSuccess = _rValue >>= aTemp;
 328                     if (bConversionSuccess)
 329                     {
 330                         const Sequence<sal_Int8>& rLeftSeq = *static_cast<const Sequence<sal_Int8>*>(pData);
 331                         const Sequence<sal_Int8>& rRightSeq = aTemp;
 332                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 333                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
 334                     }
 335                 }
 336                 else if (isA(_rType, static_cast< Sequence<sal_uInt8>* >(NULL)))
 337                 {
 338                     Sequence<sal_uInt8> aTemp;
 339                     bConversionSuccess = _rValue >>= aTemp;
 340                     if (bConversionSuccess)
 341                     {
 342                         const Sequence<sal_uInt8>& rLeftSeq = *static_cast<const Sequence<sal_uInt8>*>(pData);
 343                         const Sequence<sal_uInt8>& rRightSeq = aTemp;
 344                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 345                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
 346                     }
 347                 }
 348                 else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL)))
 349                 {
 350                     Sequence<sal_Int16> aTemp;
 351                     bConversionSuccess = _rValue >>= aTemp;
 352                     if (bConversionSuccess)
 353                     {
 354                         const Sequence<sal_Int16>& rLeftSeq = *static_cast<const Sequence<sal_Int16>*>(pData);
 355                         const Sequence<sal_Int16>& rRightSeq = aTemp;
 356                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 357                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0;
 358                     }
 359                 }
 360                 else if (isA(_rType, static_cast< Sequence<sal_uInt16>* >(NULL)))
 361                 {
 362                     Sequence<sal_uInt16> aTemp;
 363                     bConversionSuccess = _rValue >>= aTemp;
 364                     if (bConversionSuccess)
 365                     {
 366                         const Sequence<sal_uInt16>& rLeftSeq = *static_cast<const Sequence<sal_uInt16>*>(pData);
 367                         const Sequence<sal_uInt16>& rRightSeq = aTemp;
 368                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 369                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt16)) == 0;
 370                     }
 371                 }
 372                 else if (isA(_rType, static_cast< Sequence<sal_Int32>* >(NULL)))
 373                 {
 374                     Sequence<sal_Int32> aTemp;
 375                     bConversionSuccess = _rValue >>= aTemp;
 376                     if (bConversionSuccess)
 377                     {
 378                         const Sequence<sal_Int32>& rLeftSeq = *static_cast<const Sequence<sal_Int32>*>(pData);
 379                         const Sequence<sal_Int32>& rRightSeq = aTemp;
 380                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 381                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int32)) == 0;
 382                     }
 383                 }
 384                 else if (isA(_rType, static_cast< Sequence<sal_uInt32>* >(NULL)))
 385                 {
 386                     Sequence<sal_uInt32> aTemp;
 387                     bConversionSuccess = _rValue >>= aTemp;
 388                     if (bConversionSuccess)
 389                     {
 390                         const Sequence<sal_uInt32>& rLeftSeq = *static_cast<const Sequence<sal_uInt32>*>(pData);
 391                         const Sequence<sal_uInt32>& rRightSeq = aTemp;
 392                         bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
 393                             memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt32)) == 0;
 394                     }
 395                 }
 396                 else if (isA(_rType, static_cast< Sequence< OUString >* >(NULL)))
 397                 {
 398                     Sequence< OUString > aTemp;
 399                     bConversionSuccess = _rValue >>= aTemp;
 400                     if (bConversionSuccess)
 401                     {
 402                         const Sequence< OUString >& rLeftSeq = *static_cast<const Sequence< OUString>*>(pData);
 403                         const Sequence< OUString >& rRightSeq = aTemp;
 404                         sal_Int32 nSeqLen = rLeftSeq.getLength();
 405                         bRes = ( nSeqLen == rRightSeq.getLength() );
 406                         for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ )
 407                         {
 408                             const OUString& rS1 = rLeftSeq.getConstArray()[n];
 409                             const OUString& rS2 = rRightSeq.getConstArray()[n];
 410                             bRes = ( rS1 == rS2 );
 411                         }
 412                     }
 413                 }
 414                 break;
 415             default:
 416                 bRes = false;
 417         }
 418
 419         bRes = bRes && bConversionSuccess;
 420     }
 421     return bRes;
 422 }
 423
 424
 425 bool compare(const Any& rLeft, const Any& rRight)
 426 {
 427     return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight);
 428 }
 429
 430
 431 bool    operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight)
 432 {
 433     return ( _rLeft.Name.equals( _rRight.Name ) ) &&
 434     ( _rLeft.Height == _rRight.Height ) &&
 435     ( _rLeft.Width == _rRight.Width ) &&
 436     ( _rLeft.StyleName.equals( _rRight.StyleName ) ) &&
 437     ( _rLeft.Family == _rRight.Family ) &&
 438     ( _rLeft.CharSet == _rRight.CharSet ) &&
 439     ( _rLeft.Pitch == _rRight.Pitch ) &&
 440     ( _rLeft.CharacterWidth == _rRight.CharacterWidth ) &&
 441     ( _rLeft.Weight == _rRight.Weight ) &&
 442     ( _rLeft.Slant == _rRight.Slant ) &&
 443     ( _rLeft.Underline == _rRight.Underline ) &&
 444     ( _rLeft.Strikeout == _rRight.Strikeout ) &&
 445     ( _rLeft.Orientation == _rRight.Orientation ) &&
 446     ( _rLeft.Kerning == _rRight.Kerning ) &&
 447     ( _rLeft.WordLineMode == _rRight.WordLineMode ) &&
 448     ( _rLeft.Type == _rRight.Type ) ;
 449 }
 450
 451
 452 Type getSequenceElementType(const Type& _rSequenceType)
 453 {
 454     OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE,
 455                 "getSequenceElementType: must be called with a  sequence type!");
 456
 457     if (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE))
 458         return Type();
 459
 460     TypeDescription aTD(_rSequenceType);
 461     typelib_IndirectTypeDescription* pSequenceTD =
 462         reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get());
 463
 464     OSL_ASSERT(pSequenceTD);
 465     OSL_ASSERT(pSequenceTD->pType);
 466
 467     if (pSequenceTD && pSequenceTD->pType)
 468         return Type(pSequenceTD->pType);
 469
 470     return Type();
 471 }
 472
 473 }   // namespace comphelper
 474
 475
 476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */