QGIS » QGIS Application

  /**

   * Fetch the specified feature from provider, if it is cached. This

   * must be called every time the provider data change outside vector layer control.

   * @param featureId id of feature that should be reloaded

   * @param rectFrom hint of rectangle, where the feature resided. If not provided,

   *             whole cache will be searched for the id.

   * @param rectTo hint of rectangle, where the feature resides now. If not provided,

   *             all provider features will be searched for the id.

  **/

  void recacheFeature( int featureId, QgsRectangle rectFrom=QgsRectangle(), QgsRectangle rectTo=QgsRectangle() );

  /**

   * Fetch features from specified rectangle from provider, if it is cached. This

   * must be called every time the provider data change outside vector layer control.

   * @param rect rectangle containing changed features. All features within

   *             the rectangle will be reloaded.

  **/

  void recacheFeatures( QgsRectangle rect );

  //features cache mode

  QString cacheMode = settings.value( "qgis/vectorLayerCacheMode", "heuristics" ).toString();

  if ( cacheMode == "all" )

    radCacheAll->setChecked(true);

  else if ( cacheMode == "nothing" )

    radCacheNothing->setChecked(true);

  else

    radCacheHeuristics->setChecked(true);

  settings.setValue( "qgis/vectorLayerCacheMode",

    radCacheNothing->isChecked() ? "nothing" : (

      radCacheAll->isChecked() ? "all" : "heuristics"

    )

  );

#include "qgsfeaturecache.h"

  mFeatureCache=new QgsFeatureCache;

#ifdef ENABLE_GEOMETRYCACHE

#endif

  delete mFeatureCache;

#ifdef ENABLE_GEOMETRYCACHE

#endif

    QgsRectangle renderExtent=rendererContext.extent();

    //apply cache mode

    QSettings settings;

    QString cacheMode=settings.value( "qgis/vectorLayerCacheMode", "heuristics" ).toString();

    if ( cacheMode == "heuristics" )

      mFeatureCache->setCacheMode(QgsFeatureCache::CACHE_HEURISTICS);

    else if ( cacheMode == "all" )

      mFeatureCache->setCacheMode(QgsFeatureCache::CACHE_ALL);

    else

      mFeatureCache->setCacheMode(QgsFeatureCache::CACHE_NOTHING);

    mFeatureCache->applyCurrentCacheMode(renderExtent);

    select( attributes, renderExtent);

    if ( !mFeatureCache->isSelectValid() )

    {

#ifdef LIMIT_CACHED_EXTENT

      if ( mDataProvider->extent() == mFeatureCache->getCachedRectangle() )

      {

        //everything is cached already, retrieve selected part

        //note: this will fail, if requested classification attributes changed

        mFeatureCache->makeSelectValid();

      }

      -

      if ( !mFeatureCache->isSelectValid() )

      {

        //cache still invalid, we'll have to refill the cache

        if ( renderExtent.contains( mDataProvider->extent() ) )

        {

          //only cache as big rectangle as the provider can provide

          select( attributes, mDataProvider->extent() );

        }

#endif        

        mFeatureCache->clear();

#ifdef LIMIT_CACHED_EXTENT

      }

#endif

    }

        if ( !mFeatureCache->isInitialized() )

        {

          mFeatureCache->insert( fet );

        }

#ifdef ENABLE_GEOMETRYCACHE

#endif

      if ( !mFeatureCache->isInitialized() )

      {

        mFeatureCache->setAsInitialized();

      }

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

  QgsAttributeList attrToSelect;

      attrToSelect=provAttributes;

      attrToSelect=mFetchAttributes;

    attrToSelect=QgsAttributeList();

  bool cacheSelectSuccessful;

  if ( rect == QgsRectangle() )

  {

    //we can't give QgsRectangle() to feature cache's select(), as it would only select

    //extent of cache - instead of extent of the real data

    cacheSelectSuccessful=mFeatureCache->select(

      attrToSelect, mDataProvider->extent(), fetchGeometries, useIntersect

    );

  }

  else

  {

    cacheSelectSuccessful=mFeatureCache->select(

      attrToSelect, rect, fetchGeometries, useIntersect

    );

  }

  if ( ! cacheSelectSuccessful )

    mDataProvider->select( attrToSelect, rect, fetchGeometries, useIntersect );

  if ( !mFetching && !mFeatureCache->isSelectValid() )

  while ( true )

    if ( mFeatureCache->isSelectValid() ) {

      if ( !mFeatureCache->nextFeature ( f ) )

        break;

    }

    else

    {

      if ( !dataProvider()->nextFeature( f ) )

        break;

    }

  bool gotFeature;

    if ( !(

      mFeatureCache->isInitialized() &&

      mFeatureCache->areAttributesCached( mDataProvider->attributeIndexes() ) &&

      mFeatureCache->featureAtId( featureId, f, fetchGeometries, true )

    ) )

      //feature not in cache, try the provider

      gotFeature=mDataProvider->featureAtId( featureId, f, fetchGeometries, mDataProvider->attributeIndexes() );

    }

    else

    {

      gotFeature=true;

    }

    if ( gotFeature )

    {

    if ( !( mFeatureCache->isInitialized() && mFeatureCache->featureAtId( featureId, f, fetchGeometries, false ) ) )

      //feature not in cache, try the provider

      gotFeature=mDataProvider->featureAtId( featureId, f, fetchGeometries, QgsAttributeList() );

    }

    else

    {

      gotFeature=true;

    }

    if ( gotFeature )

    {

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#else

      QgsFeature f;

      if ( !featureAtId( atFeatureId, f, true, false ) )

      {

        return false;

      }

      geometry=*(f.geometry());

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#else

      QgsFeature f;

      if ( !featureAtId( atFeatureId, f, true, false ) )

      {

        return false;

      }

      geometry=*(f.geometry());

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#else

      QgsFeature f;

      if ( !featureAtId( atFeatureId, f, true, false ) )

      {

        return false;

      }

      geometry=*(f.geometry());

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

      QgsGeometry translateGeom( *( addedIt->geometry() ) );

      int errorCode = translateGeom.addIsland( ring );

      if ( errorCode == 0 )

      {

        editGeometryChange( selectedFeatureId, translateGeom );

        setModified( true, true );

      }

      return errorCode;

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

      QgsGeometry translateGeom( *( addedIt->geometry() ) );

      int errorCode = translateGeom.translate( dx, dy );

      if ( errorCode == 0 )

      {

        editGeometryChange( featureId, translateGeom );

        setModified( true, true );

      }

      return errorCode;

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

    mFeatureCache->clear();

#ifdef ENABLE_GEOMETRYCACHE

#endif

  //TODO: is this needed here? I think not

  //mFeatureCache->clear();

#ifdef ENABLE_GEOMETRYCACHE

#endif

    if ( !mFeatureCache->isSelectValid() && ( mDataProvider->extent() == mFeatureCache->getCachedRectangle() ) )

    {

      //everything is cached already, what ain't in cache, ain't nowhere in layer :-)

      mFeatureCache->makeSelectValid();

    }

#ifdef ENABLE_GEOMETRYCACHE

#endif

        // added feature

void QgsVectorLayer::recacheFeature( int featureId, QgsRectangle rectFrom, QgsRectangle rectTo )

{

  if ( rectTo==QgsRectangle() )

    rectTo=mDataProvider->extent();

  QgsRectangle cachedRect=mFeatureCache->getCachedRectangle();

  rectFrom=rectFrom.intersect( &cachedRect );

  rectTo=rectTo.intersect( &cachedRect );

  mFeatureCache->remove( featureId, rectFrom );

  //now reinsert the feature from provider

  if ( mDataProvider->capabilities() & QgsVectorDataProvider::SelectGeometryAtId )

  {

    //either using existing method

    QgsFeature fet;

    mDataProvider->featureAtId( featureId, fet, true, mRenderer->classificationAttributes() );

    mFeatureCache->insert( fet, false );

  }

  else

  {

    //or fallback to search for feature id in specified rectangle

    mDataProvider->select( mRenderer->classificationAttributes(), rectTo );

    QgsFeature fet;

    while ( mDataProvider->nextFeature( fet ) )

    {

      if ( fet.id() == featureId )

      {

        mFeatureCache->insert( fet, false );

        mDataProvider->rewind();

        break;

      }

    }

  }

}

void QgsVectorLayer::recacheFeatures( QgsRectangle rect )

{

  QgsRectangle cachedRect=mFeatureCache->getCachedRectangle();

  rect=rect.intersect( &cachedRect );

  mFeatureCache->remove( rect );

  mDataProvider->select( mRenderer->classificationAttributes(), rect );

  QgsFeature fet; 

  while ( mDataProvider->nextFeature( fet ) )

  {

    mFeatureCache->insert( fet, false );

  }

}

/***************************************************************************

                      qgsfeaturecache.h - Spatial Feature Cache Class

                     --------------------------------------

 Date                 : 19-Jun-2009

 Copyright            : (C) 2009 by Andrej Krutak

 email                : andree at andree.sk

 ***************************************************************************

 *                                                                         *

 *   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 QGSFEATURECACHE_H

#define QGSFEATURECACHE_H

#include <QHash>

#include <QLinkedList>

#include "qgsfeature.h"

#include "qgis.h"

#include "qgsrectangle.h"

#include "qgslabel.h"

#include "qgsspatialindex.h"

/**

 * A feature cache class. Stores inserted features in memory and enables

 * efficient selects and feature retrievals.

 * 

 * Usage of the class:

 * 

 * After creating the class object, the cache is empty. To fill, one first

 * has to specify, what region will be filled - this is done by calling

 * select() method, where one specifies rectangle and attributes to be cached.

 * The method will obviously fail, because no data are cached yet.

 * (Also, until the cache is filled, isInitialized() will return false.)

 * 

 * After that, insert(feature, true) method has to be called to efficiently

 * insert contained features. After all features are inserted, setAsInitialized()

 * has to be called. This method efficiently commits all inserted features into

 * the cache. After this, the cache is initialized and all subsequent calls

 * to select(), using subset of previously specified rectangle and attributes,

 * will be successful. Features may then be retrieved by repetetive calls

 * of nextFeature().

 * 

 * One might want to retrieve features even if the requested rectangle doesn't

 * completely fit into cached area. In case the requested attributes are

 * a subset of cached ones, this is possible - just call makeSelectValid()

 * after select(). By calling this, it's possible to retrieve even partial

 * cache matches.

 * 

 * To modify existing cache data, one may use insert(feature, false), and 

 * remove() methods, which to immediate changes to the cached data. Note that

 * calling these methods for large ammounts of features may be quite slow -

 * in case a big part of tree has to be 'edited', it might be much faster

 * to clear() the cache and refill it again using previously mentioned method.

 *

 * There are several cache modes, that change the way cache keeps data stored.

 * It's possible to set new mode using setCacheMode(). To apply the mode

 * for a specified select, applyCurrentCacheMode() has to be called. The method

 * tells cache, what rectangle is currently required by user - according to this

 * the cache will determine, what data to discard (if any).

**/

class CORE_EXPORT QgsFeatureCache

{

public:

  QgsFeatureCache();

  ~QgsFeatureCache();

  /**

   * Inserts the specified feature to cache.

   * @param f feature to be inserted

   * @param deferredInsert if true, feature will only be inserted after calling 

   *                       setAsInitialized(); otherwise the feature is inserted

   *                       immediately (which is pretty costly in case of inserting

   *                       more than a few features)

   * @returns whether the operation was successful.

  **/

  bool insert( QgsFeature &f, bool deferredInsert=true );

  /**

   * Remove feature with specified id. If rect is specified, it will be

   * used as hint to find the feature (it could be e.g. feture's bounding rect.)

  **/

  bool remove( int featureId, QgsRectangle rect = QgsRectangle() );

  /**

   * Remove features intersecting specified rectangle.

  **/

  bool remove( QgsRectangle rect );

  /**

   * Returns, whether the cache is properly initialized (and thus the

   * nextFeature() and featureAtId() are usable)

  **/

  inline bool isInitialized() { return mIsInitialized; }

  /**

   * Returns, whether the last called select() left the

   * cache in state valid for iteration using nextFeature()

  **/

  inline bool isSelectValid() { return mSelectValid; }

  /**

   * Sets the cache as valid; to be called after it's filled with

   * features (@see insertFeature()) and only when the cache was empty before.

   * The cache parameters (contained rectangle, attributes) are set to current

   * select parameters.

  **/

  void setAsInitialized();

    /** Clear the cache; also sets it as not valid */

  void clear();

  /**

   * Select features; returns whether the cache is valid for the specified select

   * @param fetchAttributes attributes to fetch

   * @param rect rectangle to fetch the features from. If rect==QgsRectangle(),

   *             all features in cache are selected.

   * @param fetchGeometry also fetch geometries

   * @param useIntersect only retrieve features that really (not only their bounding rect) intersect with rectangle

   * @returns True, if select was successful (i.e. nextFeature() will return data).

  **/

  bool select( QgsAttributeList fetchAttributes,

                QgsRectangle rect = QgsRectangle(),

                bool fetchGeometry = true,

                bool useIntersect = false);

  /**

   * Make the last selected features fetchable using nextFeature(), if at least selected

   * attributes are subset of the the cached ones.

  **/

  void makeSelectValid();

  /** Retrieve next feature from the select; Returns false if there are no more features. */

  bool nextFeature( QgsFeature& feature );

  /** Returns the feature with specified Id. */

  bool featureAtId( int featureId, QgsFeature &f, bool fetchGeometries = true, bool fetchAttributes = true );

  /** cache modes */

  enum CacheMode {

    ///store all inserted features

    CACHE_ALL=0,

    /**

     * Store features and use heuristics to crop the stored rectangle size at

     * selects - and so optimize size of occupied memory.

    **/

    CACHE_HEURISTICS,

    ///don't store any features

    CACHE_NOTHING,

  };

  /** Sets cache mode. */

  void setCacheMode(CacheMode mode);

  /** Apply current cache mode to currently cached data (using specified rectangle). */

  void applyCurrentCacheMode(QgsRectangle const &rect);

  /** Returns cached rectangle. This is the biggest selectable rectangle. */

  QgsRectangle getCachedRectangle() { return mCachedRectangle; }

  /** Returns true, if cached attributes are superset of specified attributes list */

  bool areAttributesCached(QgsAttributeList list);

private:

  /** Filter out cached data outside the specified rectangle */

  void filterTo(QgsRectangle const &r);

  /** Contains, whether the cache has been filled for the current select */

  bool mIsInitialized;

  /** Holds cached features */

  QgsSpatialIndex *mCachedFeatures;

  /** Contains features waiting to be really inserted into tree by setAsInitialized() */

  QLinkedList<QgsFeature*> mCachedFeaturesList;

  /** Rectangle that is currently cached */

  QgsRectangle mCachedRectangle;

  /** Contains attribute list, that are stored in cached features */

  QgsAttributeList mCachedAttributes;

  /** Holds, whether geometries are also cached (alongside attributes) */

  bool mCachedIncludingGeometries;

  /** Holds, whether the current select is valid */

  bool mSelectValid;

  /** Select parameters - attributes */

  QgsAttributeList mSelectedAttributes;

  /** Select parameters - rectangle */

  QgsRectangle mSelectedRectangle;;

  /** Select parameters - fetch geometries?*/

  bool mSelectedFetchGeometries;

  /** Select parameters - use intersect?*/

  bool mSelectedUseIntersect;

  /** List of selected features */

  QLinkedList<QgsFeature*> mSelectedFeaturesList;

  /** Select parameters - iterator in the mCachedFeatures */

  QLinkedList<QgsFeature*>::iterator mSelectedFeaturesIterator;

  CacheMode mCacheMode;

};

#endif //QGSFEATURECACHE_H

class QgsFeatureCache;

    /**

     * Fetch the specified feature from provider, if it is cached. This

     * must be called every time the provider data change outside vector layer control.

     * @param featureId id of feature that should be reloaded

     * @param rectFrom hint of rectangle, where the feature resided. If not provided,

     *             whole cache will be searched for the id.

     * @param rectTo hint of rectangle, where the feature resides now. If not provided,

     *             all provider features will be searched for the id.

    **/

    void recacheFeature( int featureId, QgsRectangle rectFrom=QgsRectangle(), QgsRectangle rectTo=QgsRectangle() );

    /**

     * Fetch features from specified rectangle from provider, if it is cached. This

     * must be called every time the provider data change outside vector layer control.

     * @param rect rectangle containing changed features. All features within

     *             the rectangle will be reloaded.

    **/

    void recacheFeatures( QgsRectangle rect );

#ifdef ENABLE_GEOMETRYCACHE

#endif

#ifdef ENABLE_GEOMETRYCACHE

#endif

    /** Cache of features (used mainly for displaying of features) */

    QgsFeatureCache *mFeatureCache;

#ifndef EXTERNALSORT_SORTUSINGPRIORITYQUEUE

      std::vector<PQEntry*> m_buffer;

#else

#endif

#include <algorithm>

#ifdef EXTERNALSORT_SORTUSINGPRIORITYQUEUE

#else

      m_buffer.push_back( new PQEntry( pS, m_pComparator, tf ) );

#endif

#ifndef EXTERNALSORT_SORTUSINGPRIORITYQUEUE

      std::sort(m_buffer.begin(), m_buffer.end());

#endif

#ifdef EXTERNALSORT_SORTUSINGPRIORITYQUEUE

#else

        PQEntry* pqe = m_buffer.back(); m_buffer.pop_back();

#endif

#include "spatialindex/SpatialIndexImpl.h"

#include "rtree/Node.h"

#include "rtree/Leaf.h"

#include "rtree/Index.h"

#include "rtree/BulkLoader.h"

#include "rtree/RTree.h"

#include <stdexcept>

/** Convert rectangle to a region suitable for use in the spatial index library */

inline Tools::Geometry::Region rectToRegion( QgsRectangle rect )

{

  double pt1[2], pt2[2];

  pt1[0] = rect.xMinimum();

  pt1[1] = rect.yMinimum();

  pt2[0] = rect.xMaximum();

  pt2[1] = rect.yMaximum();

  return Tools::Geometry::Region( pt1, pt2, 2 );

}

inline QgsRectangle regionToRect( Tools::Geometry::Region rect )

{

  return QgsRectangle( rect.getLow(0), rect.getLow(1), rect.getHigh(0), rect.getHigh(1) );

}

/** returns, whether the rectBig contains rectSmall (with specified overflow exceptions) */

inline bool RectContainsWithOverflow( QgsRectangle rectBig, QgsRectangle rectSmall,

                               bool left, bool right,

                               bool over, bool under )

{

  bool rv=true;

  rv &= left  || !left  && (rectBig.xMinimum() < rectSmall.xMinimum());

  rv &= right || !right && (rectBig.xMaximum() > rectSmall.xMaximum());

  rv &= over  || !over  && (rectBig.yMinimum() < rectSmall.yMinimum());

  rv &= under || !under && (rectBig.yMaximum() > rectSmall.yMaximum());

  return rv;

}

/**

 * Creates a handle (pointer to pointer...) to specified feature. This

 * is needed for the RTree, as we can't directly change data node's data

 * (without removing and reinserting the node) and also because the data provided

 * to RTree is being memcopied (so we can't place a object there - we wouldn't be

 * able to delete it nicely later).

 * If the target is nonzero, it's an array where address of the

 * pointer to feature will be stored. Otherwise the array will be allocated

 * by the function.

 * @param f Feature to be handled

 * @param target if nonzero, it's considered to be a array of size sizeof(byte*),

 *               The return value will be stored in this array.

 * @returns Handle to the feature (newly allocated or ==target, if target!=0).

 *   The return value is an array containing the handle's value. Crazy stuff.

**/

inline byte* QgsFeaturePtr2ByteArray(QgsFeature* f, byte *target=0)

{

  //alloc a doublepointer to QgsFeature

  //Data (rv) -> fPtrPtr -> QgsFeature (f)

  //need to do this, because we can't change contents of Data, once inserted...

  byte* rv;

  if (target==0)

    rv=new byte[sizeof(byte*)];

  else

    rv=target;

  //create link: fPtrPtr -> f

  QgsFeature **fPtrPtr=new QgsFeature *;

  *fPtrPtr=f;

  //copy fPtrPtr address to rv

  memcpy(rv, &fPtrPtr, sizeof(QgsFeature**));

  return rv;

}

/**

 * Inverse operation to QgsFeaturePtr2ByteArray. Also deallocates the specified

 * pointer's array. Returns pointer to pointer to the feature referenced by handle.

**/

inline QgsFeature** ByteArray2QgsFeaturePtr(byte *p)

{

  QgsFeature** rv;

  //retrieve pointer to fPtrPtr

  memcpy(&rv, p, sizeof(QgsFeature**));

  //release received data copy

  delete []p;

  return rv;

}

/** Visitor that adds found features to list */

/** Visitor that's freeing QgsFeature** objects stored in the Rtree. */

class QgisFreeMemVisitor : public SpatialIndex::IVisitor

  public:

    QgisFreeMemVisitor( bool dontDeletePointer=false ):

      mOnlyFreeSpecifiedId(false), mDontDeletePointer(dontDeletePointer) {}

    QgisFreeMemVisitor( long onlyFreeId, bool dontDeletePointer=false ):

      mOnlyFreeId(onlyFreeId), mOnlyFreeSpecifiedId(true),

      mDontDeletePointer(dontDeletePointer) {}

    void visitNode( const INode& n ) {}

    void visitData( const IData& d )

    {

      if ( mOnlyFreeSpecifiedId && ( d.getIdentifier() != mOnlyFreeId ) )

        return;

      long unsigned len;

      byte *data;

      d.getData(len, &data);

      QgsFeature **ptr=ByteArray2QgsFeaturePtr(data);

      if ( !ptr )

        return;

      if (*ptr!=0)

      {

        delete *ptr;

        *ptr=0;

      }

      if ( !mDontDeletePointer )

        delete ptr;

    }

    void visitData( std::vector<const IData*>& v ) {}

  private:

    bool mDontDeletePointer;

    bool mOnlyFreeSpecifiedId;

    long mOnlyFreeId;

};

/** Visitor storing found features to a QLinkedList. */

class QgisFeatureVisitor : public SpatialIndex::IVisitor

{

  public:

    /**

     * If unlinkFeatureFromData==true, then the features are also detached from

     * the rtree (used e.g. when some features are extracted from tree and

     * the tree is deleted afterwards (which erases all contained features))

    */

    QgisFeatureVisitor( QLinkedList<QgsFeature *> & list, bool unlinkFeatureFromData = false )

        : mList( list ), mUnlinkFeatureFromData( unlinkFeatureFromData ) {}

    void visitNode( const INode& n ) {}

    void visitData( const IData& d )

    {

      long unsigned len;

      byte *data;

      d.getData(len, &data);

      QgsFeature **f=ByteArray2QgsFeaturePtr(data);

      mList.push_back( *f );

      if ( mUnlinkFeatureFromData )

        *f=0;

    }

    void visitData( std::vector<const IData*>& v ) {}

  private:

    QLinkedList<QgsFeature *>& mList;

    bool mUnlinkFeatureFromData;

};

/**

 * A trivial data stream providing RTree::Data objects from list to ExternalSort.

**/

class QgisFeatureLinkedListDataStream : public IDataStream

{

public:

  QgisFeatureLinkedListDataStream(QLinkedList<QgsFeature*> &list) : mList(list)

    { rewind(); }

  virtual ~QgisFeatureLinkedListDataStream() { }

  virtual IData* getNext()

  {

    if (!hasNext())

      return 0;

    Region r=rectToRegion((*mListIt)->geometry()->boundingBox());

    //We basically create a pointer to feature in list and hand pointer

    //to that pointer (=handle) to the caller (most probably it'll be

    //the Tools::ExternalSort::initializeRuns ...)

    byte ptr[sizeof(byte*)];

    QgsFeaturePtr2ByteArray(*mListIt, ptr);

    RTree::Data* ret = new RTree::Data(

      sizeof(byte*), ptr,

      r, (*mListIt)->id()

    );

    mListIt++;

    return ret;

  }

  virtual bool hasNext() throw (Tools::NotSupportedException)

    { return mListIt!=mList.end(); }

  virtual long unsigned size() throw (Tools::NotSupportedException)

    { throw Tools::NotSupportedException("Operation not supported."); }

  virtual void rewind() throw (Tools::NotSupportedException)

    { mListIt=mList.begin(); }

private:

  QLinkedList<QgsFeature*> &mList;

  QLinkedList<QgsFeature*>::iterator mListIt;

};

/** A strategy pattern class determining maximal bounding rectangle of a rtree */

class DetermineIndexedRectStrategy : public IQueryStrategy

