ucb/source/ucp/ftp/ftpresultsetbase.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 <comphelper/processfactory.hxx>
  21 #include <ucbhelper/contentidentifier.hxx>
  22 #include <com/sun/star/ucb/OpenMode.hpp>
  23 #include <com/sun/star/uno/Reference.h>
  24 #include <com/sun/star/beans/PropertyAttribute.hpp>
  25 #include <com/sun/star/ucb/ListActionType.hpp>
  26 #include <com/sun/star/ucb/XSourceInitialization.hpp>
  27 #include <ucbhelper/resultsetmetadata.hxx>
  28 #include "ftpresultsetbase.hxx"
  29
  30 using namespace ftp;
  31 using namespace com::sun::star;
  32
  33 ResultSetBase::ResultSetBase(
  34     const uno::Reference< uno::XComponentContext >&  rxContext,
  35     const uno::Reference< ucb::XContentProvider >&  xProvider,
  36     sal_Int32 nOpenMode,
  37     const uno::Sequence< beans::Property >& seq,
  38     const uno::Sequence< ucb::NumberedSortingInfo >& seqSort )
  39     : m_xContext( rxContext ),
  40       m_xProvider( xProvider ),
  41       m_nRow( -1 ),
  42       m_nWasNull( true ),
  43       m_nOpenMode( nOpenMode ),
  44       m_bRowCountFinal( true ),
  45       m_sProperty( seq ),
  46       m_sSortingInfo( seqSort ),
  47       m_pDisposeEventListeners( 0 ),
  48       m_pRowCountListeners( 0 ),
  49       m_pIsFinalListeners( 0 )
  50 {
  51 }
  52
  53 ResultSetBase::~ResultSetBase()
  54 {
  55     delete m_pIsFinalListeners;
  56     delete m_pRowCountListeners;
  57     delete m_pDisposeEventListeners;
  58 }
  59
  60
  61 // XInterface
  62
  63 void SAL_CALL
  64 ResultSetBase::acquire(
  65     void )
  66     throw()
  67 {
  68     OWeakObject::acquire();
  69 }
  70
  71
  72 void SAL_CALL
  73 ResultSetBase::release(
  74     void )
  75     throw()
  76 {
  77     OWeakObject::release();
  78 }
  79
  80
  81
  82 uno::Any SAL_CALL
  83 ResultSetBase::queryInterface(
  84     const uno::Type& rType )
  85     throw( uno::RuntimeException, std::exception )
  86 {
  87     uno::Any aRet = cppu::queryInterface(
  88         rType,
  89         (static_cast< lang::XComponent* >(this)),
  90         (static_cast< sdbc::XRow* >(this)),
  91         (static_cast< sdbc::XResultSet* >(this)),
  92         (static_cast< sdbc::XResultSetMetaDataSupplier* >(this)),
  93         (static_cast< beans::XPropertySet* >(this)),
  94         (static_cast< ucb::XContentAccess* >(this)) );
  95     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
  96 }
  97
  98
  99
 100 // XComponent
 101
 102
 103 void SAL_CALL
 104 ResultSetBase::addEventListener(
 105     const uno::Reference< lang::XEventListener >& Listener )
 106     throw( uno::RuntimeException, std::exception )
 107 {
 108     osl::MutexGuard aGuard( m_aMutex );
 109
 110     if ( ! m_pDisposeEventListeners )
 111         m_pDisposeEventListeners =
 112             new cppu::OInterfaceContainerHelper( m_aMutex );
 113
 114     m_pDisposeEventListeners->addInterface( Listener );
 115 }
 116
 117
 118 void SAL_CALL
 119 ResultSetBase::removeEventListener(
 120     const uno::Reference< lang::XEventListener >& Listener )
 121     throw( uno::RuntimeException, std::exception )
 122 {
 123     osl::MutexGuard aGuard( m_aMutex );
 124
 125     if ( m_pDisposeEventListeners )
 126         m_pDisposeEventListeners->removeInterface( Listener );
 127 }
 128
 129
 130
 131 void SAL_CALL
 132 ResultSetBase::dispose()
 133     throw( uno::RuntimeException, std::exception )
 134 {
 135     osl::MutexGuard aGuard( m_aMutex );
 136
 137     lang::EventObject aEvt;
 138     aEvt.Source = static_cast< lang::XComponent * >( this );
 139
 140     if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
 141     {
 142         m_pDisposeEventListeners->disposeAndClear( aEvt );
 143     }
 144     if( m_pRowCountListeners && m_pRowCountListeners->getLength() )
 145     {
 146         m_pRowCountListeners->disposeAndClear( aEvt );
 147     }
 148     if( m_pIsFinalListeners && m_pIsFinalListeners->getLength() )
 149     {
 150         m_pIsFinalListeners->disposeAndClear( aEvt );
 151     }
 152 }
 153
 154
 155
 156 //  XResultSet
 157
 158 sal_Bool SAL_CALL
 159 ResultSetBase::next(
 160     void )
 161     throw( sdbc::SQLException,
 162            uno::RuntimeException, std::exception )
 163 {
 164     bool test;
 165     if( ++m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 166         test = true;
 167     else
 168         test = false;
 169     return test;
 170 }
 171
 172
 173 sal_Bool SAL_CALL
 174 ResultSetBase::isBeforeFirst(
 175     void )
 176     throw( sdbc::SQLException,
 177            uno::RuntimeException, std::exception )
 178 {
 179     return m_nRow == -1;
 180 }
 181
 182
 183 sal_Bool SAL_CALL
 184 ResultSetBase::isAfterLast(
 185     void )
 186     throw( sdbc::SQLException,
 187            uno::RuntimeException, std::exception )
 188 {
 189     return m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size());   // Cannot happen, if m_aFolder.isOpen()
 190 }
 191
 192
 193 sal_Bool SAL_CALL
 194 ResultSetBase::isFirst(
 195     void )
 196     throw( sdbc::SQLException,
 197            uno::RuntimeException, std::exception )
 198 {
 199     return m_nRow == 0;
 200 }
 201
 202
 203 sal_Bool SAL_CALL
 204 ResultSetBase::isLast(
 205     void  )
 206     throw( sdbc::SQLException,
 207            uno::RuntimeException, std::exception)
 208 {
 209     if( m_nRow ==  sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1 )
 210         return true;
 211     else
 212         return false;
 213 }
 214
 215
 216 void SAL_CALL
 217 ResultSetBase::beforeFirst(
 218     void  )
 219     throw( sdbc::SQLException,
 220            uno::RuntimeException, std::exception)
 221 {
 222     m_nRow = -1;
 223 }
 224
 225
 226 void SAL_CALL
 227 ResultSetBase::afterLast(
 228     void  )
 229     throw( sdbc::SQLException,
 230            uno::RuntimeException, std::exception )
 231 {
 232     m_nRow = m_aItems.size();
 233 }
 234
 235
 236 sal_Bool SAL_CALL
 237 ResultSetBase::first(
 238     void  )
 239     throw( sdbc::SQLException,
 240            uno::RuntimeException, std::exception)
 241 {
 242     m_nRow = -1;
 243     return next();
 244 }
 245
 246
 247 sal_Bool SAL_CALL
 248 ResultSetBase::last(
 249     void  )
 250     throw( sdbc::SQLException,
 251            uno::RuntimeException, std::exception )
 252 {
 253     m_nRow = m_aItems.size() - 1;
 254     return true;
 255 }
 256
 257
 258 sal_Int32 SAL_CALL
 259 ResultSetBase::getRow(
 260     void )
 261     throw( sdbc::SQLException,
 262            uno::RuntimeException, std::exception)
 263 {
 264     // Test, whether behind last row
 265     if( -1 == m_nRow || m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 266         return 0;
 267     else
 268         return m_nRow+1;
 269 }
 270
 271
 272 sal_Bool SAL_CALL ResultSetBase::absolute( sal_Int32 row )
 273     throw( sdbc::SQLException, uno::RuntimeException, std::exception)
 274 {
 275     if( row >= 0 )
 276         m_nRow = row - 1;
 277     else
 278     {
 279         last();
 280         m_nRow += ( row + 1 );
 281         if( m_nRow < -1 )
 282             m_nRow = -1;
 283     }
 284
 285     return 0<= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 286 }
 287
 288
 289
 290
 291 sal_Bool SAL_CALL
 292 ResultSetBase::relative(
 293     sal_Int32 row )
 294     throw( sdbc::SQLException,
 295            uno::RuntimeException, std::exception)
 296 {
 297     if( isAfterLast() || isBeforeFirst() )
 298         throw sdbc::SQLException();
 299
 300     if( row > 0 )
 301         while( row-- )
 302             next();
 303     else if( row < 0 )
 304         while( row++ && m_nRow > - 1 )
 305             previous();
 306
 307     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 308 }
 309
 310
 311
 312 sal_Bool SAL_CALL
 313 ResultSetBase::previous(
 314     void )
 315     throw( sdbc::SQLException,
 316            uno::RuntimeException, std::exception)
 317 {
 318     if( m_nRow > sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 319         m_nRow = m_aItems.size();  // Correct Handling of afterLast
 320     if( 0 <= m_nRow ) -- m_nRow;
 321
 322     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 323 }
 324
 325
 326 void SAL_CALL
 327 ResultSetBase::refreshRow(
 328     void )
 329     throw( sdbc::SQLException,
 330            uno::RuntimeException, std::exception)
 331 {
 332 }
 333
 334
 335 sal_Bool SAL_CALL
 336 ResultSetBase::rowUpdated(
 337     void )
 338     throw( sdbc::SQLException,
 339            uno::RuntimeException, std::exception )
 340 {
 341     return false;
 342 }
 343
 344 sal_Bool SAL_CALL
 345 ResultSetBase::rowInserted(
 346     void  )
 347     throw( sdbc::SQLException,
 348            uno::RuntimeException, std::exception )
 349 {
 350     return false;
 351 }
 352
 353 sal_Bool SAL_CALL
 354 ResultSetBase::rowDeleted(
 355     void  )
 356     throw( sdbc::SQLException,
 357            uno::RuntimeException, std::exception )
 358 {
 359     return false;
 360 }
 361
 362
 363 uno::Reference< uno::XInterface > SAL_CALL
 364 ResultSetBase::getStatement(
 365     void  )
 366     throw( sdbc::SQLException,
 367            uno::RuntimeException, std::exception )
 368 {
 369     uno::Reference< uno::XInterface > test( 0 );
 370     return test;
 371 }
 372
 373
 374 // XCloseable
 375
 376 void SAL_CALL
 377 ResultSetBase::close(
 378     void )
 379     throw( sdbc::SQLException,
 380            uno::RuntimeException, std::exception)
 381 {
 382 }
 383
 384
 385 OUString SAL_CALL
 386 ResultSetBase::queryContentIdentifierString(
 387     void )
 388     throw( uno::RuntimeException, std::exception )
 389 {
 390     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 391         return m_aPath[m_nRow];
 392     else
 393         return OUString();
 394 }
 395
 396
 397 uno::Reference< ucb::XContentIdentifier > SAL_CALL
 398 ResultSetBase::queryContentIdentifier(
 399     void
 400 )
 401     throw(
 402         uno::RuntimeException, std::exception
 403     )
 404 {
 405     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 406     {
 407         if(!m_aIdents[m_nRow].is()) {
 408             OUString url = queryContentIdentifierString();
 409             if(!url.isEmpty() )
 410                 m_aIdents[m_nRow] =
 411                     uno::Reference< ucb::XContentIdentifier >(
 412                         new ::ucbhelper::ContentIdentifier(url) );
 413         }
 414         return m_aIdents[m_nRow];
 415     }
 416
 417     return uno::Reference<ucb::XContentIdentifier>();
 418 }
 419
 420
 421 uno::Reference< ucb::XContent > SAL_CALL
 422 ResultSetBase::queryContent(
 423     void )
 424     throw( uno::RuntimeException, std::exception )
 425 {
 426     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 427         return m_xProvider->queryContent(queryContentIdentifier());
 428     else
 429         return uno::Reference< ucb::XContent >();
 430 }
 431
 432
 433
 434 class XPropertySetInfoImpl
 435     : public cppu::OWeakObject,
 436       public beans::XPropertySetInfo
 437 {
 438 public:
 439
 440     XPropertySetInfoImpl( const uno::Sequence< beans::Property >& aSeq )
 441         : m_aSeq( aSeq )
 442     {
 443     }
 444
 445     void SAL_CALL acquire()
 446         throw() SAL_OVERRIDE
 447     {
 448         OWeakObject::acquire();
 449     }
 450
 451
 452     void SAL_CALL release()
 453         throw() SAL_OVERRIDE
 454     {
 455         OWeakObject::release();
 456     }
 457
 458     uno::Any SAL_CALL queryInterface( const uno::Type& rType )
 459         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
 460     {
 461         uno::Any aRet = cppu::queryInterface(
 462             rType,
 463             (static_cast< beans::XPropertySetInfo* >(this)) );
 464         return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 465     }
 466
 467     uno::Sequence< beans::Property > SAL_CALL getProperties()
 468         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
 469     {
 470         return m_aSeq;
 471     }
 472
 473     beans::Property SAL_CALL getPropertyByName( const OUString& aName )
 474         throw( beans::UnknownPropertyException,
 475                uno::RuntimeException, std::exception) SAL_OVERRIDE
 476     {
 477         for( int i = 0; i < m_aSeq.getLength(); ++i )
 478             if( aName == m_aSeq[i].Name )
 479                 return m_aSeq[i];
 480         throw beans::UnknownPropertyException();
 481     }
 482
 483     sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
 484         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
 485     {
 486         for( int i = 0; i < m_aSeq.getLength(); ++i )
 487             if( Name == m_aSeq[i].Name )
 488                 return true;
 489         return false;
 490     }
 491
 492 private:
 493
 494     uno::Sequence< beans::Property > m_aSeq;
 495 };
 496
 497
 498
 499 // XPropertySet
 500 uno::Reference< beans::XPropertySetInfo > SAL_CALL
 501 ResultSetBase::getPropertySetInfo()
 502     throw( uno::RuntimeException, std::exception)
 503 {
 504     uno::Sequence< beans::Property > seq(2);
 505     seq[0].Name = "RowCount";
 506     seq[0].Handle = -1;
 507     seq[0].Type = cppu::UnoType<sal_Int32>::get();
 508     seq[0].Attributes = beans::PropertyAttribute::READONLY;
 509
 510     seq[1].Name = "IsRowCountFinal";
 511     seq[1].Handle = -1;
 512     seq[1].Type = cppu::UnoType<sal_Bool>::get();
 513     seq[1].Attributes = beans::PropertyAttribute::READONLY;
 514
 515     //t
 516     return uno::Reference< beans::XPropertySetInfo > (
 517         new XPropertySetInfoImpl( seq ) );
 518 }
 519
 520
 521
 522 void SAL_CALL ResultSetBase::setPropertyValue(
 523     const OUString& aPropertyName, const uno::Any& /*aValue*/ )
 524     throw( beans::UnknownPropertyException,
 525            beans::PropertyVetoException,
 526            lang::IllegalArgumentException,
 527            lang::WrappedTargetException,
 528            uno::RuntimeException, std::exception)
 529 {
 530     if( aPropertyName == "IsRowCountFinal" ||
 531         aPropertyName == "RowCount" )
 532         return;
 533
 534     throw beans::UnknownPropertyException();
 535 }
 536
 537
 538 uno::Any SAL_CALL ResultSetBase::getPropertyValue(
 539     const OUString& PropertyName )
 540     throw( beans::UnknownPropertyException,
 541            lang::WrappedTargetException,
 542            uno::RuntimeException, std::exception)
 543 {
 544     if( PropertyName == "IsRowCountFinal" )
 545     {
 546         uno::Any aAny;
 547         aAny <<= m_bRowCountFinal;
 548         return aAny;
 549     }
 550     else if ( PropertyName == "RowCount" )
 551     {
 552         uno::Any aAny;
 553         sal_Int32 count = m_aItems.size();
 554         aAny <<= count;
 555         return aAny;
 556     }
 557     else
 558         throw beans::UnknownPropertyException();
 559 }
 560
 561
 562 void SAL_CALL ResultSetBase::addPropertyChangeListener(
 563     const OUString& aPropertyName,
 564     const uno::Reference< beans::XPropertyChangeListener >& xListener )
 565     throw( beans::UnknownPropertyException,
 566            lang::WrappedTargetException,
 567            uno::RuntimeException, std::exception)
 568 {
 569     if( aPropertyName == "IsRowCountFinal" )
 570     {
 571         osl::MutexGuard aGuard( m_aMutex );
 572         if ( ! m_pIsFinalListeners )
 573             m_pIsFinalListeners =
 574                 new cppu::OInterfaceContainerHelper( m_aMutex );
 575
 576         m_pIsFinalListeners->addInterface( xListener );
 577     }
 578     else if ( aPropertyName == "RowCount" )
 579     {
 580         osl::MutexGuard aGuard( m_aMutex );
 581         if ( ! m_pRowCountListeners )
 582             m_pRowCountListeners =
 583                 new cppu::OInterfaceContainerHelper( m_aMutex );
 584         m_pRowCountListeners->addInterface( xListener );
 585     }
 586     else
 587         throw beans::UnknownPropertyException();
 588 }
 589
 590
 591 void SAL_CALL ResultSetBase::removePropertyChangeListener(
 592     const OUString& aPropertyName,
 593     const uno::Reference< beans::XPropertyChangeListener >& aListener )
 594     throw( beans::UnknownPropertyException,
 595            lang::WrappedTargetException,
 596            uno::RuntimeException, std::exception)
 597 {
 598     if( aPropertyName == "IsRowCountFinal" &&
 599         m_pIsFinalListeners )
 600     {
 601         osl::MutexGuard aGuard( m_aMutex );
 602         m_pIsFinalListeners->removeInterface( aListener );
 603     }
 604     else if ( aPropertyName == "RowCount" &&
 605               m_pRowCountListeners )
 606     {
 607         osl::MutexGuard aGuard( m_aMutex );
 608         m_pRowCountListeners->removeInterface( aListener );
 609     }
 610     else
 611         throw beans::UnknownPropertyException();
 612 }
 613
 614
 615 void SAL_CALL ResultSetBase::addVetoableChangeListener(
 616     const OUString& /*PropertyName*/,
 617     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
 618     throw( beans::UnknownPropertyException,
 619            lang::WrappedTargetException,
 620            uno::RuntimeException, std::exception)
 621 {
 622 }
 623
 624
 625 void SAL_CALL ResultSetBase::removeVetoableChangeListener(
 626     const OUString& /*PropertyName*/,
 627     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
 628     throw( beans::UnknownPropertyException,
 629            lang::WrappedTargetException,
 630            uno::RuntimeException, std::exception)
 631 {
 632 }
 633
 634
 635
 636 // XResultSetMetaDataSupplier
 637 uno::Reference< sdbc::XResultSetMetaData > SAL_CALL
 638 ResultSetBase::getMetaData(
 639     void )
 640     throw( sdbc::SQLException,
 641            uno::RuntimeException, std::exception )
 642 {
 643     ::ucbhelper::ResultSetMetaData* p =
 644           new ::ucbhelper::ResultSetMetaData( m_xContext, m_sProperty );
 645     return uno::Reference< sdbc::XResultSetMetaData >( p );
 646 }
 647
 648
 649
 650
 651 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */