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 <QCache>

#include "qgsvectorlayer.h"

class QgsCachedFeatureIterator;
class QgsAbstractCacheIndex;

class CORE_EXPORT QgsVectorLayerCache : public QObject
{
    Q_OBJECT

  private:
    class QgsCachedFeature
    {
      public:
        QgsCachedFeature( const QgsFeature& feat, QgsVectorLayerCache* vlCache )
            : mCache( vlCache )
        {
          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; }

      private:
        QgsFeature* mFeature;
        QgsVectorLayerCache* mCache;

        friend class QgsVectorLayerCache;
        Q_DISABLE_COPY( QgsCachedFeature )
    };

  public:
    QgsVectorLayerCache( QgsVectorLayer* layer, int cacheSize, QObject* parent = nullptr );
    ~QgsVectorLayerCache();

    void setCacheSize( int cacheSize );

    int cacheSize();

    void setCacheGeometry( bool cacheGeometry );

    bool cacheGeometry() const { return mCacheGeometry; }

    void setCacheSubsetOfAttributes( const QgsAttributeList& attributes );

    void setCacheAddedAttributes( bool cacheAddedAttributes );

    void setFullCache( bool fullCache );

    bool hasFullCache() const { return mFullCache; }

    void addCacheIndex( QgsAbstractCacheIndex *cacheIndex );

    QgsFeatureIterator getFeatures( const QgsFeatureRequest& featureRequest = QgsFeatureRequest() );

    bool isFidCached( const QgsFeatureId fid ) const;

    QgsFeatureIds cachedFeatureIds() const { return mCache.keys().toSet(); }

    bool featureAtId( QgsFeatureId featureId, QgsFeature &feature, bool skipCache = false );

    bool removeCachedFeature( QgsFeatureId fid );

    QgsVectorLayer* layer();

  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 );

    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 featureDeleted( QgsFeatureId fid );
    void onFeatureAdded( QgsFeatureId fid );
    void attributeAdded( int field );
    void attributeDeleted( int field );
    void geometryChanged( QgsFeatureId fid, QgsGeometry& geom );
    void layerDeleted();
    void invalidate();

  private:

    inline void cacheFeature( QgsFeature& feat )
    {
      QgsCachedFeature* cachedFeature = new QgsCachedFeature( feat, this );
      mCache.insert( feat.id(), cachedFeature );
    }

    QgsVectorLayer* mLayer;
    QCache< QgsFeatureId, QgsCachedFeature > mCache;

    bool mCacheGeometry;
    bool mFullCache;
    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