{

public:

  QgsRectangle mIndexedRect;

public:

  void getNextEntry(const IEntry& entry, long& nextEntry, bool& hasNext)

  {

    Region region;

    //The first time we are called, entry points to the root. We don't need more.

    hasNext = false;

    IShape* ps;

    entry.getShape(&ps);

    ps->getMBR(region);

    delete ps;

    mIndexedRect=regionToRect(region);

  }

};

QgsSpatialIndex::QgsSpatialIndex(bool copyFeatures)

{

  initialize(QLinkedList<QgsFeature*>(), copyFeatures);

}

QgsSpatialIndex::QgsSpatialIndex(QLinkedList<QgsFeature*> features,

  bool copyFeatures )

{

  initialize(features, copyFeatures);

}

void QgsSpatialIndex::initialize(QLinkedList<QgsFeature*> features, bool copyFeatures)

{

  mCopyFeatures=copyFeatures;

  if (!features.empty()) {

    //Bulk load provided features into the empty tree

    QgisFeatureLinkedListDataStream stream(features);

    unsigned long bindex = static_cast<unsigned long>( std::floor( static_cast<double>( indexCapacity * fillFactor ) ) );

    unsigned long bleaf = static_cast<unsigned long>( std::floor( static_cast<double>( leafCapacity * fillFactor ) ) );

    SpatialIndex::RTree::BulkLoader bl;

    bl.bulkLoadUsingSTR( static_cast<RTree::RTree*>( mRTree ), stream, bindex, bleaf, 50000000 );

    //all features' pointers were added to index, make sure noone else will

    //use them,..

    features.clear();

  }

QgsSpatialIndex::~QgsSpatialIndex()

  uninitialize();

}

void QgsSpatialIndex::uninitialize()

{

  QgisFreeMemVisitor freeingVisitor;

  //free all feature pointers and features in the tree

  //TODO: what is maximal range? or how to select all features in rtree?

  //

  DetermineIndexedRectStrategy getRectStrategy;

  mRTree->queryStrategy(getRectStrategy);

  mRTree->intersectsWithQuery(

    rectToRegion( getRectStrategy.mIndexedRect ),

    freeingVisitor

  );

  //delete the rest of index

  return ::rectToRegion( rect );

  if (!mCopyFeatures)

  {

    return insertFeature(&f);

  }

  else

  {

    QgsFeature *fP=new QgsFeature(f);

    return insertFeature(fP);

  }

}

bool QgsSpatialIndex::insertFeature( QgsFeature* f )

{

  if ( !featureInfo( *f, r, id ) )

    if (!mCopyFeatures)

    {

      mRTree->insertData( 0, 0, r, id );

    }

    else

    {

      mRTree->insertData( sizeof(QgsFeature*), QgsFeaturePtr2ByteArray(f), r, id );

    }