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 <deque>
#include <unordered_set>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsfeatureiterator.h"
#include "qgsfeaturerequest.h"
#include "qgsfield.h"
 
#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 = std::make_unique<QgsFeature>( feat );
        }
 
        ~QgsCachedFeature()
        {
          // That's the reason we need this wrapper:
          // Inform the cache that this feature has been removed
          mCache->featureRemoved( mFeature->id() );
        }
 
        inline const QgsFeature *feature() { return mFeature.get(); }
 
        bool allAttributesFetched() const;
 
        bool geometryFetched() const;
 
      private:
        std::unique_ptr<QgsFeature> mFeature;
        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 QgsFeature getFeature( QgsFeatureId fid )
    {
      QgsFeature feature;
      getFeatures( QgsFeatureRequest( fid ) ).nextFeature( feature );
      return feature;
    }

    inline QgsFeatureIterator getFeatures( const QgsFeatureIds &fids ) { return getFeatures( QgsFeatureRequest( fids ) ); }

    inline QgsFeatureIterator getFeatures( const QgsRectangle &rectangle ) { return getFeatures( QgsFeatureRequest( 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
    // clang-format off

    int __len__() const;
    % MethodCode
    sipRes = sipCpp->featureCount();
    % End

    int __bool__() const;
    % MethodCode
    sipRes = true;
    % End
// clang-format on
#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;
};
#endif // QgsVectorLayerCache_H