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 "qgis.h"
#include "qgsfield.h"
#include "qgsfeaturerequest.h"
#include "qgsfeatureiterator.h"

#include <QCache>

class QgsVectorLayer;
class QgsFeature;
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 = nullptr;
        QgsVectorLayerCache *mCache = nullptr;

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

    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 { return mCache.keys().toSet(); }

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

    bool removeCachedFeature( QgsFeatureId fid );

    QgsVectorLayer *layer();

    QgsCoordinateReferenceSystem sourceCrs() const;

    QgsFields fields() const;

    QgsWkbTypes::Type wkbType() const;

#ifdef SIP_RUN

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

    int __bool__() const;
    % MethodCode
    sipRes = true;
    % End
#endif

    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 )
    {
      QgsCachedFeature *cachedFeature = new QgsCachedFeature( feat, this );
      mCache.insert( feat.id(), cachedFeature );
    }

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

    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