ucb/source/ucp/file/filrset.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <com/sun/star/sdbc/SQLException.hpp>
  24 #include <com/sun/star/ucb/ListenerAlreadySetException.hpp>
  25 #include <com/sun/star/ucb/ServiceNotFoundException.hpp>
  26 #include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp>
  27 #include "filid.hxx"
  28 #include "filtask.hxx"
  29 #include "filprp.hxx"
  30 #include "filrset.hxx"
  31 #include <com/sun/star/ucb/OpenMode.hpp>
  32 #include "prov.hxx"
  33 #include <com/sun/star/uno/Reference.h>
  34
  35 #include <com/sun/star/beans/PropertyAttribute.hpp>
  36 #include <com/sun/star/ucb/ListActionType.hpp>
  37 #include <com/sun/star/ucb/XSourceInitialization.hpp>
  38 #include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp>
  39 #include <ucbhelper/resultsetmetadata.hxx>
  40
  41 using namespace fileaccess;
  42 using namespace com::sun::star;
  43
  44 #if OSL_DEBUG_LEVEL > 0
  45 #define THROW_WHERE SAL_WHERE
  46 #else
  47 #define THROW_WHERE ""
  48 #endif
  49
  50 XResultSet_impl::XResultSet_impl( TaskManager* pMyShell,
  51                                   const OUString& aUnqPath,
  52                                   sal_Int32 OpenMode,
  53                                   const uno::Sequence< beans::Property >& seq,
  54                                   const uno::Sequence< ucb::NumberedSortingInfo >& seqSort )
  55     : m_pMyShell( pMyShell )
  56     , m_nRow( -1 )
  57     , m_nWasNull ( false )
  58     , m_nOpenMode( OpenMode )
  59     , m_bRowCountFinal( false )
  60     , m_aBaseDirectory( aUnqPath )
  61     , m_aFolder( aUnqPath )
  62     , m_sProperty( seq )
  63     , m_sSortingInfo( seqSort )
  64     , m_nErrorCode( TASKHANDLER_NO_ERROR )
  65     , m_nMinorErrorCode( TASKHANDLER_NO_ERROR )
  66 {
  67     osl::FileBase::RC err = m_aFolder.open();
  68     if(  err != osl::FileBase::E_None )
  69     {
  70         m_nIsOpen = false;
  71         m_aFolder.close();
  72
  73         m_nErrorCode = TASKHANDLING_OPEN_FOR_DIRECTORYLISTING;
  74         m_nMinorErrorCode = err;
  75     }
  76     else
  77         m_nIsOpen = true;
  78 }
  79
  80
  81 XResultSet_impl::~XResultSet_impl()
  82 {
  83     if( m_nIsOpen )
  84         m_aFolder.close();
  85 }
  86
  87
  88 void SAL_CALL
  89 XResultSet_impl::disposing( const lang::EventObject& )
  90 {
  91     // To do, but what
  92 }
  93
  94
  95 void SAL_CALL
  96 XResultSet_impl::addEventListener(
  97     const uno::Reference< lang::XEventListener >& Listener )
  98 {
  99     std::unique_lock aGuard( m_aMutex );
 100
 101     m_aDisposeEventListeners.addInterface( aGuard, Listener );
 102 }
 103
 104
 105 void SAL_CALL
 106 XResultSet_impl::removeEventListener(
 107     const uno::Reference< lang::XEventListener >& Listener )
 108 {
 109     std::unique_lock aGuard( m_aMutex );
 110
 111     m_aDisposeEventListeners.removeInterface( aGuard, Listener );
 112 }
 113
 114
 115 void SAL_CALL
 116 XResultSet_impl::dispose()
 117 {
 118     std::unique_lock aGuard( m_aMutex );
 119
 120     lang::EventObject aEvt;
 121     aEvt.Source = static_cast< lang::XComponent * >( this );
 122
 123     m_aDisposeEventListeners.disposeAndClear( aGuard, aEvt );
 124     m_aRowCountListeners.disposeAndClear( aGuard, aEvt );
 125     m_aIsFinalListeners.disposeAndClear( aGuard, aEvt );
 126 }
 127
 128
 129 void XResultSet_impl::rowCountChanged(std::unique_lock<std::mutex>& rGuard)
 130 {
 131     sal_Int32 aOldValue,aNewValue;
 132     std::vector< uno::Reference< beans::XPropertyChangeListener > > seq = m_aRowCountListeners.getElements(rGuard);
 133     aNewValue = m_aItems.size();
 134     aOldValue = aNewValue-1;
 135     beans::PropertyChangeEvent aEv;
 136     aEv.PropertyName = "RowCount";
 137     aEv.Further = false;
 138     aEv.PropertyHandle = -1;
 139     aEv.OldValue <<= aOldValue;
 140     aEv.NewValue <<= aNewValue;
 141     for( const auto& listener : seq )
 142         listener->propertyChange( aEv );
 143 }
 144
 145
 146 void XResultSet_impl::isFinalChanged()
 147 {
 148     std::vector< uno::Reference< beans::XPropertyChangeListener > > seq;
 149     {
 150         std::unique_lock aGuard( m_aMutex );
 151         seq = m_aIsFinalListeners.getElements(aGuard);
 152         m_bRowCountFinal = true;
 153     }
 154     beans::PropertyChangeEvent aEv;
 155     aEv.PropertyName = "IsRowCountFinal";
 156     aEv.Further = false;
 157     aEv.PropertyHandle = -1;
 158     aEv.OldValue <<= false;
 159     aEv.NewValue <<= true;
 160     for( const auto& listener : seq )
 161         listener->propertyChange( aEv );
 162 }
 163
 164
 165 bool
 166 XResultSet_impl::OneMore()
 167 {
 168     if( ! m_nIsOpen )
 169         return false;
 170
 171     osl::FileBase::RC err;
 172     bool IsRegular;
 173     OUString aUnqPath;
 174     osl::DirectoryItem  aDirIte;
 175     uno::Reference< sdbc::XRow > aRow;
 176
 177     while( true )
 178     {
 179         err = m_aFolder.getNextItem( aDirIte );
 180
 181         if( err == osl::FileBase::E_NOENT || err == osl::FileBase::E_INVAL )
 182         {
 183             m_aFolder.close();
 184             isFinalChanged();
 185             m_nIsOpen = false;
 186             return m_nIsOpen;
 187         }
 188         else if( err == osl::FileBase::E_None )
 189         {
 190             if (!m_pMyShell->getv( m_sProperty, aDirIte, aUnqPath, IsRegular, aRow ))
 191             {
 192                 SAL_WARN(
 193                     "ucb.ucp.file",
 194                     "getting dir item in <" << m_aBaseDirectory << "> failed");
 195                 continue;
 196             }
 197
 198             if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && IsRegular )
 199             {
 200                 std::unique_lock aGuard( m_aMutex );
 201                 m_aItems.push_back( aRow );
 202                 m_aIdents.emplace_back( );
 203                 m_aUnqPath.push_back( aUnqPath );
 204                 rowCountChanged(aGuard);
 205                 return true;
 206
 207             }
 208             else if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && ! IsRegular )
 209             {
 210                 continue;
 211             }
 212             else if( m_nOpenMode == ucb::OpenMode::FOLDERS && ! IsRegular )
 213             {
 214                 std::unique_lock aGuard( m_aMutex );
 215                 m_aItems.push_back( aRow );
 216                 m_aIdents.emplace_back( );
 217                 m_aUnqPath.push_back( aUnqPath );
 218                 rowCountChanged(aGuard);
 219                 return true;
 220             }
 221             else if( m_nOpenMode == ucb::OpenMode::FOLDERS && IsRegular )
 222             {
 223                 continue;
 224             }
 225             else
 226             {
 227                 std::unique_lock aGuard( m_aMutex );
 228                 m_aItems.push_back( aRow );
 229                 m_aIdents.emplace_back( );
 230                 m_aUnqPath.push_back( aUnqPath );
 231                 rowCountChanged(aGuard);
 232                 return true;
 233             }
 234         }
 235         else  // error fetching anything
 236         {
 237             throw sdbc::SQLException( THROW_WHERE, uno::Reference< uno::XInterface >(), OUString(), 0, uno::Any() );
 238         }
 239     }
 240 }
 241
 242
 243 sal_Bool SAL_CALL
 244 XResultSet_impl::next()
 245 {
 246     bool test;
 247     if( ++m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) ) test = true;
 248     else
 249         test = OneMore();
 250     return test;
 251 }
 252
 253
 254 sal_Bool SAL_CALL
 255 XResultSet_impl::isBeforeFirst()
 256 {
 257     return m_nRow == -1;
 258 }
 259
 260
 261 sal_Bool SAL_CALL
 262 XResultSet_impl::isAfterLast()
 263 {
 264     return m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size());   // Cannot happen, if m_aFolder.isOpen()
 265 }
 266
 267
 268 sal_Bool SAL_CALL
 269 XResultSet_impl::isFirst()
 270 {
 271     return m_nRow == 0;
 272 }
 273
 274
 275 sal_Bool SAL_CALL
 276 XResultSet_impl::isLast()
 277 {
 278     if( m_nRow ==  sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1 )
 279         return ! OneMore();
 280     else
 281         return false;
 282 }
 283
 284
 285 void SAL_CALL
 286 XResultSet_impl::beforeFirst()
 287 {
 288     m_nRow = -1;
 289 }
 290
 291
 292 void SAL_CALL
 293 XResultSet_impl::afterLast()
 294 {
 295     m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size());
 296     while( OneMore() )
 297         ++m_nRow;
 298 }
 299
 300
 301 sal_Bool SAL_CALL
 302 XResultSet_impl::first()
 303 {
 304     m_nRow = -1;
 305     return next();
 306 }
 307
 308
 309 sal_Bool SAL_CALL
 310 XResultSet_impl::last()
 311 {
 312     m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1;
 313     while( OneMore() )
 314         ++m_nRow;
 315     return true;
 316 }
 317
 318
 319 sal_Int32 SAL_CALL
 320 XResultSet_impl::getRow()
 321 {
 322     // Test, whether behind last row
 323     if( -1 == m_nRow || m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 324         return 0;
 325     else
 326         return m_nRow+1;
 327 }
 328
 329
 330 sal_Bool SAL_CALL XResultSet_impl::absolute( sal_Int32 row )
 331 {
 332     if( row >= 0 )
 333     {
 334         m_nRow = row - 1;
 335         if( row >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 336             while( row-- && OneMore() )
 337                 ;
 338     }
 339     else
 340     {
 341         last();
 342         m_nRow += ( row + 1 );
 343         if( m_nRow < -1 )
 344             m_nRow = -1;
 345     }
 346
 347     return 0<= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 348 }
 349
 350
 351 sal_Bool SAL_CALL
 352 XResultSet_impl::relative( sal_Int32 row )
 353 {
 354     if( isAfterLast() || isBeforeFirst() )
 355         throw sdbc::SQLException( THROW_WHERE, uno::Reference< uno::XInterface >(), OUString(), 0, uno::Any() );
 356     if( row > 0 )
 357         while( row-- ) next();
 358     else if( row < 0 )
 359         while( row++ && m_nRow > - 1 ) previous();
 360
 361     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 362 }
 363
 364
 365 sal_Bool SAL_CALL
 366 XResultSet_impl::previous()
 367 {
 368     if( m_nRow > sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 369         m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size());  // Correct Handling of afterLast
 370     if( 0 <= m_nRow ) -- m_nRow;
 371
 372     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 373 }
 374
 375
 376 void SAL_CALL
 377 XResultSet_impl::refreshRow()
 378 {
 379     // get the row from the filesystem
 380 }
 381
 382
 383 sal_Bool SAL_CALL
 384 XResultSet_impl::rowUpdated()
 385 {
 386     return false;
 387 }
 388
 389 sal_Bool SAL_CALL
 390 XResultSet_impl::rowInserted()
 391 {
 392     return false;
 393 }
 394
 395 sal_Bool SAL_CALL
 396 XResultSet_impl::rowDeleted()
 397 {
 398     return false;
 399 }
 400
 401
 402 uno::Reference< uno::XInterface > SAL_CALL
 403 XResultSet_impl::getStatement()
 404 {
 405     return uno::Reference< uno::XInterface >();
 406 }
 407
 408
 409 // XCloseable
 410
 411 void SAL_CALL
 412 XResultSet_impl::close()
 413 {
 414     if( m_nIsOpen )
 415     {
 416         m_aFolder.close();
 417         isFinalChanged();
 418         std::unique_lock aGuard( m_aMutex );
 419         m_nIsOpen = false;
 420     }
 421 }
 422
 423
 424 OUString SAL_CALL
 425 XResultSet_impl::queryContentIdentifierString()
 426 {
 427     uno::Reference< ucb::XContentIdentifier > xContentId
 428         = queryContentIdentifier();
 429
 430     if( xContentId.is() )
 431         return xContentId->getContentIdentifier();
 432     else
 433         return OUString();
 434 }
 435
 436
 437 uno::Reference< ucb::XContentIdentifier > SAL_CALL
 438 XResultSet_impl::queryContentIdentifier()
 439 {
 440     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 441     {
 442         if( ! m_aIdents[m_nRow].is() )
 443         {
 444             m_aIdents[m_nRow].set( new FileContentIdentifier( m_aUnqPath[  m_nRow ] ) );
 445         }
 446         return m_aIdents[m_nRow];
 447     }
 448     return uno::Reference< ucb::XContentIdentifier >();
 449 }
 450
 451
 452 uno::Reference< ucb::XContent > SAL_CALL
 453 XResultSet_impl::queryContent()
 454 {
 455     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 456         return m_pMyShell->m_pProvider->queryContent( queryContentIdentifier() );
 457     else
 458         return uno::Reference< ucb::XContent >();
 459 }
 460
 461
 462 // XDynamicResultSet
 463
 464
 465 // virtual
 466 uno::Reference< sdbc::XResultSet > SAL_CALL
 467 XResultSet_impl::getStaticResultSet()
 468 {
 469     std::unique_lock aGuard( m_aMutex );
 470
 471     if ( m_xListener.is() )
 472         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 473
 474     return uno::Reference< sdbc::XResultSet >( this );
 475 }
 476
 477
 478 // virtual
 479 void SAL_CALL
 480 XResultSet_impl::setListener(
 481     const uno::Reference< ucb::XDynamicResultSetListener >& Listener )
 482 {
 483     std::unique_lock aGuard( m_aMutex );
 484
 485     if ( m_xListener.is() )
 486         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 487
 488     m_xListener = Listener;
 489
 490
 491     // Create "welcome event" and send it to listener.
 492
 493
 494     // Note: We only have the implementation for a static result set at the
 495     //       moment (src590). The dynamic result sets passed to the listener
 496     //       are a fake. This implementation will never call "notify" at the
 497     //       listener to propagate any changes!!!
 498
 499     uno::Any aInfo;
 500     aInfo <<= ucb::WelcomeDynamicResultSetStruct( this, /* "old" */
 501                                                   this /* "new" */ );
 502
 503     uno::Sequence< ucb::ListAction > aActions( 1 );
 504     aActions.getArray()[ 0 ] = ucb::ListAction( 0, // Position; not used
 505                                                 0, // Count; not used
 506                                                 ucb::ListActionType::WELCOME,
 507                                                 aInfo );
 508     aGuard.unlock();
 509
 510     Listener->notify(
 511         ucb::ListEvent(
 512             static_cast< cppu::OWeakObject * >( this ), aActions ) );
 513 }
 514
 515
 516 // virtual
 517 void SAL_CALL
 518 XResultSet_impl::connectToCache(
 519     const uno::Reference< ucb::XDynamicResultSet > & xCache )
 520 {
 521     if( m_xListener.is() )
 522         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 523
 524     uno::Reference< ucb::XSourceInitialization > xTarget(
 525         xCache, uno::UNO_QUERY );
 526     if( xTarget.is() && m_pMyShell->m_xContext.is() )
 527     {
 528         uno::Reference< ucb::XCachedDynamicResultSetStubFactory > xStubFactory;
 529         try
 530         {
 531             xStubFactory
 532                 = ucb::CachedDynamicResultSetStubFactory::create(
 533                     m_pMyShell->m_xContext );
 534         }
 535         catch ( uno::Exception const & )
 536         {
 537         }
 538
 539         if( xStubFactory.is() )
 540         {
 541             xStubFactory->connectToCache(
 542                 this, xCache,m_sSortingInfo, nullptr );
 543             return;
 544         }
 545     }
 546     throw ucb::ServiceNotFoundException( THROW_WHERE );
 547 }
 548
 549
 550 // virtual
 551 sal_Int16 SAL_CALL
 552 XResultSet_impl::getCapabilities()
 553 {
 554     // Never set ucb::ContentResultSetCapability::SORTED
 555     //  - Underlying content cannot provide sorted data...
 556     return 0;
 557 }
 558
 559 // XResultSetMetaDataSupplier
 560 uno::Reference< sdbc::XResultSetMetaData > SAL_CALL
 561 XResultSet_impl::getMetaData()
 562 {
 563     auto pProp = std::find_if(std::cbegin(m_sProperty), std::cend(m_sProperty),
 564         [](const beans::Property& rProp) { return rProp.Name == "Title"; });
 565     if (pProp != std::cend(m_sProperty))
 566     {
 567         std::vector< ::ucbhelper::ResultSetColumnData >
 568                                 aColumnData( m_sProperty.getLength() );
 569         auto n = std::distance(std::cbegin(m_sProperty), pProp);
 570         // @@@ #82177# - Determine correct value!
 571         aColumnData[ n ].isCaseSensitive = false;
 572
 573         return new ::ucbhelper::ResultSetMetaData(
 574                 m_pMyShell->m_xContext,
 575                 m_sProperty,
 576                 std::move(aColumnData) );
 577     }
 578
 579     return new ::ucbhelper::ResultSetMetaData( m_pMyShell->m_xContext, m_sProperty );
 580 }
 581
 582
 583 // XPropertySet
 584 uno::Reference< beans::XPropertySetInfo > SAL_CALL
 585 XResultSet_impl::getPropertySetInfo()
 586 {
 587
 588     uno::Sequence< beans::Property > seq
 589     {
 590         { "RowCount", -1, cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY },
 591         { "IsRowCountFinal", -1, cppu::UnoType<sal_Bool>::get(), beans::PropertyAttribute::READONLY }
 592     };
 593
 594     return new XPropertySetInfo_impl( m_pMyShell, seq );
 595 }
 596
 597
 598 void SAL_CALL XResultSet_impl::setPropertyValue(
 599     const OUString& aPropertyName, const uno::Any& )
 600 {
 601     if( aPropertyName == "IsRowCountFinal" ||
 602         aPropertyName == "RowCount" )
 603         return;
 604     throw beans::UnknownPropertyException( aPropertyName );
 605 }
 606
 607
 608 uno::Any SAL_CALL XResultSet_impl::getPropertyValue(
 609     const OUString& PropertyName )
 610 {
 611     if( PropertyName == "IsRowCountFinal" )
 612     {
 613         return uno::Any(m_bRowCountFinal);
 614     }
 615     else if ( PropertyName == "RowCount" )
 616     {
 617         sal_Int32 count = sal::static_int_cast<sal_Int32>(m_aItems.size());
 618         return uno::Any(count);
 619     }
 620     else
 621         throw beans::UnknownPropertyException( PropertyName );
 622 }
 623
 624
 625 void SAL_CALL XResultSet_impl::addPropertyChangeListener(
 626     const OUString& aPropertyName,
 627     const uno::Reference< beans::XPropertyChangeListener >& xListener )
 628 {
 629     if( aPropertyName == "IsRowCountFinal" )
 630     {
 631         std::unique_lock aGuard( m_aMutex );
 632
 633         m_aIsFinalListeners.addInterface( aGuard, xListener );
 634     }
 635     else if ( aPropertyName == "RowCount" )
 636     {
 637         std::unique_lock aGuard( m_aMutex );
 638
 639         m_aRowCountListeners.addInterface( aGuard, xListener );
 640     }
 641     else
 642         throw beans::UnknownPropertyException( aPropertyName );
 643 }
 644
 645
 646 void SAL_CALL XResultSet_impl::removePropertyChangeListener(
 647     const OUString& aPropertyName,
 648     const uno::Reference< beans::XPropertyChangeListener >& aListener )
 649 {
 650     if( aPropertyName == "IsRowCountFinal" )
 651     {
 652         std::unique_lock aGuard( m_aMutex );
 653
 654         m_aIsFinalListeners.removeInterface( aGuard, aListener );
 655     }
 656     else if ( aPropertyName == "RowCount" )
 657     {
 658         std::unique_lock aGuard( m_aMutex );
 659
 660         m_aRowCountListeners.removeInterface( aGuard, aListener );
 661     }
 662     else
 663         throw beans::UnknownPropertyException( aPropertyName );
 664 }
 665
 666 void SAL_CALL XResultSet_impl::addVetoableChangeListener(
 667     const OUString&,
 668     const uno::Reference< beans::XVetoableChangeListener >& )
 669 {
 670 }
 671
 672
 673 void SAL_CALL XResultSet_impl::removeVetoableChangeListener(
 674     const OUString&,
 675     const uno::Reference< beans::XVetoableChangeListener >& )
 676 {
 677 }
 678
 679 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */