qgsvectorlayercache.h

Go to the documentation of this file.

/***************************************************************************
  qgsvectorlayercache.h
  Cache features of a vector layer
  -------------------
         begin                : January 2013
         copyright            : (C) Matthias Kuhn
         email                : matthias at opengis dot ch
 
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
 
#ifndef QgsVectorLayerCache_H
#define QgsVectorLayerCache_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfield.h"
#include "qgsfeaturerequest.h"
#include "qgsfeatureiterator.h"
#include <unordered_set>
#include <deque>
#include <QCache>
 
class QgsVectorLayer;
class QgsFeature;
class QgsCachedFeatureIterator;
class QgsAbstractCacheIndex;
 
class CORE_EXPORT QgsVectorLayerCache : public QObject
{
    Q_OBJECT
 
  private:
 
    class CORE_EXPORT QgsCachedFeature
    {
      public:
 
        QgsCachedFeature( const QgsFeature &feat, QgsVectorLayerCache *vlCache, bool allAttributesFetched, bool geometryFetched )
          : mCache( vlCache )
          , mAllAttributesFetched( allAttributesFetched )
          , mGeometryFetched( geometryFetched )
        {
          mFeature = new QgsFeature( feat );
        }
 
        ~QgsCachedFeature()
        {
          // That's the reason we need this wrapper:
          // Inform the cache that this feature has been removed
          mCache->featureRemoved( mFeature->id() );
          delete mFeature;
        }
 
        inline const QgsFeature *feature() { return mFeature; }
 
        bool allAttributesFetched() const;
 
        bool geometryFetched() const;
 
      private:
        QgsFeature *mFeature = nullptr;
        QgsVectorLayerCache *mCache = nullptr;
        bool mAllAttributesFetched = true;
        bool mGeometryFetched = false;
 
        friend class QgsVectorLayerCache;
        Q_DISABLE_COPY( QgsCachedFeature )
    };
 
  public:
    QgsVectorLayerCache( QgsVectorLayer *layer, int cacheSize, QObject *parent SIP_TRANSFERTHIS = nullptr );
    ~QgsVectorLayerCache() override;
 
    void setCacheSize( int cacheSize );
 
    int cacheSize();
 
    void setCacheGeometry( bool cacheGeometry );
 
    bool cacheGeometry() const { return mCacheGeometry; }
 
    void setCacheSubsetOfAttributes( const QgsAttributeList &attributes );
 
    QgsAttributeList cacheSubsetOfAttributes( ) const;
 
    void setCacheAddedAttributes( bool cacheAddedAttributes );
 
    void setFullCache( bool fullCache );
 
    bool hasFullCache() const { return mFullCache; }
 
    void addCacheIndex( QgsAbstractCacheIndex *cacheIndex SIP_TRANSFER );
 
    QgsFeatureIterator getFeatures( const QgsFeatureRequest &featureRequest = QgsFeatureRequest() );
 
    inline QgsFeatureIterator getFeatures( const QString &expression )
    {
      return getFeatures( QgsFeatureRequest( expression ) );
    }
    inline QgsFeatureIterator getFeatures( const QString &expression ) {…}
 
    inline QgsFeature getFeature( QgsFeatureId fid )
    {
      QgsFeature feature;
      getFeatures( QgsFeatureRequest( fid ) ).nextFeature( feature );
      return feature;
    }
    inline QgsFeature getFeature( QgsFeatureId fid ) {…}
 
    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids )
    {
      return getFeatures( QgsFeatureRequest( fids ) );
    }
    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids ) {…}
 
    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle )
    {
      return getFeatures( QgsFeatureRequest( rectangle ) );
    }
    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle ) {…}
 
    bool isFidCached( QgsFeatureId fid ) const;
 
    QgsFeatureIds cachedFeatureIds() const;
 
    bool featureAtId( QgsFeatureId featureId, QgsFeature &feature SIP_OUT, bool skipCache = false );
 
    bool featureAtIdWithAllAttributes( QgsFeatureId featureId, QgsFeature &feature SIP_OUT, bool skipCache = false );
 
    bool completeFeatureAtId( QgsFeatureId featureId, QgsFeature &feature SIP_OUT, bool skipCache = false );
 
    bool removeCachedFeature( QgsFeatureId fid );
 
    QgsVectorLayer *layer();
 
    QgsCoordinateReferenceSystem sourceCrs() const;
 
    QgsFields fields() const;
 
    Qgis::WkbType wkbType() const;
 
#ifdef SIP_RUN
 
    int __len__() const;
    % MethodCode
    sipRes = sipCpp->featureCount();
    % End
 
    int __bool__() const;
    % MethodCode
    sipRes = true;
    % End
#endif
 
    long long featureCount() const;
 
  protected:
 
    void requestCompleted( const QgsFeatureRequest &featureRequest, const QgsFeatureIds &fids );
 
    void featureRemoved( QgsFeatureId fid );
 
    bool checkInformationCovered( const QgsFeatureRequest &featureRequest );
 
 
  signals:
 
    void progress( int i, bool &cancel ) SIP_SKIP;
 
    void finished();
 
    void cachedLayerDeleted();
 
    void attributeValueChanged( QgsFeatureId fid, int field, const QVariant &value );
 
    void featureAdded( QgsFeatureId fid );
 
    void invalidated();
 
  private slots:
    void onAttributeValueChanged( QgsFeatureId fid, int field, const QVariant &value );
    void onJoinAttributeValueChanged( QgsFeatureId fid, int field, const QVariant &value );
    void featureDeleted( QgsFeatureId fid );
    void onFeatureAdded( QgsFeatureId fid );
    void attributeAdded( int field );
    void attributeDeleted( int field );
    void geometryChanged( QgsFeatureId fid, const QgsGeometry &geom );
    void layerDeleted();
    void invalidate();
 
  private:
 
    void connectJoinedLayers() const;
 
    inline void cacheFeature( QgsFeature &feat, bool allAttributesFetched, bool geometryFetched = false )
    {
      QgsCachedFeature *cachedFeature = new QgsCachedFeature( feat, this, allAttributesFetched, geometryFetched || mCacheGeometry );
      mCache.insert( feat.id(), cachedFeature );
      if ( mCacheUnorderedKeys.find( feat.id() ) == mCacheUnorderedKeys.end() )
      {
        mCacheUnorderedKeys.insert( feat.id() );
        mCacheOrderedKeys.emplace_back( feat.id() );
      }
    }
 
    QgsVectorLayer *mLayer = nullptr;
    QCache< QgsFeatureId, QgsCachedFeature > mCache;
 
    // we need two containers here. One is used for efficient tracking of the IDs which have been added to the cache, the other
    // is used to store the order of the incoming feature ids, so that we can correctly iterate through features in the original order.
    // the ordered list alone is far too slow to handle this -- searching for existing items in a list is magnitudes slower than the unordered_set
    std::unordered_set< QgsFeatureId > mCacheUnorderedKeys;
    std::deque< QgsFeatureId > mCacheOrderedKeys;
 
    bool mCacheGeometry = true;
    bool mFullCache = false;
    QList<QgsAbstractCacheIndex *> mCacheIndices;
 
    QgsAttributeList mCachedAttributes;
 
    friend class QgsCachedFeatureIterator;
    friend class QgsCachedFeatureWriterIterator;
    friend class QgsCachedFeature;
 
    bool canUseCacheForRequest( const QgsFeatureRequest &featureRequest, QgsFeatureIterator &it );
 
    friend class TestVectorLayerCache;
};
class CORE_EXPORT QgsVectorLayerCache : public QObject {…};
#endif // QgsVectorLayerCache_H