dbaccess/source/core/dataaccess/myucp_datasupplier.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 <vector>
  21
  22 #include <ucbhelper/contentidentifier.hxx>
  23 #include <ucbhelper/providerhelper.hxx>
  24
  25 #include "myucp_datasupplier.hxx"
  26 #include "ContentHelper.hxx"
  27 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  28 #include <tools/debug.hxx>
  29
  30 using namespace ::com::sun::star::uno;
  31 using namespace ::com::sun::star::ucb;
  32 using namespace ::com::sun::star::beans;
  33 using namespace ::com::sun::star::lang;
  34 using namespace ::com::sun::star::sdbc;
  35 using namespace ::com::sun::star::io;
  36 using namespace ::com::sun::star::container;
  37
  38 // @@@ Adjust namespace name.
  39 using namespace dbaccess;
  40
  41 // @@@ Adjust namespace name.
  42 namespace dbaccess
  43 {
  44
  45 // struct ResultListEntry.
  46 struct ResultListEntry
  47 {
  48     OUString                       aId;
  49     Reference< XContentIdentifier >     xId;
  50     ::rtl::Reference< OContentHelper >  xContent;
  51     Reference< XRow >                   xRow;
  52     const ContentProperties&            rData;
  53
  54     explicit ResultListEntry(const ContentProperties& rEntry) : rData( rEntry ) {}
  55 };
  56
  57 // ResultList.
  58 typedef std::vector< ResultListEntry* > ResultList;
  59
  60 // struct DataSupplier_Impl.
  61 struct DataSupplier_Impl
  62 {
  63     osl::Mutex                                   m_aMutex;
  64     ResultList                                   m_aResults;
  65     rtl::Reference< ODocumentContainer >         m_xContent;
  66     bool                                         m_bCountFinal;
  67
  68     explicit DataSupplier_Impl(const rtl::Reference< ODocumentContainer >& rContent)
  69         : m_xContent(rContent)
  70         , m_bCountFinal(false)
  71     {
  72     }
  73     ~DataSupplier_Impl();
  74 };
  75
  76 DataSupplier_Impl::~DataSupplier_Impl()
  77 {
  78     ResultList::const_iterator it  = m_aResults.begin();
  79     ResultList::const_iterator end = m_aResults.end();
  80
  81     while ( it != end )
  82     {
  83         delete (*it);
  84         ++it;
  85     }
  86 }
  87
  88 }
  89
  90 // DataSupplier Implementation.
  91
  92 DataSupplier::DataSupplier( const rtl::Reference< ODocumentContainer >& rContent )
  93 : m_pImpl( new DataSupplier_Impl( rContent ) )
  94 {
  95
  96 }
  97
  98 DataSupplier::~DataSupplier()
  99 {
 100
 101 }
 102
 103 OUString DataSupplier::queryContentIdentifierString( sal_uInt32 nIndex )
 104 {
 105     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 106
 107     if ( (size_t)nIndex < m_pImpl->m_aResults.size() )
 108     {
 109         OUString aId = m_pImpl->m_aResults[ nIndex ]->aId;
 110         if ( !aId.isEmpty() )
 111         {
 112             // Already cached.
 113             return aId;
 114         }
 115     }
 116
 117     if ( getResult( nIndex ) )
 118     {
 119         OUString aId = m_pImpl->m_xContent->getIdentifier()->getContentIdentifier();
 120
 121         if ( !aId.isEmpty() )
 122             aId += "/";
 123
 124         aId += m_pImpl->m_aResults[ nIndex ]->rData.aTitle;
 125
 126         m_pImpl->m_aResults[ nIndex ]->aId = aId;
 127         return aId;
 128     }
 129     return OUString();
 130 }
 131
 132 Reference< XContentIdentifier >
 133 DataSupplier::queryContentIdentifier( sal_uInt32 nIndex )
 134 {
 135     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 136
 137     if ( (size_t)nIndex < m_pImpl->m_aResults.size() )
 138     {
 139         Reference< XContentIdentifier > xId = m_pImpl->m_aResults[ nIndex ]->xId;
 140         if ( xId.is() )
 141         {
 142             // Already cached.
 143             return xId;
 144         }
 145     }
 146
 147     OUString aId = queryContentIdentifierString( nIndex );
 148     if ( !aId.isEmpty() )
 149     {
 150         Reference< XContentIdentifier > xId = new ::ucbhelper::ContentIdentifier( aId );
 151         m_pImpl->m_aResults[ nIndex ]->xId = xId;
 152         return xId;
 153     }
 154     return Reference< XContentIdentifier >();
 155 }
 156
 157 Reference< XContent >
 158 DataSupplier::queryContent( sal_uInt32 _nIndex )
 159 {
 160     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 161
 162     if ( (size_t)_nIndex < m_pImpl->m_aResults.size() )
 163     {
 164         Reference< XContent > xContent = m_pImpl->m_aResults[ _nIndex ]->xContent.get();
 165         if ( xContent.is() )
 166         {
 167             // Already cached.
 168             return xContent;
 169         }
 170     }
 171
 172     Reference< XContentIdentifier > xId = queryContentIdentifier( _nIndex );
 173     if ( xId.is() )
 174     {
 175         try
 176         {
 177             Reference< XContent > xContent;
 178             OUString sName = xId->getContentIdentifier();
 179             sal_Int32 nIndex = sName.lastIndexOf('/') + 1;
 180             sName = sName.getToken(0,'/',nIndex);
 181
 182             m_pImpl->m_aResults[ _nIndex ]->xContent = m_pImpl->m_xContent->getContent(sName);
 183
 184             xContent = m_pImpl->m_aResults[ _nIndex ]->xContent.get();
 185             return xContent;
 186
 187         }
 188         catch ( IllegalIdentifierException& )
 189         {
 190         }
 191     }
 192     return Reference< XContent >();
 193 }
 194
 195 bool DataSupplier::getResult( sal_uInt32 nIndex )
 196 {
 197     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 198
 199     if ( (size_t)nIndex < m_pImpl->m_aResults.size() )
 200     {
 201         // Result already present.
 202         return true;
 203     }
 204
 205     // Result not (yet) present.
 206
 207     if ( m_pImpl->m_bCountFinal )
 208         return false;
 209
 210     // Try to obtain result...
 211
 212     sal_uInt32 nOldCount = m_pImpl->m_aResults.size();
 213     bool bFound = false;
 214     sal_uInt32 nPos = nOldCount;
 215
 216     // @@@ Obtain data and put it into result list...
 217     Sequence< OUString> aSeq = m_pImpl->m_xContent->getElementNames();
 218     if ( nIndex < sal::static_int_cast< sal_uInt32 >( aSeq.getLength() ) )
 219     {
 220         const OUString* pIter = aSeq.getConstArray();
 221         const OUString* pEnd   = pIter + aSeq.getLength();
 222         for(pIter = pIter + nPos;pIter != pEnd;++pIter,++nPos)
 223         {
 224             m_pImpl->m_aResults.push_back(
 225                             new ResultListEntry( m_pImpl->m_xContent->getContent(*pIter)->getContentProperties() ) );
 226
 227             if ( nPos == nIndex )
 228             {
 229                 // Result obtained.
 230                 bFound = true;
 231                 break;
 232             }
 233         }
 234     }
 235
 236     if ( !bFound )
 237         m_pImpl->m_bCountFinal = true;
 238
 239     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet().get();
 240     if ( xResultSet.is() )
 241     {
 242         // Callbacks follow!
 243         aGuard.clear();
 244
 245         if ( (size_t)nOldCount < m_pImpl->m_aResults.size() )
 246             xResultSet->rowCountChanged(
 247                                     nOldCount, m_pImpl->m_aResults.size() );
 248
 249         if ( m_pImpl->m_bCountFinal )
 250             xResultSet->rowCountFinal();
 251     }
 252
 253     return bFound;
 254 }
 255
 256 sal_uInt32 DataSupplier::totalCount()
 257 {
 258     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 259
 260     if ( m_pImpl->m_bCountFinal )
 261         return m_pImpl->m_aResults.size();
 262
 263     sal_uInt32 nOldCount = m_pImpl->m_aResults.size();
 264
 265     // @@@ Obtain data and put it into result list...
 266     Sequence< OUString> aSeq = m_pImpl->m_xContent->getElementNames();
 267     const OUString* pIter = aSeq.getConstArray();
 268     const OUString* pEnd   = pIter + aSeq.getLength();
 269     for(;pIter != pEnd;++pIter)
 270         m_pImpl->m_aResults.push_back(
 271                         new ResultListEntry( m_pImpl->m_xContent->getContent(*pIter)->getContentProperties() ) );
 272
 273     m_pImpl->m_bCountFinal = true;
 274
 275     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet().get();
 276     if ( xResultSet.is() )
 277     {
 278         // Callbacks follow!
 279         aGuard.clear();
 280
 281         if ( (size_t)nOldCount < m_pImpl->m_aResults.size() )
 282             xResultSet->rowCountChanged(
 283                                     nOldCount, m_pImpl->m_aResults.size() );
 284
 285         xResultSet->rowCountFinal();
 286     }
 287
 288     return m_pImpl->m_aResults.size();
 289 }
 290
 291 sal_uInt32 DataSupplier::currentCount()
 292 {
 293     return m_pImpl->m_aResults.size();
 294 }
 295
 296 bool DataSupplier::isCountFinal()
 297 {
 298     return m_pImpl->m_bCountFinal;
 299 }
 300
 301 Reference< XRow >
 302 DataSupplier::queryPropertyValues( sal_uInt32 nIndex  )
 303 {
 304     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 305
 306     if ( (size_t)nIndex < m_pImpl->m_aResults.size() )
 307     {
 308         Reference< XRow > xRow = m_pImpl->m_aResults[ nIndex ]->xRow;
 309         if ( xRow.is() )
 310         {
 311             // Already cached.
 312             return xRow;
 313         }
 314     }
 315
 316     if ( getResult( nIndex ) )
 317     {
 318         if ( !m_pImpl->m_aResults[ nIndex ]->xContent.is() )
 319             queryContent(nIndex);
 320
 321         Reference< XRow > xRow = m_pImpl->m_aResults[ nIndex ]->xContent->getPropertyValues(getResultSet()->getProperties());
 322         m_pImpl->m_aResults[ nIndex ]->xRow = xRow;
 323         return xRow;
 324     }
 325
 326     return Reference< XRow >();
 327 }
 328
 329 void DataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 330 {
 331     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 332
 333     if ( (size_t)nIndex < m_pImpl->m_aResults.size() )
 334         m_pImpl->m_aResults[ nIndex ]->xRow.clear();
 335 }
 336
 337 void DataSupplier::close()
 338 {
 339 }
 340
 341 void DataSupplier::validate()
 342     throw( ResultSetException )
 343 {
 344 }
 345
 346 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */