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