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