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     return Date();
 398 }
 399
 400 Time SAL_CALL MacabResultSet::getTime(sal_Int32)
 401 {
 402     ::osl::MutexGuard aGuard( m_aMutex );
 403     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 404
 405     ::dbtools::throwFunctionNotSupportedSQLException("getTime", nullptr);
 406
 407     return css::util::Time();
 408 }
 409
 410 DateTime SAL_CALL MacabResultSet::getTimestamp(sal_Int32 columnIndex)
 411 {
 412     ::osl::MutexGuard aGuard( m_aMutex );
 413     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 414
 415     DateTime nRet;
 416     sal_Int32 nRecords = m_aMacabRecords->size();
 417     m_bWasNull = true;
 418
 419     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 420     {
 421         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 422         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 423         if(aField != nullptr)
 424         {
 425             if(aField->type == kABDateProperty)
 426             {
 427                 nRet = CFDateToDateTime(static_cast<CFDateRef>(aField->value));
 428                 m_bWasNull = false;
 429             }
 430         }
 431     }
 432
 433 // Trigger an exception if m_bWasNull is true?
 434     return nRet;
 435 }
 436
 437 Reference< XInputStream > SAL_CALL MacabResultSet::getBinaryStream(sal_Int32)
 438 {
 439     ::osl::MutexGuard aGuard( m_aMutex );
 440     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 441
 442     ::dbtools::throwFunctionNotSupportedSQLException("getBinaryStream", nullptr);
 443
 444     return nullptr;
 445 }
 446
 447 Reference< XInputStream > SAL_CALL MacabResultSet::getCharacterStream(sal_Int32)
 448 {
 449     ::osl::MutexGuard aGuard( m_aMutex );
 450     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 451
 452     ::dbtools::throwFunctionNotSupportedSQLException("getCharacterStream", nullptr);
 453
 454     return nullptr;
 455 }
 456
 457 Any SAL_CALL MacabResultSet::getObject(sal_Int32, const Reference< css::container::XNameAccess >&)
 458 {
 459     ::osl::MutexGuard aGuard( m_aMutex );
 460     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 461
 462     ::dbtools::throwFunctionNotSupportedSQLException("getObject", nullptr);
 463
 464     return Any();
 465 }
 466
 467 Reference< XRef > SAL_CALL MacabResultSet::getRef(sal_Int32)
 468 {
 469     ::osl::MutexGuard aGuard( m_aMutex );
 470     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 471
 472     ::dbtools::throwFunctionNotSupportedSQLException("getRef", nullptr);
 473
 474     return nullptr;
 475 }
 476
 477 Reference< XBlob > SAL_CALL MacabResultSet::getBlob(sal_Int32)
 478 {
 479     ::osl::MutexGuard aGuard( m_aMutex );
 480     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 481
 482     ::dbtools::throwFunctionNotSupportedSQLException("getBlob", nullptr);
 483
 484     return nullptr;
 485 }
 486
 487 Reference< XClob > SAL_CALL MacabResultSet::getClob(sal_Int32)
 488 {
 489     ::osl::MutexGuard aGuard( m_aMutex );
 490     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 491
 492     ::dbtools::throwFunctionNotSupportedSQLException("getClob", nullptr);
 493
 494     return nullptr;
 495 }
 496
 497 Reference< XArray > SAL_CALL MacabResultSet::getArray(sal_Int32)
 498 {
 499     ::osl::MutexGuard aGuard( m_aMutex );
 500     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 501
 502     ::dbtools::throwFunctionNotSupportedSQLException("getArray", nullptr);
 503
 504     return nullptr;
 505 }
 506
 507 Reference< XResultSetMetaData > SAL_CALL MacabResultSet::getMetaData()
 508 {
 509     ::osl::MutexGuard aGuard( m_aMutex );
 510     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 511
 512     if (!m_xMetaData.is())
 513         m_xMetaData = new MacabResultSetMetaData(m_xStatement->getOwnConnection(), m_sTableName);
 514
 515     Reference< XResultSetMetaData > xMetaData = m_xMetaData;
 516     return xMetaData;
 517 }
 518
 519 sal_Bool SAL_CALL MacabResultSet::isBeforeFirst()
 520 {
 521     ::osl::MutexGuard aGuard( m_aMutex );
 522     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 523
 524     if (m_nRowPos == -1)
 525         return true;
 526
 527     return false;
 528 }
 529
 530 sal_Bool SAL_CALL MacabResultSet::isAfterLast()
 531 {
 532     ::osl::MutexGuard aGuard( m_aMutex );
 533     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 534
 535     sal_Int32 nRecords = m_aMacabRecords->size();
 536     if (m_nRowPos == nRecords)
 537         return true;
 538
 539     return false;
 540 }
 541
 542 sal_Bool SAL_CALL MacabResultSet::isFirst()
 543 {
 544     ::osl::MutexGuard aGuard( m_aMutex );
 545     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 546
 547     if (m_nRowPos == 0)
 548         return true;
 549
 550     return false;
 551 }
 552
 553 sal_Bool SAL_CALL MacabResultSet::isLast()
 554 {
 555     ::osl::MutexGuard aGuard( m_aMutex );
 556     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 557
 558     sal_Int32 nRecords = m_aMacabRecords->size();
 559     if (m_nRowPos == nRecords - 1)
 560         return true;
 561
 562     return false;
 563 }
 564
 565 void SAL_CALL MacabResultSet::beforeFirst()
 566 {
 567     ::osl::MutexGuard aGuard( m_aMutex );
 568     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 569
 570     // move before the first row
 571     m_nRowPos = -1;
 572 }
 573
 574 void SAL_CALL MacabResultSet::afterLast()
 575 {
 576     ::osl::MutexGuard aGuard( m_aMutex );
 577     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 578
 579     // move after the last row
 580     sal_Int32 nRecords = m_aMacabRecords->size();
 581     m_nRowPos = nRecords;
 582 }
 583
 584 void SAL_CALL MacabResultSet::close()
 585 {
 586     {
 587         ::osl::MutexGuard aGuard( m_aMutex );
 588         checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 589     }
 590     dispose();
 591 }
 592
 593 sal_Bool SAL_CALL MacabResultSet::first()
 594 {
 595     ::osl::MutexGuard aGuard( m_aMutex );
 596     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 597
 598     sal_Int32 nRecords = m_aMacabRecords->size();
 599     if (nRecords == 0)
 600         return false;
 601
 602     m_nRowPos = 0;
 603     return true;
 604 }
 605
 606 sal_Bool SAL_CALL MacabResultSet::last()
 607 {
 608     ::osl::MutexGuard aGuard( m_aMutex );
 609     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 610
 611     sal_Int32 nRecords = m_aMacabRecords->size();
 612     if (nRecords == 0)
 613         return false;
 614
 615     m_nRowPos = nRecords - 1;
 616     return true;
 617 }
 618
 619 sal_Int32 SAL_CALL MacabResultSet::getRow()
 620 {
 621     ::osl::MutexGuard aGuard( m_aMutex );
 622     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 623
 624     return m_nRowPos;
 625 }
 626
 627 sal_Bool SAL_CALL MacabResultSet::absolute(sal_Int32 row)
 628 {
 629     ::osl::MutexGuard aGuard( m_aMutex );
 630     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 631
 632     sal_Int32 nRecords = m_aMacabRecords->size();
 633     if (row <= -1 ||
 634         row >= nRecords)
 635         return false;
 636
 637     m_nRowPos = row;
 638     return true;
 639 }
 640
 641 sal_Bool SAL_CALL MacabResultSet::relative(sal_Int32 row)
 642 {
 643     ::osl::MutexGuard aGuard( m_aMutex );
 644     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 645
 646     return absolute(m_nRowPos + row);
 647 }
 648
 649 sal_Bool SAL_CALL MacabResultSet::next()
 650 {
 651     ::osl::MutexGuard aGuard( m_aMutex );
 652     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 653
 654     return absolute(m_nRowPos + 1);
 655 }
 656
 657 sal_Bool SAL_CALL MacabResultSet::previous()
 658 {
 659     ::osl::MutexGuard aGuard( m_aMutex );
 660     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 661
 662     return absolute(m_nRowPos - 1);
 663 }
 664
 665 Reference< XInterface > SAL_CALL MacabResultSet::getStatement()
 666 {
 667     ::osl::MutexGuard aGuard( m_aMutex );
 668     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 669
 670     Reference< XStatement > xStatement = m_xStatement;
 671     return xStatement;
 672 }
 673
 674 sal_Bool SAL_CALL MacabResultSet::rowDeleted()
 675 {
 676     ::osl::MutexGuard aGuard( m_aMutex );
 677     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 678
 679     return false;
 680 }
 681
 682 sal_Bool SAL_CALL MacabResultSet::rowInserted()
 683 {
 684     ::osl::MutexGuard aGuard( m_aMutex );
 685     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 686
 687     return false;
 688 }
 689
 690 sal_Bool SAL_CALL MacabResultSet::rowUpdated()
 691 {
 692     ::osl::MutexGuard aGuard( m_aMutex );
 693     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 694
 695     return false;
 696 }
 697
 698 sal_Bool SAL_CALL MacabResultSet::wasNull()
 699 {
 700     ::osl::MutexGuard aGuard( m_aMutex );
 701     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 702
 703     return m_bWasNull;
 704 }
 705
 706 void SAL_CALL MacabResultSet::cancel()
 707 {
 708     ::osl::MutexGuard aGuard( m_aMutex );
 709     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 710 }
 711
 712 void SAL_CALL MacabResultSet::clearWarnings()
 713 {
 714 }
 715
 716 Any SAL_CALL MacabResultSet::getWarnings()
 717 {
 718     return Any();
 719 }
 720
 721 void SAL_CALL MacabResultSet::insertRow()
 722 {
 723     ::osl::MutexGuard aGuard( m_aMutex );
 724     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 725
 726     // you only have to implement this if you want to insert new rows
 727 }
 728
 729 void SAL_CALL MacabResultSet::updateRow()
 730 {
 731     ::osl::MutexGuard aGuard( m_aMutex );
 732     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 733
 734     // only when you allow updates
 735 }
 736
 737 void SAL_CALL MacabResultSet::deleteRow()
 738 {
 739     ::osl::MutexGuard aGuard( m_aMutex );
 740     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 741 }
 742
 743 void SAL_CALL MacabResultSet::cancelRowUpdates()
 744 {
 745     ::osl::MutexGuard aGuard( m_aMutex );
 746     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 747 }
 748
 749 void SAL_CALL MacabResultSet::moveToInsertRow()
 750 {
 751     ::osl::MutexGuard aGuard( m_aMutex );
 752     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 753
 754     // only when you allow inserts
 755 }
 756
 757 void SAL_CALL MacabResultSet::moveToCurrentRow()
 758 {
 759     ::osl::MutexGuard aGuard( m_aMutex );
 760     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 761 }
 762
 763 void SAL_CALL MacabResultSet::updateNull(sal_Int32)
 764 {
 765     ::osl::MutexGuard aGuard( m_aMutex );
 766     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 767 }
 768
 769 void SAL_CALL MacabResultSet::updateBoolean(sal_Int32, sal_Bool)
 770 {
 771     ::osl::MutexGuard aGuard( m_aMutex );
 772     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 773 }
 774
 775 void SAL_CALL MacabResultSet::updateByte(sal_Int32, sal_Int8)
 776 {
 777     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 778     ::osl::MutexGuard aGuard( m_aMutex );
 779 }
 780
 781 void SAL_CALL MacabResultSet::updateShort(sal_Int32, sal_Int16)
 782 {
 783     ::osl::MutexGuard aGuard( m_aMutex );
 784     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 785 }
 786
 787 void SAL_CALL MacabResultSet::updateInt(sal_Int32, sal_Int32)
 788 {
 789     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 790     ::osl::MutexGuard aGuard( m_aMutex );
 791 }
 792
 793 void SAL_CALL MacabResultSet::updateLong(sal_Int32, sal_Int64)
 794 {
 795     ::osl::MutexGuard aGuard( m_aMutex );
 796     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 797 }
 798
 799 void SAL_CALL MacabResultSet::updateFloat(sal_Int32, float)
 800 {
 801     ::osl::MutexGuard aGuard( m_aMutex );
 802     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 803 }
 804
 805 void SAL_CALL MacabResultSet::updateDouble(sal_Int32, double)
 806 {
 807     ::osl::MutexGuard aGuard( m_aMutex );
 808     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 809 }
 810
 811 void SAL_CALL MacabResultSet::updateString(sal_Int32, const OUString&)
 812 {
 813     ::osl::MutexGuard aGuard( m_aMutex );
 814     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 815 }
 816
 817 void SAL_CALL MacabResultSet::updateBytes(sal_Int32, const Sequence< sal_Int8 >&)
 818 {
 819     ::osl::MutexGuard aGuard( m_aMutex );
 820     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 821 }
 822
 823 void SAL_CALL MacabResultSet::updateDate(sal_Int32, const Date&)
 824 {
 825     ::osl::MutexGuard aGuard( m_aMutex );
 826     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 827 }
 828
 829 void SAL_CALL MacabResultSet::updateTime(sal_Int32, const css::util::Time&)
 830 {
 831     ::osl::MutexGuard aGuard( m_aMutex );
 832     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 833 }
 834
 835 void SAL_CALL MacabResultSet::updateTimestamp(sal_Int32, const DateTime&)
 836 {
 837     ::osl::MutexGuard aGuard( m_aMutex );
 838     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 839 }
 840
 841 void SAL_CALL MacabResultSet::updateBinaryStream(sal_Int32, const Reference< XInputStream >&, sal_Int32)
 842 {
 843     ::osl::MutexGuard aGuard( m_aMutex );
 844     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 845 }
 846
 847 void SAL_CALL MacabResultSet::updateCharacterStream(sal_Int32, const Reference< XInputStream >&, sal_Int32)
 848 {
 849     ::osl::MutexGuard aGuard( m_aMutex );
 850     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 851 }
 852
 853 void SAL_CALL MacabResultSet::refreshRow()
 854 {
 855     ::osl::MutexGuard aGuard( m_aMutex );
 856     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 857 }
 858
 859 void SAL_CALL MacabResultSet::updateObject(sal_Int32, const Any&)
 860 {
 861     ::osl::MutexGuard aGuard( m_aMutex );
 862     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 863 }
 864
 865 void SAL_CALL MacabResultSet::updateNumericObject(sal_Int32, const Any&, sal_Int32)
 866 {
 867     ::osl::MutexGuard aGuard( m_aMutex );
 868     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 869 }
 870
 871 // XRowLocate
 872 Any SAL_CALL MacabResultSet::getBookmark()
 873 {
 874     ::osl::MutexGuard aGuard( m_aMutex );
 875     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 876
 877     sal_Int32 nRecords = m_aMacabRecords->size();
 878
 879     if (m_nRowPos != -1 && m_nRowPos != nRecords)
 880     {
 881         macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,u"UID");
 882         if(uidField != nullptr)
 883         {
 884             if(uidField->type == kABStringProperty)
 885             {
 886                 return Any(CFStringToOUString( static_cast<CFStringRef>(uidField->value) ));
 887             }
 888         }
 889     }
 890     return Any();
 891 }
 892
 893 sal_Bool SAL_CALL MacabResultSet::moveToBookmark(const  Any& bookmark)
 894 {
 895     ::osl::MutexGuard aGuard( m_aMutex );
 896     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 897
 898     OUString sBookmark = comphelper::getString(bookmark);
 899     sal_Int32 nRecords = m_aMacabRecords->size();
 900
 901     for (sal_Int32 nRow = 0; nRow < nRecords; nRow++)
 902     {
 903         macabfield *uidField = m_aMacabRecords->getField(m_nRowPos,u"UID");
 904         if(uidField != nullptr)
 905         {
 906             if(uidField->type == kABStringProperty)
 907             {
 908                 OUString sUniqueIdentifier = CFStringToOUString( static_cast<CFStringRef>(uidField->value) );
 909                 if (sUniqueIdentifier == sBookmark)
 910                 {
 911                     m_nRowPos = nRow;
 912                     return true;
 913                 }
 914             }
 915         }
 916     }
 917     return false;
 918 }
 919
 920 sal_Bool SAL_CALL MacabResultSet::moveRelativeToBookmark(const  Any& bookmark, sal_Int32 rows)
 921 {
 922     ::osl::MutexGuard aGuard( m_aMutex );
 923     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 924
 925     sal_Int32 nRowSave = m_nRowPos;
 926
 927     if (moveToBookmark(bookmark))
 928     {
 929         sal_Int32 nRecords = m_aMacabRecords->size();
 930
 931         m_nRowPos += rows;
 932
 933         if (-1 < m_nRowPos && m_nRowPos < nRecords)
 934             return true;
 935     }
 936
 937     m_nRowPos = nRowSave;
 938     return false;
 939 }
 940
 941 sal_Int32 SAL_CALL MacabResultSet::compareBookmarks(const  Any& firstItem, const  Any& secondItem)
 942 {
 943     ::osl::MutexGuard aGuard( m_aMutex );
 944     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 945
 946     OUString sFirst = comphelper::getString(firstItem);
 947     OUString sSecond = comphelper::getString(secondItem);
 948
 949     if (sFirst < sSecond)
 950         return CompareBookmark::LESS;
 951     if (sFirst > sSecond)
 952         return CompareBookmark::GREATER;
 953     return CompareBookmark::EQUAL;
 954 }
 955
 956 sal_Bool SAL_CALL MacabResultSet::hasOrderedBookmarks()
 957 {
 958     return false;
 959 }
 960
 961 sal_Int32 SAL_CALL MacabResultSet::hashBookmark(const  Any& bookmark)
 962 {
 963     ::osl::MutexGuard aGuard( m_aMutex );
 964     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 965
 966     OUString sBookmark = comphelper::getString(bookmark);
 967
 968     return sBookmark.hashCode();
 969 }
 970
 971 // XDeleteRows
 972 Sequence< sal_Int32 > SAL_CALL MacabResultSet::deleteRows(const  Sequence<  Any >&)
 973 {
 974     ::osl::MutexGuard aGuard( m_aMutex );
 975     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 976
 977     return Sequence< sal_Int32 >();
 978 }
 979
 980 IPropertyArrayHelper* MacabResultSet::createArrayHelper() const
 981 {
 982     return new OPropertyArrayHelper
 983     {
 984         {
 985             {
 986                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 987                 PROPERTY_ID_CURSORNAME,
 988                 cppu::UnoType<OUString>::get(),
 989                 PropertyAttribute::READONLY
 990             },
 991             {
 992                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 993                 PROPERTY_ID_FETCHDIRECTION,
 994                 cppu::UnoType<sal_Int32>::get(),
 995                 0
 996             },
 997             {
 998                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 999                 PROPERTY_ID_FETCHSIZE,
1000                 cppu::UnoType<sal_Int32>::get(),
1001                 0
1002             },
1003             {
1004                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),
1005                 PROPERTY_ID_ISBOOKMARKABLE,
1006                 cppu::UnoType<bool>::get(),
1007                 PropertyAttribute::READONLY
1008             },
1009             {
1010                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
1011                 PROPERTY_ID_RESULTSETCONCURRENCY,
1012                 cppu::UnoType<sal_Int32>::get(),
1013                 PropertyAttribute::READONLY
1014             },
1015             {
1016                 ::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
1017                 PROPERTY_ID_RESULTSETTYPE,
1018                 cppu::UnoType<sal_Int32>::get(),
1019                 PropertyAttribute::READONLY
1020             }
1021         }
1022     };
1023 }
1024
1025 IPropertyArrayHelper & MacabResultSet::getInfoHelper()
1026 {
1027     return *getArrayHelper();
1028 }
1029
1030 sal_Bool MacabResultSet::convertFastPropertyValue(
1031             Any &,
1032             Any &,
1033             sal_Int32 nHandle,
1034             const Any& )
1035 {
1036     switch (nHandle)
1037     {
1038         case PROPERTY_ID_ISBOOKMARKABLE:
1039         case PROPERTY_ID_CURSORNAME:
1040         case PROPERTY_ID_RESULTSETCONCURRENCY:
1041         case PROPERTY_ID_RESULTSETTYPE:
1042             throw css::lang::IllegalArgumentException();
1043             break;
1044         case PROPERTY_ID_FETCHDIRECTION:
1045         case PROPERTY_ID_FETCHSIZE:
1046         default:
1047             ;
1048     }
1049     return false;
1050 }
1051
1052 void MacabResultSet::setFastPropertyValue_NoBroadcast(
1053             sal_Int32 nHandle,
1054             const Any& )
1055 {
1056     switch (nHandle)
1057     {
1058         case PROPERTY_ID_ISBOOKMARKABLE:
1059         case PROPERTY_ID_CURSORNAME:
1060         case PROPERTY_ID_RESULTSETCONCURRENCY:
1061         case PROPERTY_ID_RESULTSETTYPE:
1062             throw Exception("cannot set prop " + OUString::number(nHandle), nullptr);
1063             break;
1064         case PROPERTY_ID_FETCHDIRECTION:
1065             break;
1066         case PROPERTY_ID_FETCHSIZE:
1067             break;
1068         default:
1069             ;
1070     }
1071 }
1072
1073 void MacabResultSet::getFastPropertyValue(
1074             Any& _rValue,
1075             sal_Int32 nHandle) const
1076 {
1077     switch (nHandle)
1078     {
1079         case PROPERTY_ID_ISBOOKMARKABLE:
1080             _rValue <<= false;
1081             break;
1082         case PROPERTY_ID_CURSORNAME:
1083         case PROPERTY_ID_RESULTSETCONCURRENCY:
1084         case PROPERTY_ID_RESULTSETTYPE:
1085         case PROPERTY_ID_FETCHDIRECTION:
1086         case PROPERTY_ID_FETCHSIZE:
1087             ;
1088     }
1089 }
1090
1091
1092 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */