connectivity/source/drivers/macab/MacabResultSet.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
  21 #include "MacabResultSet.hxx"
  22 #include "MacabAddressBook.hxx"
  23 #include "MacabRecords.hxx"
  24 #include "macabutilities.hxx"
  25 #include "MacabResultSetMetaData.hxx"
  26 #include "MacabConnection.hxx"
  27 #include "macabcondition.hxx"
  28 #include "macaborder.hxx"
  29 #include <com/sun/star/beans/PropertyAttribute.hpp>
  30 #include <com/sun/star/sdbcx/CompareBookmark.hpp>
  31 #include <TConnection.hxx>
  32 #include <cppuhelper/typeprovider.hxx>
  33 #include <comphelper/types.hxx>
  34 #include <connectivity/dbexception.hxx>
  35 #include <resource/sharedresources.hxx>
  36 #include <rtl/ref.hxx>
  37 #include <strings.hrc>
  38
  39 using namespace connectivity::macab;
  40 using namespace cppu;
  41 using namespace css::uno;
  42 using namespace css::lang;
  43 using namespace css::beans;
  44 using namespace css::sdbc;
  45 using namespace css::sdbcx;
  46 using namespace css::io;
  47 using namespace css::util;
  48
  49 IMPLEMENT_SERVICE_INFO(MacabResultSet, "com.sun.star.sdbc.drivers.MacabResultSet", "com.sun.star.sdbc.ResultSet");
  50
  51 MacabResultSet::MacabResultSet(MacabCommonStatement* pStmt)
  52     : MacabResultSet_BASE(m_aMutex),
  53       OPropertySetHelper(MacabResultSet_BASE::rBHelper),
  54       m_xStatement(pStmt),
  55       m_aMacabRecords(),
  56       m_nRowPos(-1),
  57       m_bWasNull(true),
  58       m_sTableName(MacabAddressBook::getDefaultTableName())
  59 {
  60 }
  61
  62 MacabResultSet::~MacabResultSet()
  63 {
  64 }
  65
  66 void MacabResultSet::allMacabRecords()
  67 {
  68     rtl::Reference<MacabConnection> pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
  69
  70     m_aMacabRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
  71 }
  72
  73 void MacabResultSet::someMacabRecords(const MacabCondition *pCondition)
  74 {
  75     rtl::Reference<MacabConnection> pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
  76     MacabRecords* allRecords;
  77
  78     allRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
  79
  80     // Bad table!! Throw exception?
  81     if(allRecords == nullptr)
  82         return;
  83
  84     if(m_aMacabRecords != nullptr && m_aMacabRecords != allRecords)
  85         delete m_aMacabRecords;
  86
  87     // The copy constructor copies everything but records (including the
  88     // maximum allocated size, which means that we'll never have to resize)
  89     m_aMacabRecords = new MacabRecords(allRecords);
  90
  91     if(pCondition->isAlwaysFalse())
  92     {
  93         return;
  94     }
  95
  96     MacabRecords::iterator iterator;
  97
  98     for (iterator = allRecords->begin();
  99          iterator != allRecords->end();
 100          ++iterator)
 101     {
 102         if (pCondition->eval(*iterator))
 103             m_aMacabRecords->insertRecord(*iterator);
 104     }
 105 }
 106
 107 void MacabResultSet::sortMacabRecords(const MacabOrder *pOrder)
 108 {
 109     // I do this with ints rather than an iterator because the ids will
 110     // be changing when we change the order and ints are easier to deal
 111     // with (for me).
 112     sal_Int32 i, j, size, smallest;
 113     size = m_aMacabRecords->size();
 114
 115     for(i = 0; i < size; i++)
 116     {
 117         smallest = i;
 118         for( j = i + 1; j < size; j++)
 119         {
 120             // if smallest > j
 121             if(pOrder->compare(m_aMacabRecords->getRecord(smallest),
 122                         m_aMacabRecords->getRecord(j) ) > 0)
 123             {
 124                 smallest = j;
 125             }
 126
 127         }
 128
 129         if(smallest != i)
 130         {
 131             m_aMacabRecords->swap(i,smallest);
 132         }
 133     }
 134
 135 }
 136
 137 void MacabResultSet::setTableName(OUString const & _sTableName)
 138 {
 139     m_sTableName = _sTableName;
 140 }
 141
 142 void MacabResultSet::disposing()
 143 {
 144     OPropertySetHelper::disposing();
 145
 146     ::osl::MutexGuard aGuard(m_aMutex);
 147
 148     m_xStatement.clear();
 149     m_xMetaData.clear();
 150 }
 151
 152 Any SAL_CALL MacabResultSet::queryInterface(const Type & rType)
 153 {
 154     Any aRet = OPropertySetHelper::queryInterface(rType);
 155     if (!aRet.hasValue())
 156         aRet = MacabResultSet_BASE::queryInterface(rType);
 157     return aRet;
 158 }
 159
 160 void SAL_CALL MacabResultSet::acquire() noexcept
 161 {
 162     MacabResultSet_BASE::acquire();
 163 }
 164
 165 void SAL_CALL MacabResultSet::release() noexcept
 166 {
 167     MacabResultSet_BASE::release();
 168 }
 169
 170 Sequence<  Type > SAL_CALL MacabResultSet::getTypes()
 171 {
 172     OTypeCollection aTypes(
 173         cppu::UnoType<css::beans::XMultiPropertySet>::get(),
 174         cppu::UnoType<css::beans::XFastPropertySet>::get(),
 175         cppu::UnoType<css::beans::XPropertySet>::get());
 176
 177     return comphelper::concatSequences(aTypes.getTypes(), MacabResultSet_BASE::getTypes());
 178 }
 179
 180 css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL MacabResultSet::getPropertySetInfo(  )
 181 {
 182     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 183 }
 184
 185 sal_Int32 SAL_CALL MacabResultSet::findColumn(const OUString& columnName)
 186 {
 187     ::osl::MutexGuard aGuard( m_aMutex );
 188     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 189
 190     // find the first column with the name columnName
 191     Reference< XResultSetMetaData > xMeta = getMetaData();
 192     sal_Int32 nLen = xMeta->getColumnCount();
 193
 194     for (sal_Int32 i = 1; i <= nLen; ++i)
 195     {
 196         if (xMeta->isCaseSensitive(i) ?
 197             columnName == xMeta->getColumnName(i) :
 198             columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
 199                 return i;
 200     }
 201
 202     ::dbtools::throwInvalidColumnException( columnName, *this );
 203     assert(false);
 204     return 0; // Never reached
 205 }
 206
 207 OUString SAL_CALL MacabResultSet::getString(sal_Int32 columnIndex)
 208 {
 209     ::osl::MutexGuard aGuard( m_aMutex );
 210     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 211
 212     OUString aRet;
 213     sal_Int32 nRecords = m_aMacabRecords->size();
 214     m_bWasNull = true;
 215
 216     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 217     {
 218         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 219         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 220         if(aField != nullptr)
 221         {
 222             if(aField->type == kABStringProperty)
 223             {
 224                 aRet = CFStringToOUString(static_cast<CFStringRef>(aField->value));
 225                 m_bWasNull = false;
 226             }
 227         }
 228     }
 229
 230 // Trigger an exception if m_bWasNull is true?
 231     return aRet;
 232 }
 233
 234 sal_Bool SAL_CALL MacabResultSet::getBoolean(sal_Int32)
 235 {
 236     ::osl::MutexGuard aGuard( m_aMutex );
 237     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 238
 239     ::dbtools::throwFunctionNotSupportedSQLException("getBoolean", nullptr);
 240
 241     return false;
 242 }
 243
 244 sal_Int8 SAL_CALL MacabResultSet::getByte(sal_Int32)
 245 {
 246     ::osl::MutexGuard aGuard( m_aMutex );
 247     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 248
 249     ::dbtools::throwFunctionNotSupportedSQLException("getByte", nullptr);
 250
 251     return 0;
 252 }
 253
 254 sal_Int16 SAL_CALL MacabResultSet::getShort(sal_Int32)
 255 {
 256     ::osl::MutexGuard aGuard( m_aMutex );
 257     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 258
 259     ::dbtools::throwFunctionNotSupportedSQLException("getShort", nullptr);
 260
 261     return 0;
 262 }
 263
 264 sal_Int32 SAL_CALL MacabResultSet::getInt(sal_Int32 columnIndex)
 265 {
 266     ::osl::MutexGuard aGuard( m_aMutex );
 267     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 268
 269     sal_Int32 nRet = 0;
 270     sal_Int32 nRecords = m_aMacabRecords->size();
 271     m_bWasNull = true;
 272
 273     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 274     {
 275         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 276         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 277         if(aField != nullptr)
 278         {
 279             if(aField->type == kABIntegerProperty)
 280             {
 281                 CFNumberType numberType = CFNumberGetType( static_cast<CFNumberRef>(aField->value) );
 282                 // m_bWasNull now becomes whether getting the value was successful
 283                 // Should we check for the wrong type here, e.g., a float or a 64 bit int?
 284                 m_bWasNull = !CFNumberGetValue(static_cast<CFNumberRef>(aField->value), numberType, &nRet);
 285             }
 286         }
 287     }
 288
 289 // Trigger an exception if m_bWasNull is true?
 290     return nRet;
 291 }
 292
 293 sal_Int64 SAL_CALL MacabResultSet::getLong(sal_Int32 columnIndex)
 294 {
 295     ::osl::MutexGuard aGuard( m_aMutex );
 296     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 297
 298     sal_Int64 nRet = 0;
 299     sal_Int32 nRecords = m_aMacabRecords->size();
 300     m_bWasNull = true;
 301
 302     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 303     {
 304         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 305         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 306         if(aField != nullptr)
 307         {
 308             if(aField->type == kABIntegerProperty)
 309             {
 310                 CFNumberType numberType = CFNumberGetType( static_cast<CFNumberRef>(aField->value) );
 311                 // m_bWasNull now becomes whether getting the value was successful
 312                 // Should we check for the wrong type here, e.g., a float or a 32 bit int?
 313                 m_bWasNull = !CFNumberGetValue(static_cast<CFNumberRef>(aField->value), numberType, &nRet);
 314             }
 315         }
 316     }
 317
 318 // Trigger an exception if m_bWasNull is true?
 319     return nRet;
 320 }
 321
 322 float SAL_CALL MacabResultSet::getFloat(sal_Int32 columnIndex)
 323 {
 324     ::osl::MutexGuard aGuard( m_aMutex );
 325     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 326
 327     float nVal = 0;
 328     sal_Int32 nRecords = m_aMacabRecords->size();
 329     m_bWasNull = true;
 330
 331     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 332     {
 333         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 334         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 335         if(aField != nullptr)
 336         {
 337             if(aField->type == kABRealProperty)
 338             {
 339                 CFNumberType numberType = CFNumberGetType( static_cast<CFNumberRef>(aField->value) );
 340                 // m_bWasNull now becomes whether getting the value was successful
 341                 // Should we check for the wrong type here, e.g., an int or a double?
 342                 m_bWasNull = !CFNumberGetValue(static_cast<CFNumberRef>(aField->value), numberType, &nVal);
 343             }
 344         }
 345     }
 346
 347 // Trigger an exception if m_bWasNull is true?
 348     return nVal;
 349 }
 350
 351 double SAL_CALL MacabResultSet::getDouble(sal_Int32 columnIndex)
 352 {
 353     ::osl::MutexGuard aGuard( m_aMutex );
 354     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 355
 356     double nVal = 0;
 357     sal_Int32 nRecords = m_aMacabRecords->size();
 358     m_bWasNull = true;
 359
 360     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 361     {
 362         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 363         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 364         if(aField != nullptr)
 365         {
 366             if(aField->type == kABRealProperty)
 367             {
 368                 CFNumberType numberType = CFNumberGetType( static_cast<CFNumberRef>(aField->value) );
 369                 // m_bWasNull now becomes whether getting the value was successful
 370                 // Should we check for the wrong type here, e.g., an int or a float?
 371                 m_bWasNull = !CFNumberGetValue(static_cast<CFNumberRef>(aField->value), numberType, &nVal);
 372             }
 373         }
 374     }
 375
 376 // Trigger an exception if m_bWasNull is true?
 377     return nVal;
 378 }
 379
 380 Sequence< sal_Int8 > SAL_CALL MacabResultSet::getBytes(sal_Int32)
 381 {
 382     ::osl::MutexGuard aGuard( m_aMutex );
 383     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 384
 385     ::dbtools::throwFunctionNotSupportedSQLException("getBytes", nullptr);
 386
 387     return Sequence< sal_Int8 >();
 388 }
 389
 390 Date SAL_CALL MacabResultSet::getDate(sal_Int32)
 391 {
 392     ::osl::MutexGuard aGuard( m_aMutex );
 393     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 394
 395     ::dbtools::throwFunctionNotSupportedSQLException("getDate", nullptr);
 396
 397     Date aRet;
 398     return aRet;
 399 }
 400
 401 Time SAL_CALL MacabResultSet::getTime(sal_Int32)
 402 {
 403     ::osl::MutexGuard aGuard( m_aMutex );
 404     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 405
 406     ::dbtools::throwFunctionNotSupportedSQLException("getTime", nullptr);
 407
 408     css::util::Time nRet;
 409     return nRet;
 410 }
 411
 412 DateTime SAL_CALL MacabResultSet::getTimestamp(sal_Int32 columnIndex)
 413 {
 414     ::osl::MutexGuard aGuard( m_aMutex );
 415     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 416
 417     DateTime nRet;
 418     sal_Int32 nRecords = m_aMacabRecords->size();
 419     m_bWasNull = true;
 420
 421     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 422     {
 423         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 424         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 425         if(aField != nullptr)
 426         {
 427             if(aField->type == kABDateProperty)
 428             {
 429                 nRet = CFDateToDateTime(static_cast<CFDateRef>(aField->value));
 430                 m_bWasNull = false;
 431             }
 432         }
 433     }
 434
 435 // Trigger an exception if m_bWasNull is true?
 436     return nRet;
 437 }
 438
 439 Reference< XInputStream > SAL_CALL MacabResultSet::getBinaryStream(sal_Int32)
 440 {
 441     ::osl::MutexGuard aGuard( m_aMutex );
 442     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 443
 444     ::dbtools::throwFunctionNotSupportedSQLException("getBinaryStream", nullptr);
 445
 446     return nullptr;
 447 }
 448
 449 Reference< XInputStream > SAL_CALL MacabResultSet::getCharacterStream(sal_Int32)
 450 {
 451     ::osl::MutexGuard aGuard( m_aMutex );
 452     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 453
 454     ::dbtools::throwFunctionNotSupportedSQLException("getCharacterStream", nullptr);
 455
 456     return nullptr;
 457 }
 458
 459 Any SAL_CALL MacabResultSet::getObject(sal_Int32, const Reference< css::container::XNameAccess >&)
 460 {
 461     ::osl::MutexGuard aGuard( m_aMutex );
 462     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 463
 464     ::dbtools::throwFunctionNotSupportedSQLException("getObject", nullptr);
 465
 466     return Any();
 467 }
 468
 469 Reference< XRef > SAL_CALL MacabResultSet::getRef(sal_Int32)
 470 {
 471     ::osl::MutexGuard aGuard( m_aMutex );
 472     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 473
 474     ::dbtools::throwFunctionNotSupportedSQLException("getRef", nullptr);
 475
 476     return nullptr;
 477 }
 478
 479 Reference< XBlob > SAL_CALL MacabResultSet::getBlob(sal_Int32)
 480 {
 481     ::osl::MutexGuard aGuard( m_aMutex );
 482     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 483
 484     ::dbtools::throwFunctionNotSupportedSQLException("getBlob", nullptr);
 485
 486     return nullptr;
 487 }
 488
 489 Reference< XClob > SAL_CALL MacabResultSet::getClob(sal_Int32)
 490 {
 491     ::osl::MutexGuard aGuard( m_aMutex );
 492     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 493
 494     ::dbtools::throwFunctionNotSupportedSQLException("getClob", nullptr);
 495
 496     return nullptr;
 497 }
 498
 499 Reference< XArray > SAL_CALL MacabResultSet::getArray(sal_Int32)
 500 {
 501     ::osl::MutexGuard aGuard( m_aMutex );
 502     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 503
 504     ::dbtools::throwFunctionNotSupportedSQLException("getArray", nullptr);
 505
 506     return nullptr;
 507 }
 508
 509 Reference< XResultSetMetaData > SAL_CALL MacabResultSet::getMetaData()
 510 {
 511     ::osl::MutexGuard aGuard( m_aMutex );
 512     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 513
 514     if (!m_xMetaData.is())
 515         m_xMetaData = new MacabResultSetMetaData(m_xStatement->getOwnConnection(), m_sTableName);
 516
 517     Reference< XResultSetMetaData > xMetaData = m_xMetaData;
 518     return xMetaData;
 519 }
 520
 521 sal_Bool SAL_CALL MacabResultSet::isBeforeFirst()
 522 {
 523     ::osl::MutexGuard aGuard( m_aMutex );
 524     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 525
 526     if (m_nRowPos == -1)
 527         return true;
 528
 529     return false;
 530 }
 531
 532 sal_Bool SAL_CALL MacabResultSet::isAfterLast()
 533 {
 534     ::osl::MutexGuard aGuard( m_aMutex );
 535     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 536
 537     sal_Int32 nRecords = m_aMacabRecords->size();
 538     if (m_nRowPos == nRecords)
 539         return true;
 540
 541     return false;
 542 }
 543
 544 sal_Bool SAL_CALL MacabResultSet::isFirst()
 545 {
 546     ::osl::MutexGuard aGuard( m_aMutex );
 547     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 548
 549     if (m_nRowPos == 0)
 550         return true;
 551
 552     return false;
 553 }
 554
 555 sal_Bool SAL_CALL MacabResultSet::isLast()
 556 {
 557     ::osl::MutexGuard aGuard( m_aMutex );
 558     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 559
 560     sal_Int32 nRecords = m_aMacabRecords->size();
 561     if (m_nRowPos == nRecords - 1)
 562         return true;
 563
 564     return false;
 565 }
 566
 567 void SAL_CALL MacabResultSet::beforeFirst()
 568 {
 569     ::osl::MutexGuard aGuard( m_aMutex );
 570     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 571
 572     // move before the first row
 573     m_nRowPos = -1;
 574 }
 575
 576 void SAL_CALL MacabResultSet::afterLast()
 577 {
 578     ::osl::MutexGuard aGuard( m_aMutex );
 579     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 580
 581     // move after the last row
 582     sal_Int32 nRecords = m_aMacabRecords->size();
 583     m_nRowPos = nRecords;
 584 }
 585
 586 void SAL_CALL MacabResultSet::close()
 587 {
 588     {
 589         ::osl::MutexGuard aGuard( m_aMutex );
 590         checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 591     }
 592     dispose();
 593 }
 594
 595 sal_Bool SAL_CALL MacabResultSet::first()
 596 {
 597     ::osl::MutexGuard aGuard( m_aMutex );
 598     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 599
 600     sal_Int32 nRecords = m_aMacabRecords->size();
 601     if (nRecords == 0)
 602         return false;
 603
 604     m_nRowPos = 0;
 605     return true;
 606 }
 607
 608 sal_Bool SAL_CALL MacabResultSet::last()
 609 {
 610     ::osl::MutexGuard aGuard( m_aMutex );
 611     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 612
 613     sal_Int32 nRecords = m_aMacabRecords->size();
 614     if (nRecords == 0)
 615         return false;
 616
 617     m_nRowPos = nRecords - 1;
 618     return true;
 619 }
 620
 621 sal_Int32 SAL_CALL MacabResultSet::getRow()
 622 {
 623     ::osl::MutexGuard aGuard( m_aMutex );
 624     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 625
 626     return m_nRowPos;
 627 }
 628
 629 sal_Bool SAL_CALL MacabResultSet::absolute(sal_Int32 row)
 630 {
 631     ::osl::MutexGuard aGuard( m_aMutex );
 632     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 633
 634     sal_Int32 nRecords = m_aMacabRecords->size();
 635     if (row <= -1 ||
 636         row >= nRecords)
 637         return false;
 638
 639     m_nRowPos = row;
 640     return true;
 641 }
 642
 643 sal_Bool SAL_CALL MacabResultSet::relative(sal_Int32 row)
 644 {
 645     ::osl::MutexGuard aGuard( m_aMutex );
 646     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 647
 648     return absolute(m_nRowPos + row);
 649 }
 650
 651 sal_Bool SAL_CALL MacabResultSet::next()
 652 {
 653     ::osl::MutexGuard aGuard( m_aMutex );
 654     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 655
 656     return absolute(m_nRowPos + 1);
 657 }
 658
 659 sal_Bool SAL_CALL MacabResultSet::previous()
 660 {
 661     ::osl::MutexGuard aGuard( m_aMutex );
 662     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 663
 664     return absolute(m_nRowPos - 1);
 665 }
 666
 667 Reference< XInterface > SAL_CALL MacabResultSet::getStatement()
 668 {
 669     ::osl::MutexGuard aGuard( m_aMutex );
 670     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 671
 672     Reference< XStatement > xStatement = m_xStatement;
 673     return xStatement;
 674 }
 675
 676 sal_Bool SAL_CALL MacabResultSet::rowDeleted()
 677 {
 678     ::osl::MutexGuard aGuard( m_aMutex );
 679     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 680
 681     return false;
 682 }
 683
 684 sal_Bool SAL_CALL MacabResultSet::rowInserted()
 685 {
 686     ::osl::MutexGuard aGuard( m_aMutex );
 687     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 688
 689     return false;
 690 }
 691
 692 sal_Bool SAL_CALL MacabResultSet::rowUpdated()
 693 {
 694     ::osl::MutexGuard aGuard( m_aMutex );
 695     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 696
 697     return false;
 698 }
 699
 700 sal_Bool SAL_CALL MacabResultSet::wasNull()
 701 {
 702     ::osl::MutexGuard aGuard( m_aMutex );
 703     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 704
 705     return m_bWasNull;
 706 }
 707
 708 void SAL_CALL MacabResultSet::cancel()
 709 {
 710     ::osl::MutexGuard aGuard( m_aMutex );
 711     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 712 }
 713
 714 void SAL_CALL MacabResultSet::clearWarnings()
 715 {
 716 }
 717
 718 Any SAL_CALL MacabResultSet::getWarnings()
 719 {
 720     return Any();
 721 }
 722
 723 void SAL_CALL MacabResultSet::insertRow()
 724 {
 725     ::osl::MutexGuard aGuard( m_aMutex );
 726     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 727
 728     // you only have to implement this if you want to insert new rows
 729 }
 730
 731 void SAL_CALL MacabResultSet::updateRow()
 732 {
 733     ::osl::MutexGuard aGuard( m_aMutex );
 734     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 735
 736     // only when you allow updates
 737 }
 738
 739 void SAL_CALL MacabResultSet::deleteRow()
 740 {
 741     ::osl::MutexGuard aGuard( m_aMutex );
 742     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 743 }
 744
 745 void SAL_CALL MacabResultSet::cancelRowUpdates()
 746 {
 747     ::osl::MutexGuard aGuard( m_aMutex );
 748     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 749 }
 750
 751 void SAL_CALL MacabResultSet::moveToInsertRow()
 752 {
 753     ::osl::MutexGuard aGuard( m_aMutex );
 754     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 755
 756     // only when you allow inserts
 757 }
 758
 759 void SAL_CALL MacabResultSet::moveToCurrentRow()
 760 {
 761     ::osl::MutexGuard aGuard( m_aMutex );
 762     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 763 }
 764
 765 void SAL_CALL MacabResultSet::updateNull(sal_Int32)
 766 {
 767     ::osl::MutexGuard aGuard( m_aMutex );
 768     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 769 }
 770
 771 void SAL_CALL MacabResultSet::updateBoolean(sal_Int32, sal_Bool)
 772 {
 773     ::osl::MutexGuard aGuard( m_aMutex );
 774     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 775 }
 776
 777 void SAL_CALL MacabResultSet::updateByte(sal_Int32, sal_Int8)
 778 {
 779     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 780     ::osl::MutexGuard aGuard( m_aMutex );
 781 }
 782
 783 void SAL_CALL MacabResultSet::updateShort(sal_Int32, sal_Int16)
 784 {
 785     ::osl::MutexGuard aGuard( m_aMutex );
 786     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 787 }
 788
 789 void SAL_CALL MacabResultSet::updateInt(sal_Int32, sal_Int32)
 790 {
 791     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 792     ::osl::MutexGuard aGuard( m_aMutex );
 793 }
 794
 795 void SAL_CALL MacabResultSet::updateLong(sal_Int32, sal_Int64)
 796 {
 797     ::osl::MutexGuard aGuard( m_aMutex );
 798     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 799 }
 800
 801 void SAL_CALL MacabResultSet::updateFloat(sal_Int32, float)
 802 {
 803     ::osl::MutexGuard aGuard( m_aMutex );
 804     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 805 }
 806
 807 void SAL_CALL MacabResultSet::updateDouble(sal_Int32, double)
 808 {
 809     ::osl::MutexGuard aGuard( m_aMutex );
 810     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 811 }
 812
 813 void SAL_CALL MacabResultSet::updateString(sal_Int32, const OUString&)
 814 {
 815     ::osl::MutexGuard aGuard( m_aMutex );
 816     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 817 }
 818
 819 void SAL_CALL MacabResultSet::updateBytes(sal_Int32, const Sequence< sal_Int8 >&)
 820 {
 821     ::osl::MutexGuard aGuard( m_aMutex );
 822     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 823 }
 824
 825 void SAL_CALL MacabResultSet::updateDate(sal_Int32, const Date&)
 826 {
 827     ::osl::MutexGuard aGuard( m_aMutex );
 828     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 829 }
 830
 831 void SAL_CALL MacabResultSet::updateTime(sal_Int32, const css::util::Time&)
 832 {
 833     ::osl::MutexGuard aGuard( m_aMutex );
 834     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 835 }
 836
 837 void SAL_CALL MacabResultSet::updateTimestamp(sal_Int32, const DateTime&)
 838 {
 839     ::osl::MutexGuard aGuard( m_aMutex );
 840     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 841 }
 842
 843 void SAL_CALL MacabResultSet::updateBinaryStream(sal_Int32, const Reference< XInputStream >&, sal_Int32)
 844 {
 845     ::osl::MutexGuard aGuard( m_aMutex );
 846     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 847 }
 848
 849 void SAL_CALL MacabResultSet::updateCharacterStream(sal_Int32, const Reference< XInputStream >&, sal_Int32)
 850 {
 851     ::osl::MutexGuard aGuard( m_aMutex );
 852     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 853 }
 854
 855 void SAL_CALL MacabResultSet::refreshRow()
 856 {
 857     ::osl::MutexGuard aGuard( m_aMutex );
 858     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 859 }
 860
 861 void SAL_CALL MacabResultSet::updateObject(sal_Int32, const Any&)
 862 {
 863     ::osl::MutexGuard aGuard( m_aMutex );
 864     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 865 }
 866
 867 void SAL_CALL MacabResultSet::updateNumericObject(sal_Int32, const Any&, sal_Int32)
 868 {
 869     ::osl::MutexGuard aGuard( m_aMutex );
 870     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 871 }
 872
 873 // XRowLocate
 874 Any SAL_CALL MacabResultSet::getBookmark()
 875 {
 876     ::osl::MutexGuard aGuard( m_aMutex );
 877     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 878
 879     sal_Int32 nRecords = m_aMacabRecords->size();
 880
 881     if (m_nRowPos != -1 && m_nRowPos != nRecords)
 882     {
 883         macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,u"UID");
 884         if(uidField != nullptr)
 885         {
 886             if(uidField->type == kABStringProperty)
 887             {
 888                 return makeAny(CFStringToOUString( static_cast<CFStringRef>(uidField->value) ));
 889             }
 890         }
 891     }
 892     return Any();
 893 }
 894
 895 sal_Bool SAL_CALL MacabResultSet::moveToBookmark(const  Any& bookmark)
 896 {
 897     ::osl::MutexGuard aGuard( m_aMutex );
 898     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 899
 900     OUString sBookmark = comphelper::getString(bookmark);
 901     sal_Int32 nRecords = m_aMacabRecords->size();
 902
 903     for (sal_Int32 nRow = 0; nRow < nRecords; nRow++)
 904     {
 905         macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,u"UID");
 906         if(uidField != nullptr)
 907         {
 908             if(uidField->type == kABStringProperty)
 909             {
 910                 OUString sUniqueIdentifier = CFStringToOUString( static_cast<CFStringRef>(uidField->value) );
 911                 if (sUniqueIdentifier == sBookmark)
 912                 {
 913                     m_nRowPos = nRow;
 914                     return true;
 915                 }
 916             }
 917         }
 918     }
 919     return false;
 920 }
 921
 922 sal_Bool SAL_CALL MacabResultSet::moveRelativeToBookmark(const  Any& bookmark, sal_Int32 rows)
 923 {
 924     ::osl::MutexGuard aGuard( m_aMutex );
 925     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 926
 927     sal_Int32 nRowSave = m_nRowPos;
 928
 929     if (moveToBookmark(bookmark))
 930     {
 931         sal_Int32 nRecords = m_aMacabRecords->size();
 932
 933         m_nRowPos += rows;
 934
 935         if (-1 < m_nRowPos && m_nRowPos < nRecords)
 936             return true;
 937     }
 938
 939     m_nRowPos = nRowSave;
 940     return false;
 941 }
 942
 943 sal_Int32 SAL_CALL MacabResultSet::compareBookmarks(const  Any& firstItem, const  Any& secondItem)
 944 {
 945     ::osl::MutexGuard aGuard( m_aMutex );
 946     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 947
 948     OUString sFirst = comphelper::getString(firstItem);
 949     OUString sSecond = comphelper::getString(secondItem);
 950
 951     if (sFirst < sSecond)
 952         return CompareBookmark::LESS;
 953     if (sFirst > sSecond)
 954         return CompareBookmark::GREATER;
 955     return CompareBookmark::EQUAL;
 956 }
 957
 958 sal_Bool SAL_CALL MacabResultSet::hasOrderedBookmarks()
 959 {
 960     return false;
 961 }
 962
 963 sal_Int32 SAL_CALL MacabResultSet::hashBookmark(const  Any& bookmark)
 964 {
 965     ::osl::MutexGuard aGuard( m_aMutex );
 966     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 967
 968     OUString sBookmark = comphelper::getString(bookmark);
 969
 970     return sBookmark.hashCode();
 971 }
 972
 973 // XDeleteRows
 974 Sequence< sal_Int32 > SAL_CALL MacabResultSet::deleteRows(const  Sequence<  Any >&)
 975 {
 976     ::osl::MutexGuard aGuard( m_aMutex );
 977     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 978
 979     return Sequence< sal_Int32 >();
 980 }
 981
 982 IPropertyArrayHelper* MacabResultSet::createArrayHelper() const
 983 {
 984     Sequence< Property > aProps(6);
 985     Property* pProperties = aProps.getArray();
 986     sal_Int32 nPos = 0;
 987     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 988         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), PropertyAttribute::READONLY);
 989
 990     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 991         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 992
 993     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 994         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 995
 996     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),
 997         PROPERTY_ID_ISBOOKMARKABLE, cppu::UnoType<bool>::get(), PropertyAttribute::READONLY);
 998
 999     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
1000         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
1001
1002     pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
1003         PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
1004
1005     return new OPropertyArrayHelper(aProps);
1006 }
1007
1008 IPropertyArrayHelper & MacabResultSet::getInfoHelper()
1009 {
1010     return *getArrayHelper();
1011 }
1012
1013 sal_Bool MacabResultSet::convertFastPropertyValue(
1014             Any &,
1015             Any &,
1016             sal_Int32 nHandle,
1017             const Any& )
1018 {
1019     switch (nHandle)
1020     {
1021         case PROPERTY_ID_ISBOOKMARKABLE:
1022         case PROPERTY_ID_CURSORNAME:
1023         case PROPERTY_ID_RESULTSETCONCURRENCY:
1024         case PROPERTY_ID_RESULTSETTYPE:
1025             throw css::lang::IllegalArgumentException();
1026             break;
1027         case PROPERTY_ID_FETCHDIRECTION:
1028         case PROPERTY_ID_FETCHSIZE:
1029         default:
1030             ;
1031     }
1032     return false;
1033 }
1034
1035 void MacabResultSet::setFastPropertyValue_NoBroadcast(
1036             sal_Int32 nHandle,
1037             const Any& )
1038 {
1039     switch (nHandle)
1040     {
1041         case PROPERTY_ID_ISBOOKMARKABLE:
1042         case PROPERTY_ID_CURSORNAME:
1043         case PROPERTY_ID_RESULTSETCONCURRENCY:
1044         case PROPERTY_ID_RESULTSETTYPE:
1045             throw Exception("cannot set prop " + OUString::number(nHandle), nullptr);
1046             break;
1047         case PROPERTY_ID_FETCHDIRECTION:
1048             break;
1049         case PROPERTY_ID_FETCHSIZE:
1050             break;
1051         default:
1052             ;
1053     }
1054 }
1055
1056 void MacabResultSet::getFastPropertyValue(
1057             Any& _rValue,
1058             sal_Int32 nHandle) const
1059 {
1060     switch (nHandle)
1061     {
1062         case PROPERTY_ID_ISBOOKMARKABLE:
1063             _rValue <<= false;
1064             break;
1065         case PROPERTY_ID_CURSORNAME:
1066         case PROPERTY_ID_RESULTSETCONCURRENCY:
1067         case PROPERTY_ID_RESULTSETTYPE:
1068         case PROPERTY_ID_FETCHDIRECTION:
1069         case PROPERTY_ID_FETCHSIZE:
1070             ;
1071     }
1072 }
1073
1074
1075 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */