ucb/source/ucp/hierarchy/hierarchydatasupplier.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 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26
  27 #include <vector>
  28 #include <ucbhelper/contentidentifier.hxx>
  29 #include "hierarchydatasupplier.hxx"
  30 #include "hierarchyprovider.hxx"
  31 #include "hierarchycontent.hxx"
  32
  33 using namespace com::sun::star;
  34 using namespace hierarchy_ucp;
  35
  36 namespace hierarchy_ucp
  37 {
  38
  39
  40
  41 // struct ResultListEntry.
  42
  43
  44
  45 struct ResultListEntry
  46 {
  47     OUString                             aId;
  48     uno::Reference< ucb::XContentIdentifier > xId;
  49     uno::Reference< ucb::XContent >           xContent;
  50     uno::Reference< sdbc::XRow >              xRow;
  51     HierarchyEntryData                        aData;
  52
  53     ResultListEntry( const HierarchyEntryData& rEntry ) : aData( rEntry ) {}
  54 };
  55
  56
  57
  58 // ResultList.
  59
  60
  61
  62 typedef std::vector< ResultListEntry* > ResultList;
  63
  64
  65
  66 // struct DataSupplier_Impl.
  67
  68
  69
  70 struct DataSupplier_Impl
  71 {
  72     osl::Mutex                                      m_aMutex;
  73     ResultList                                      m_aResults;
  74     rtl::Reference< HierarchyContent >              m_xContent;
  75     uno::Reference< uno::XComponentContext >        m_xContext;
  76     HierarchyEntry                                  m_aFolder;
  77     HierarchyEntry::iterator                        m_aIterator;
  78     sal_Int32                                       m_nOpenMode;
  79     bool                                        m_bCountFinal;
  80
  81     DataSupplier_Impl(
  82         const uno::Reference< uno::XComponentContext >& rxContext,
  83         const rtl::Reference< HierarchyContent >& rContent,
  84         sal_Int32 nOpenMode )
  85     : m_xContent( rContent ), m_xContext( rxContext ),
  86       m_aFolder( rxContext,
  87                  static_cast< HierarchyContentProvider * >(
  88                      rContent->getProvider().get() ),
  89                  rContent->getIdentifier()->getContentIdentifier() ),
  90       m_nOpenMode( nOpenMode ), m_bCountFinal( false ) {}
  91     ~DataSupplier_Impl();
  92 };
  93
  94
  95 DataSupplier_Impl::~DataSupplier_Impl()
  96 {
  97     ResultList::const_iterator it  = m_aResults.begin();
  98     ResultList::const_iterator end = m_aResults.end();
  99
 100     while ( it != end )
 101     {
 102         delete (*it);
 103         ++it;
 104     }
 105 }
 106
 107 }
 108
 109
 110
 111
 112 // HierarchyResultSetDataSupplier Implementation.
 113
 114
 115
 116
 117 HierarchyResultSetDataSupplier::HierarchyResultSetDataSupplier(
 118                 const uno::Reference< uno::XComponentContext >& rxContext,
 119                 const rtl::Reference< HierarchyContent >& rContent,
 120                 sal_Int32 nOpenMode )
 121 : m_pImpl( new DataSupplier_Impl( rxContext, rContent, nOpenMode ) )
 122 {
 123 }
 124
 125
 126 // virtual
 127 HierarchyResultSetDataSupplier::~HierarchyResultSetDataSupplier()
 128 {
 129     delete m_pImpl;
 130 }
 131
 132
 133 // virtual
 134 OUString HierarchyResultSetDataSupplier::queryContentIdentifierString(
 135                                                         sal_uInt32 nIndex )
 136 {
 137     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 138
 139     if ( nIndex < m_pImpl->m_aResults.size() )
 140     {
 141         OUString aId = m_pImpl->m_aResults[ nIndex ]->aId;
 142         if ( !aId.isEmpty() )
 143         {
 144             // Already cached.
 145             return aId;
 146         }
 147     }
 148
 149     if ( getResult( nIndex ) )
 150     {
 151         OUString aId
 152             = m_pImpl->m_xContent->getIdentifier()->getContentIdentifier();
 153
 154         if ( ( aId.lastIndexOf( '/' ) + 1 ) != aId.getLength() )
 155             aId += "/";
 156
 157         aId += m_pImpl->m_aResults[ nIndex ]->aData.getName();
 158
 159         m_pImpl->m_aResults[ nIndex ]->aId = aId;
 160         return aId;
 161     }
 162     return OUString();
 163 }
 164
 165
 166 // virtual
 167 uno::Reference< ucb::XContentIdentifier >
 168 HierarchyResultSetDataSupplier::queryContentIdentifier( sal_uInt32 nIndex )
 169 {
 170     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 171
 172     if ( nIndex < m_pImpl->m_aResults.size() )
 173     {
 174         uno::Reference< ucb::XContentIdentifier > xId
 175                                 = m_pImpl->m_aResults[ nIndex ]->xId;
 176         if ( xId.is() )
 177         {
 178             // Already cached.
 179             return xId;
 180         }
 181     }
 182
 183     OUString aId = queryContentIdentifierString( nIndex );
 184     if ( !aId.isEmpty() )
 185     {
 186         uno::Reference< ucb::XContentIdentifier > xId
 187             = new ::ucbhelper::ContentIdentifier( aId );
 188         m_pImpl->m_aResults[ nIndex ]->xId = xId;
 189         return xId;
 190     }
 191     return uno::Reference< ucb::XContentIdentifier >();
 192 }
 193
 194
 195 // virtual
 196 uno::Reference< ucb::XContent >
 197 HierarchyResultSetDataSupplier::queryContent( sal_uInt32 nIndex )
 198 {
 199     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 200
 201     if ( nIndex < m_pImpl->m_aResults.size() )
 202     {
 203         uno::Reference< ucb::XContent > xContent
 204                                 = m_pImpl->m_aResults[ nIndex ]->xContent;
 205         if ( xContent.is() )
 206         {
 207             // Already cached.
 208             return xContent;
 209         }
 210     }
 211
 212     uno::Reference< ucb::XContentIdentifier > xId
 213         = queryContentIdentifier( nIndex );
 214     if ( xId.is() )
 215     {
 216         try
 217         {
 218             uno::Reference< ucb::XContent > xContent
 219                 = m_pImpl->m_xContent->getProvider()->queryContent( xId );
 220             m_pImpl->m_aResults[ nIndex ]->xContent = xContent;
 221             return xContent;
 222
 223         }
 224         catch ( ucb::IllegalIdentifierException const & )
 225         {
 226         }
 227     }
 228     return uno::Reference< ucb::XContent >();
 229 }
 230
 231
 232 // virtual
 233 bool HierarchyResultSetDataSupplier::getResult( sal_uInt32 nIndex )
 234 {
 235     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 236
 237     if ( m_pImpl->m_aResults.size() > nIndex )
 238     {
 239         // Result already present.
 240         return true;
 241     }
 242
 243     // Result not (yet) present.
 244
 245     if ( m_pImpl->m_bCountFinal )
 246         return false;
 247
 248     // Try to obtain result...
 249
 250     sal_uInt32 nOldCount = m_pImpl->m_aResults.size();
 251     bool bFound = false;
 252     sal_uInt32 nPos = nOldCount;
 253
 254     while ( m_pImpl->m_aFolder.next( m_pImpl->m_aIterator ) )
 255     {
 256         const HierarchyEntryData& rResult = *m_pImpl->m_aIterator;
 257         if ( checkResult( rResult ) )
 258         {
 259             m_pImpl->m_aResults.push_back( new ResultListEntry( rResult ) );
 260
 261             if ( nPos == nIndex )
 262             {
 263                 // Result obtained.
 264                 bFound = true;
 265                 break;
 266             }
 267         }
 268         nPos++;
 269     }
 270
 271     if ( !bFound )
 272         m_pImpl->m_bCountFinal = true;
 273
 274     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet().get();
 275     if ( xResultSet.is() )
 276     {
 277         // Callbacks follow!
 278         aGuard.clear();
 279
 280         if ( nOldCount < m_pImpl->m_aResults.size() )
 281             xResultSet->rowCountChanged(
 282                                     nOldCount, m_pImpl->m_aResults.size() );
 283
 284         if ( m_pImpl->m_bCountFinal )
 285             xResultSet->rowCountFinal();
 286     }
 287
 288     return bFound;
 289 }
 290
 291
 292 // virtual
 293 sal_uInt32 HierarchyResultSetDataSupplier::totalCount()
 294 {
 295     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 296
 297     if ( m_pImpl->m_bCountFinal )
 298         return m_pImpl->m_aResults.size();
 299
 300     sal_uInt32 nOldCount = m_pImpl->m_aResults.size();
 301
 302     while ( m_pImpl->m_aFolder.next( m_pImpl->m_aIterator ) )
 303     {
 304         const HierarchyEntryData& rResult = *m_pImpl->m_aIterator;
 305         if ( checkResult( rResult ) )
 306             m_pImpl->m_aResults.push_back( new ResultListEntry( rResult ) );
 307     }
 308
 309     m_pImpl->m_bCountFinal = true;
 310
 311     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet().get();
 312     if ( xResultSet.is() )
 313     {
 314         // Callbacks follow!
 315         aGuard.clear();
 316
 317         if ( nOldCount < m_pImpl->m_aResults.size() )
 318             xResultSet->rowCountChanged(
 319                                     nOldCount, m_pImpl->m_aResults.size() );
 320
 321         xResultSet->rowCountFinal();
 322     }
 323
 324     return m_pImpl->m_aResults.size();
 325 }
 326
 327
 328 // virtual
 329 sal_uInt32 HierarchyResultSetDataSupplier::currentCount()
 330 {
 331     return m_pImpl->m_aResults.size();
 332 }
 333
 334
 335 // virtual
 336 bool HierarchyResultSetDataSupplier::isCountFinal()
 337 {
 338     return m_pImpl->m_bCountFinal;
 339 }
 340
 341
 342 // virtual
 343 uno::Reference< sdbc::XRow >
 344 HierarchyResultSetDataSupplier::queryPropertyValues( sal_uInt32 nIndex  )
 345 {
 346     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 347
 348     if ( nIndex < m_pImpl->m_aResults.size() )
 349     {
 350         uno::Reference< sdbc::XRow > xRow
 351             = m_pImpl->m_aResults[ nIndex ]->xRow;
 352         if ( xRow.is() )
 353         {
 354             // Already cached.
 355             return xRow;
 356         }
 357     }
 358
 359     if ( getResult( nIndex ) )
 360     {
 361         HierarchyContentProperties aData(
 362             m_pImpl->m_aResults[ nIndex ]->aData );
 363
 364         uno::Reference< sdbc::XRow > xRow
 365             = HierarchyContent::getPropertyValues(
 366                 m_pImpl->m_xContext,
 367                 getResultSet()->getProperties(),
 368                 aData,
 369                 static_cast< HierarchyContentProvider * >(
 370                     m_pImpl->m_xContent->getProvider().get() ),
 371                 queryContentIdentifierString( nIndex ) );
 372         m_pImpl->m_aResults[ nIndex ]->xRow = xRow;
 373         return xRow;
 374     }
 375
 376     return uno::Reference< sdbc::XRow >();
 377 }
 378
 379
 380 // virtual
 381 void HierarchyResultSetDataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 382 {
 383     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 384
 385     if ( nIndex < m_pImpl->m_aResults.size() )
 386         m_pImpl->m_aResults[ nIndex ]->xRow = uno::Reference< sdbc::XRow >();
 387 }
 388
 389
 390 // virtual
 391 void HierarchyResultSetDataSupplier::close()
 392 {
 393 }
 394
 395
 396 // virtual
 397 void HierarchyResultSetDataSupplier::validate()
 398     throw( ucb::ResultSetException )
 399 {
 400 }
 401
 402
 403 bool HierarchyResultSetDataSupplier::checkResult(
 404                                     const HierarchyEntryData& rResult )
 405 {
 406     switch ( m_pImpl->m_nOpenMode )
 407     {
 408         case ucb::OpenMode::FOLDERS:
 409             if ( rResult.getType() == HierarchyEntryData::LINK )
 410             {
 411                 // Entry is a link.
 412                 return false;
 413             }
 414             break;
 415
 416         case ucb::OpenMode::DOCUMENTS:
 417             if ( rResult.getType() == HierarchyEntryData::FOLDER )
 418             {
 419                 // Entry is a folder.
 420                 return false;
 421             }
 422             break;
 423
 424         case ucb::OpenMode::ALL:
 425         default:
 426             break;
 427     }
 428
 429     return true;
 430 }
 431
 432 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */