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 <utility>
  21 #include <vector>
  22
  23 #include "myucp_datasupplier.hxx"
  24 #include <ContentHelper.hxx>
  25 #include <com/sun/star/ucb/IllegalIdentifierException.hpp>
  26
  27 using namespace ::com::sun::star::uno;
  28 using namespace ::com::sun::star::ucb;
  29 using namespace ::com::sun::star::sdbc;
  30 using namespace ::com::sun::star::io;
  31 using namespace ::com::sun::star::container;
  32
  33 using namespace dbaccess;
  34
  35
  36 DataSupplier::DataSupplier( const rtl::Reference< ODocumentContainer >& rContent )
  37 : m_xContent( rContent )
  38 {
  39 }
  40
  41 DataSupplier::~DataSupplier()
  42 {
  43 }
  44
  45 OUString DataSupplier::queryContentIdentifierString( std::unique_lock<std::mutex>& rResultSetGuard, sal_uInt32 nIndex )
  46 {
  47     osl::Guard< osl::Mutex > aGuard( m_aMutex );
  48
  49     if ( static_cast<size_t>(nIndex) < m_aResults.size() )
  50     {
  51         OUString aId = m_aResults[ nIndex ]->aId;
  52         if ( !aId.isEmpty() )
  53         {
  54             // Already cached.
  55             return aId;
  56         }
  57     }
  58
  59     if ( getResult( rResultSetGuard, nIndex ) )
  60     {
  61         OUString aId = m_xContent->getIdentifier()->getContentIdentifier();
  62
  63         if ( !aId.isEmpty() )
  64             aId += "/";
  65
  66         aId += m_aResults[ nIndex ]->rData.aTitle;
  67
  68         m_aResults[ nIndex ]->aId = aId;
  69         return aId;
  70     }
  71     return OUString();
  72 }
  73
  74 Reference< XContentIdentifier >
  75 DataSupplier::queryContentIdentifier( std::unique_lock<std::mutex>& rResultSetGuard, sal_uInt32 nIndex )
  76 {
  77     osl::Guard< osl::Mutex > aGuard( m_aMutex );
  78
  79     if ( static_cast<size_t>(nIndex) < m_aResults.size() )
  80     {
  81         Reference< XContentIdentifier > xId = m_aResults[ nIndex ]->xId;
  82         if ( xId.is() )
  83         {
  84             // Already cached.
  85             return xId;
  86         }
  87     }
  88
  89     OUString aId = queryContentIdentifierString( rResultSetGuard, nIndex );
  90     if ( !aId.isEmpty() )
  91     {
  92         Reference< XContentIdentifier > xId = new ::ucbhelper::ContentIdentifier( aId );
  93         m_aResults[ nIndex ]->xId = xId;
  94         return xId;
  95     }
  96     return Reference< XContentIdentifier >();
  97 }
  98
  99 Reference< XContent >
 100 DataSupplier::queryContent( std::unique_lock<std::mutex>& rResultSetGuard, sal_uInt32 _nIndex )
 101 {
 102     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 103
 104     if ( static_cast<size_t>(_nIndex) < m_aResults.size() )
 105     {
 106         Reference< XContent > xContent = m_aResults[ _nIndex ]->xContent;
 107         if ( xContent.is() )
 108         {
 109             // Already cached.
 110             return xContent;
 111         }
 112     }
 113
 114     Reference< XContentIdentifier > xId = queryContentIdentifier( rResultSetGuard, _nIndex );
 115     if ( xId.is() )
 116     {
 117         try
 118         {
 119             Reference< XContent > xContent;
 120             OUString sName = xId->getContentIdentifier();
 121             sName = sName.copy(sName.lastIndexOf('/')+1);
 122
 123             m_aResults[ _nIndex ]->xContent = m_xContent->getContent(sName);
 124
 125             xContent = m_aResults[ _nIndex ]->xContent.get();
 126             return xContent;
 127
 128         }
 129         catch ( IllegalIdentifierException& )
 130         {
 131         }
 132     }
 133     return Reference< XContent >();
 134 }
 135
 136 bool DataSupplier::getResult( std::unique_lock<std::mutex>& rResultSetGuard, sal_uInt32 nIndex )
 137 {
 138     osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
 139
 140     if ( static_cast<size_t>(nIndex) < m_aResults.size() )
 141     {
 142         // Result already present.
 143         return true;
 144     }
 145
 146     // Result not (yet) present.
 147
 148     if ( m_bCountFinal )
 149         return false;
 150
 151     // Try to obtain result...
 152
 153     sal_uInt32 nOldCount = m_aResults.size();
 154     bool bFound = false;
 155
 156     // @@@ Obtain data and put it into result list...
 157     Sequence< OUString> aSeq = m_xContent->getElementNames();
 158     if ( nIndex < sal::static_int_cast< sal_uInt32 >( aSeq.getLength() ) )
 159     {
 160         m_aResults.reserve(nIndex + 1);
 161         const OUString* pEnd = aSeq.begin() + nIndex + 1;
 162         for (const OUString* pIter = aSeq.begin() + nOldCount; pIter != pEnd; ++pIter)
 163             m_aResults.emplace_back(
 164                             new ResultListEntry( m_xContent->getContent(*pIter)->getContentProperties() ) );
 165
 166         // Result obtained.
 167         bFound = true;
 168     }
 169
 170     if ( !bFound )
 171         m_bCountFinal = true;
 172
 173     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet();
 174     if ( xResultSet.is() )
 175     {
 176         // Callbacks follow!
 177         aGuard.clear();
 178
 179         if ( static_cast<size_t>(nOldCount) < m_aResults.size() )
 180             xResultSet->rowCountChanged( rResultSetGuard, nOldCount, m_aResults.size() );
 181
 182         if ( m_bCountFinal )
 183             xResultSet->rowCountFinal(rResultSetGuard);
 184     }
 185
 186     return bFound;
 187 }
 188
 189 sal_uInt32 DataSupplier::totalCount(std::unique_lock<std::mutex>& rResultSetGuard)
 190 {
 191     osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
 192
 193     if ( m_bCountFinal )
 194         return m_aResults.size();
 195
 196     sal_uInt32 nOldCount = m_aResults.size();
 197
 198     // @@@ Obtain data and put it into result list...
 199     Sequence< OUString> aSeq = m_xContent->getElementNames();
 200     // FIXME: this adds everything from aSeq to m_aResults, unlike similar code in getResult,
 201     // which skips nOldCount entries in aSeq - which is correct?
 202     for (auto& name : aSeq)
 203         m_aResults.emplace_back(
 204                         new ResultListEntry( m_xContent->getContent(name)->getContentProperties() ) );
 205
 206     m_bCountFinal = true;
 207
 208     rtl::Reference< ::ucbhelper::ResultSet > xResultSet = getResultSet();
 209     if ( xResultSet.is() )
 210     {
 211         // Callbacks follow!
 212         aGuard.clear();
 213
 214         if ( static_cast<size_t>(nOldCount) < m_aResults.size() )
 215             xResultSet->rowCountChanged( rResultSetGuard, nOldCount, m_aResults.size() );
 216
 217         xResultSet->rowCountFinal(rResultSetGuard);
 218     }
 219
 220     return m_aResults.size();
 221 }
 222
 223 sal_uInt32 DataSupplier::currentCount()
 224 {
 225     return m_aResults.size();
 226 }
 227
 228 bool DataSupplier::isCountFinal()
 229 {
 230     return m_bCountFinal;
 231 }
 232
 233 Reference< XRow >
 234 DataSupplier::queryPropertyValues( std::unique_lock<std::mutex>& rResultSetGuard, sal_uInt32 nIndex  )
 235 {
 236     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 237
 238     if ( static_cast<size_t>(nIndex) < m_aResults.size() )
 239     {
 240         Reference< XRow > xRow = m_aResults[ nIndex ]->xRow;
 241         if ( xRow.is() )
 242         {
 243             // Already cached.
 244             return xRow;
 245         }
 246     }
 247
 248     if ( getResult( rResultSetGuard, nIndex ) )
 249     {
 250         if ( !m_aResults[ nIndex ]->xContent.is() )
 251             queryContent(rResultSetGuard, nIndex);
 252
 253         Reference< XRow > xRow = m_aResults[ nIndex ]->xContent->getPropertyValues(getResultSet()->getProperties());
 254         m_aResults[ nIndex ]->xRow = xRow;
 255         return xRow;
 256     }
 257
 258     return Reference< XRow >();
 259 }
 260
 261 void DataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 262 {
 263     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 264
 265     if ( static_cast<size_t>(nIndex) < m_aResults.size() )
 266         m_aResults[ nIndex ]->xRow.clear();
 267 }
 268
 269 void DataSupplier::close()
 270 {
 271 }
 272
 273 void DataSupplier::validate()
 274 {
 275 }
 276
 277 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */