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 <connectivity/dbexception.hxx>
  33 #include "resource/sharedresources.hxx"
  34 #include "resource/macab_res.hrc"
  35
  36 using namespace connectivity::macab;
  37 using namespace cppu;
  38 using namespace com::sun::star::uno;
  39 using namespace com::sun::star::lang;
  40 using namespace com::sun::star::beans;
  41 using namespace com::sun::star::sdbc;
  42 using namespace com::sun::star::sdbcx;
  43 using namespace com::sun::star::io;
  44 using namespace com::sun::star::util;
  45
  46 IMPLEMENT_SERVICE_INFO(MacabResultSet, "com.sun.star.sdbc.drivers.MacabResultSet", "com.sun.star.sdbc.ResultSet");
  47
  48 MacabResultSet::MacabResultSet(MacabCommonStatement* pStmt)
  49     : MacabResultSet_BASE(m_aMutex),
  50       OPropertySetHelper(MacabResultSet_BASE::rBHelper),
  51       m_xStatement(pStmt),
  52       m_xMetaData(NULL),
  53       m_aMacabRecords(),
  54       m_nRowPos(-1),
  55       m_bWasNull(true)
  56 {
  57     m_sTableName = MacabAddressBook::getDefaultTableName();
  58 }
  59
  60 MacabResultSet::~MacabResultSet()
  61 {
  62 }
  63
  64 void MacabResultSet::allMacabRecords()
  65 {
  66     MacabConnection* pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
  67
  68     m_aMacabRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
  69 }
  70
  71 void MacabResultSet::someMacabRecords(const MacabCondition *pCondition)
  72 {
  73     MacabConnection* pConnection = static_cast< MacabConnection *>(m_xStatement->getConnection().get());
  74     MacabRecords* allRecords;
  75
  76     allRecords = pConnection->getAddressBook()->getMacabRecords(m_sTableName);
  77
  78     // Bad table!! Throw exception?
  79     if(allRecords == NULL)
  80         return;
  81
  82     if(m_aMacabRecords != NULL && m_aMacabRecords != allRecords)
  83         delete m_aMacabRecords;
  84
  85     // The copy constructor copies everything but records (including the
  86     // maximum alloted size, which means that we'll never have to resize)
  87     m_aMacabRecords = new MacabRecords(allRecords);
  88
  89     if(pCondition->isAlwaysFalse())
  90     {
  91         return;
  92     }
  93
  94     MacabRecords::iterator iterator;
  95
  96     for (iterator = allRecords->begin();
  97          iterator != allRecords->end();
  98          ++iterator)
  99     {
 100         if (pCondition->eval(*iterator))
 101             m_aMacabRecords->insertRecord(*iterator);
 102     }
 103 }
 104
 105 void MacabResultSet::sortMacabRecords(const MacabOrder *pOrder)
 106 {
 107     // I do this with ints rather than an iterator because the ids will
 108     // be changing when we change the order and ints are easier to deal
 109     // with (for me).
 110     sal_Int32 i, j, size, smallest;
 111     size = m_aMacabRecords->size();
 112
 113     for(i = 0; i < size; i++)
 114     {
 115         smallest = i;
 116         for( j = i + 1; j < size; j++)
 117         {
 118             // if smallest > j
 119             if(pOrder->compare(m_aMacabRecords->getRecord(smallest),
 120                         m_aMacabRecords->getRecord(j) ) > 0)
 121             {
 122                 smallest = j;
 123             }
 124
 125         }
 126
 127         if(smallest != i)
 128         {
 129             m_aMacabRecords->swap(i,smallest);
 130         }
 131     }
 132
 133 }
 134
 135 void MacabResultSet::setTableName(OUString const & _sTableName)
 136 {
 137     m_sTableName = _sTableName;
 138 }
 139
 140 void MacabResultSet::disposing()
 141 {
 142     OPropertySetHelper::disposing();
 143
 144     ::osl::MutexGuard aGuard(m_aMutex);
 145
 146 m_xStatement.clear();
 147 m_xMetaData.clear();
 148 }
 149
 150 Any SAL_CALL MacabResultSet::queryInterface(const Type & rType) throw(RuntimeException)
 151 {
 152     Any aRet = OPropertySetHelper::queryInterface(rType);
 153     if (!aRet.hasValue())
 154         aRet = MacabResultSet_BASE::queryInterface(rType);
 155     return aRet;
 156 }
 157
 158 void SAL_CALL MacabResultSet::acquire() throw()
 159 {
 160     MacabResultSet_BASE::acquire();
 161 }
 162
 163 void SAL_CALL MacabResultSet::release() throw()
 164 {
 165     MacabResultSet_BASE::release();
 166 }
 167
 168 Sequence<  Type > SAL_CALL MacabResultSet::getTypes() throw(RuntimeException)
 169 {
 170     OTypeCollection aTypes(
 171         cppu::UnoType<com::sun::star::beans::XMultiPropertySet>::get(),
 172         cppu::UnoType<com::sun::star::beans::XFastPropertySet>::get(),
 173         cppu::UnoType<com::sun::star::beans::XPropertySet>::get());
 174
 175     return comphelper::concatSequences(aTypes.getTypes(), MacabResultSet_BASE::getTypes());
 176 }
 177
 178 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL MacabResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 179 {
 180     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 181 }
 182
 183 sal_Int32 SAL_CALL MacabResultSet::findColumn(const OUString& columnName) throw(SQLException, RuntimeException)
 184 {
 185     ::osl::MutexGuard aGuard( m_aMutex );
 186     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 187
 188     // find the first column with the name columnName
 189     Reference< XResultSetMetaData > xMeta = getMetaData();
 190     sal_Int32 nLen = xMeta->getColumnCount();
 191
 192     for (sal_Int32 i = 1; i <= nLen; ++i)
 193     {
 194         if (xMeta->isCaseSensitive(i) ?
 195             columnName == xMeta->getColumnName(i) :
 196             columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
 197                 return i;
 198     }
 199
 200     ::dbtools::throwInvalidColumnException( columnName, *this );
 201     assert(false);
 202     return 0; // Never reached
 203 }
 204
 205 OUString SAL_CALL MacabResultSet::getString(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
 206 {
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 209
 210     OUString aRet;
 211     sal_Int32 nRecords = m_aMacabRecords->size();
 212     m_bWasNull = true;
 213
 214     if (m_nRowPos != -1 && m_nRowPos != nRecords && m_xMetaData.is())
 215     {
 216         sal_Int32 nFieldNumber = m_xMetaData->fieldAtColumn(columnIndex);
 217         macabfield *aField = m_aMacabRecords->getField(m_nRowPos,nFieldNumber);
 218         if(aField != NULL)
 219         {
 220             if(aField->type == kABStringProperty)
 221             {
 222                 aRet = CFStringToOUString(static_cast<CFStringRef>(aField->value));
 223                 m_bWasNull = false;
 224             }
 225         }
 226     }
 227
 228 // Trigger an exception if m_bWasNull is true?
 229     return aRet;
 230 }
 231
 232 sal_Bool SAL_CALL MacabResultSet::getBoolean(sal_Int32) throw(SQLException, RuntimeException)
 233 {
 234     ::osl::MutexGuard aGuard( m_aMutex );
 235     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 236
 237 ::dbtools::throwFunctionNotSupportedSQLException("getBoolean", NULL);
 238
 239     return sal_False;
 240 }
 241
 242 sal_Int8 SAL_CALL MacabResultSet::getByte(sal_Int32) throw(SQLException, RuntimeException)
 243 {
 244     ::osl::MutexGuard aGuard( m_aMutex );
 245     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 246
 247 ::dbtools::throwFunctionNotSupportedSQLException("getByte", NULL);
 248
 249     sal_Int8 nRet = 0;
 250     return nRet;
 251 }
 252
 253 sal_Int16 SAL_CALL MacabResultSet::getShort(sal_Int32) throw(SQLException, RuntimeException)
 254 {
 255     ::osl::MutexGuard aGuard( m_aMutex );
 256     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 257
 258 ::dbtools::throwFunctionNotSupportedSQLException("getShort", NULL);
 259
 260     sal_Int16 nRet = 0;
 261     return nRet;
 262 }
 263
 264 sal_Int32 SAL_CALL MacabResultSet::getInt(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
 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 != NULL)
 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) throw(SQLException, RuntimeException)
 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 != NULL)
 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) throw(SQLException, RuntimeException)
 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 != NULL)
 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) throw(SQLException, RuntimeException)
 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 != NULL)
 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) throw(SQLException, RuntimeException)
 381 {
 382     ::osl::MutexGuard aGuard( m_aMutex );
 383     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 384
 385     ::dbtools::throwFunctionNotSupportedSQLException("getBytes", NULL);
 386
 387     return Sequence< sal_Int8 >();
 388 }
 389
 390 Date SAL_CALL MacabResultSet::getDate(sal_Int32) throw(SQLException, RuntimeException)
 391 {
 392     ::osl::MutexGuard aGuard( m_aMutex );
 393     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 394
 395     ::dbtools::throwFunctionNotSupportedSQLException("getDate", NULL);
 396
 397     Date aRet;
 398     return aRet;
 399 }
 400
 401 Time SAL_CALL MacabResultSet::getTime(sal_Int32) throw(SQLException, RuntimeException)
 402 {
 403     ::osl::MutexGuard aGuard( m_aMutex );
 404     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 405
 406     ::dbtools::throwFunctionNotSupportedSQLException("getTime", NULL);
 407
 408     css::util::Time nRet;
 409     return nRet;
 410 }
 411
 412 DateTime SAL_CALL MacabResultSet::getTimestamp(sal_Int32 columnIndex) throw(SQLException, RuntimeException)
 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 != NULL)
 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) throw(SQLException, RuntimeException)
 440 {
 441     ::osl::MutexGuard aGuard( m_aMutex );
 442     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 443
 444     ::dbtools::throwFunctionNotSupportedSQLException("getBinaryStream", NULL);
 445
 446     return NULL;
 447 }
 448
 449 Reference< XInputStream > SAL_CALL MacabResultSet::getCharacterStream(sal_Int32) throw(SQLException, RuntimeException)
 450 {
 451     ::osl::MutexGuard aGuard( m_aMutex );
 452     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 453
 454     ::dbtools::throwFunctionNotSupportedSQLException("getCharacterStream", NULL);
 455
 456     return NULL;
 457 }
 458
 459 Any SAL_CALL MacabResultSet::getObject(sal_Int32, const Reference< ::com::sun::star::container::XNameAccess >&) throw(SQLException, RuntimeException)
 460 {
 461     ::osl::MutexGuard aGuard( m_aMutex );
 462     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 463
 464     ::dbtools::throwFunctionNotSupportedSQLException("getObject", NULL);
 465
 466     return Any();
 467 }
 468
 469 Reference< XRef > SAL_CALL MacabResultSet::getRef(sal_Int32) throw(SQLException, RuntimeException)
 470 {
 471     ::osl::MutexGuard aGuard( m_aMutex );
 472     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 473
 474     ::dbtools::throwFunctionNotSupportedSQLException("getRef", NULL);
 475
 476     return NULL;
 477 }
 478
 479 Reference< XBlob > SAL_CALL MacabResultSet::getBlob(sal_Int32) throw(SQLException, RuntimeException)
 480 {
 481     ::osl::MutexGuard aGuard( m_aMutex );
 482     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 483
 484     ::dbtools::throwFunctionNotSupportedSQLException("getBlob", NULL);
 485
 486     return NULL;
 487 }
 488
 489 Reference< XClob > SAL_CALL MacabResultSet::getClob(sal_Int32) throw(SQLException, RuntimeException)
 490 {
 491     ::osl::MutexGuard aGuard( m_aMutex );
 492     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 493
 494 ::dbtools::throwFunctionNotSupportedSQLException("getClob", NULL);
 495
 496     return NULL;
 497 }
 498
 499 Reference< XArray > SAL_CALL MacabResultSet::getArray(sal_Int32) throw(SQLException, RuntimeException)
 500 {
 501     ::osl::MutexGuard aGuard( m_aMutex );
 502     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 503
 504 ::dbtools::throwFunctionNotSupportedSQLException("getArray", NULL);
 505
 506     return NULL;
 507 }
 508
 509 Reference< XResultSetMetaData > SAL_CALL MacabResultSet::getMetaData() throw(SQLException, RuntimeException)
 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.get();
 518     return xMetaData;
 519 }
 520
 521 sal_Bool SAL_CALL MacabResultSet::isBeforeFirst() throw(SQLException, RuntimeException)
 522 {
 523     ::osl::MutexGuard aGuard( m_aMutex );
 524     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 525
 526     if (m_nRowPos == -1)
 527         return sal_True;
 528
 529     return sal_False;
 530 }
 531
 532 sal_Bool SAL_CALL MacabResultSet::isAfterLast() throw(SQLException, RuntimeException)
 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 sal_True;
 540
 541     return sal_False;
 542 }
 543
 544 sal_Bool SAL_CALL MacabResultSet::isFirst() throw(SQLException, RuntimeException)
 545 {
 546     ::osl::MutexGuard aGuard( m_aMutex );
 547     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 548
 549     if (m_nRowPos == 0)
 550         return sal_True;
 551
 552     return sal_False;
 553 }
 554
 555 sal_Bool SAL_CALL MacabResultSet::isLast() throw(SQLException, RuntimeException)
 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 sal_True;
 563
 564     return sal_False;
 565 }
 566
 567 void SAL_CALL MacabResultSet::beforeFirst() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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 sal_False;
 603
 604     m_nRowPos = 0;
 605     return sal_True;
 606 }
 607
 608 sal_Bool SAL_CALL MacabResultSet::last() throw(SQLException, RuntimeException)
 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 sal_False;
 616
 617     m_nRowPos = nRecords - 1;
 618     return sal_True;
 619 }
 620
 621 sal_Int32 SAL_CALL MacabResultSet::getRow() throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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 sal_False;
 638
 639     m_nRowPos = row;
 640     return sal_True;
 641 }
 642
 643 sal_Bool SAL_CALL MacabResultSet::relative(sal_Int32 row) throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 668 {
 669     ::osl::MutexGuard aGuard( m_aMutex );
 670     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 671
 672     Reference< XStatement > xStatement = m_xStatement.get();
 673     return xStatement;
 674 }
 675
 676 sal_Bool SAL_CALL MacabResultSet::rowDeleted() throw(SQLException, RuntimeException)
 677 {
 678     ::osl::MutexGuard aGuard( m_aMutex );
 679     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 680
 681     return sal_False;
 682 }
 683
 684 sal_Bool SAL_CALL MacabResultSet::rowInserted() throw(SQLException, RuntimeException)
 685 {
 686     ::osl::MutexGuard aGuard( m_aMutex );
 687     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 688
 689     return sal_False;
 690 }
 691
 692 sal_Bool SAL_CALL MacabResultSet::rowUpdated() throw(SQLException, RuntimeException)
 693 {
 694     ::osl::MutexGuard aGuard( m_aMutex );
 695     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 696
 697     return sal_False;
 698 }
 699
 700 sal_Bool SAL_CALL MacabResultSet::wasNull() throw(SQLException, RuntimeException)
 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() throw(RuntimeException)
 709 {
 710     ::osl::MutexGuard aGuard( m_aMutex );
 711     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 712 }
 713
 714 void SAL_CALL MacabResultSet::clearWarnings() throw(SQLException, RuntimeException)
 715 {
 716 }
 717
 718 Any SAL_CALL MacabResultSet::getWarnings() throw(SQLException, RuntimeException)
 719 {
 720     return Any();
 721 }
 722
 723 void SAL_CALL MacabResultSet::insertRow() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 740 {
 741     ::osl::MutexGuard aGuard( m_aMutex );
 742     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 743 }
 744
 745 void SAL_CALL MacabResultSet::cancelRowUpdates() throw(SQLException, RuntimeException)
 746 {
 747     ::osl::MutexGuard aGuard( m_aMutex );
 748     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 749 }
 750
 751 void SAL_CALL MacabResultSet::moveToInsertRow() throw(SQLException, RuntimeException)
 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() throw(SQLException, RuntimeException)
 760 {
 761     ::osl::MutexGuard aGuard( m_aMutex );
 762     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 763 }
 764
 765 void SAL_CALL MacabResultSet::updateNull(sal_Int32) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 796 {
 797     ::osl::MutexGuard aGuard( m_aMutex );
 798     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 799 }
 800
 801 void SAL_CALL MacabResultSet::updateFloat(sal_Int32, float) throw(SQLException, RuntimeException)
 802 {
 803     ::osl::MutexGuard aGuard( m_aMutex );
 804     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 805 }
 806
 807 void SAL_CALL MacabResultSet::updateDouble(sal_Int32, double) throw(SQLException, RuntimeException)
 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&) throw(SQLException, RuntimeException)
 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 >&) throw(SQLException, RuntimeException)
 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&) throw(SQLException, RuntimeException)
 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&) throw(SQLException, RuntimeException)
 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&) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 850 {
 851     ::osl::MutexGuard aGuard( m_aMutex );
 852     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 853 }
 854
 855 void SAL_CALL MacabResultSet::refreshRow() throw(SQLException, RuntimeException)
 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&) throw(SQLException, RuntimeException)
 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) throw(SQLException, RuntimeException)
 868 {
 869     ::osl::MutexGuard aGuard( m_aMutex );
 870     checkDisposed(MacabResultSet_BASE::rBHelper.bDisposed);
 871 }
 872
 873 // XRowLocate
 874 Any SAL_CALL MacabResultSet::getBookmark() throw( SQLException,  RuntimeException)
 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,OUString("UID"));
 884         if(uidField != NULL)
 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) throw( SQLException,  RuntimeException)
 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,OUString("UID"));
 906         if(uidField != NULL)
 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 sal_True;
 915                 }
 916             }
 917         }
 918     }
 919     return sal_False;
 920 }
 921
 922 sal_Bool SAL_CALL MacabResultSet::moveRelativeToBookmark(const  Any& bookmark, sal_Int32 rows) throw( SQLException,  RuntimeException)
 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 sal_True;
 937     }
 938
 939     m_nRowPos = nRowSave;
 940     return sal_False;
 941 }
 942
 943 sal_Int32 SAL_CALL MacabResultSet::compareBookmarks(const  Any& firstItem, const  Any& secondItem) throw( SQLException,  RuntimeException)
 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() throw( SQLException,  RuntimeException)
 959 {
 960     return sal_False;
 961 }
 962
 963 sal_Int32 SAL_CALL MacabResultSet::hashBookmark(const  Any& bookmark) throw( SQLException,  RuntimeException)
 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 >&) throw( SQLException,  RuntimeException)
 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++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME),
 988         PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), PropertyAttribute::READONLY);
 989
 990     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
 991         PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
 992
 993     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
 994         PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
 995
 996     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),
 997         PROPERTY_ID_ISBOOKMARKABLE, cppu::UnoType<bool>::get(), PropertyAttribute::READONLY);
 998
 999     pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
1000         PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
1001
1002     pProperties[nPos++] = ::com::sun::star::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 *static_cast<MacabResultSet*>(this)->getArrayHelper();
1011 }
1012
1013 sal_Bool MacabResultSet::convertFastPropertyValue(
1014             Any &,
1015             Any &,
1016             sal_Int32 nHandle,
1017             const Any& )
1018                 throw (::com::sun::star::lang::IllegalArgumentException)
1019 {
1020     switch (nHandle)
1021     {
1022         case PROPERTY_ID_ISBOOKMARKABLE:
1023         case PROPERTY_ID_CURSORNAME:
1024         case PROPERTY_ID_RESULTSETCONCURRENCY:
1025         case PROPERTY_ID_RESULTSETTYPE:
1026             throw ::com::sun::star::lang::IllegalArgumentException();
1027             break;
1028         case PROPERTY_ID_FETCHDIRECTION:
1029         case PROPERTY_ID_FETCHSIZE:
1030         default:
1031             ;
1032     }
1033     return sal_False;
1034 }
1035
1036 void MacabResultSet::setFastPropertyValue_NoBroadcast(
1037             sal_Int32 nHandle,
1038             const Any& )
1039                  throw (Exception)
1040 {
1041     switch (nHandle)
1042     {
1043         case PROPERTY_ID_ISBOOKMARKABLE:
1044         case PROPERTY_ID_CURSORNAME:
1045         case PROPERTY_ID_RESULTSETCONCURRENCY:
1046         case PROPERTY_ID_RESULTSETTYPE:
1047             throw Exception();
1048             break;
1049         case PROPERTY_ID_FETCHDIRECTION:
1050             break;
1051         case PROPERTY_ID_FETCHSIZE:
1052             break;
1053         default:
1054             ;
1055     }
1056 }
1057
1058 void MacabResultSet::getFastPropertyValue(
1059             Any& _rValue,
1060             sal_Int32 nHandle) const
1061 {
1062     switch (nHandle)
1063     {
1064         case PROPERTY_ID_ISBOOKMARKABLE:
1065             _rValue <<= false;
1066             break;
1067         case PROPERTY_ID_CURSORNAME:
1068         case PROPERTY_ID_RESULTSETCONCURRENCY:
1069         case PROPERTY_ID_RESULTSETTYPE:
1070         case PROPERTY_ID_FETCHDIRECTION:
1071         case PROPERTY_ID_FETCHSIZE:
1072             ;
1073     }
1074 }
1075
1076
1077 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */