InsertIteratorFilter.hpp

#ifndef DM_INSERT_ITERATOR_FILTER_HPP_INCLUDED
#define DM_INSERT_ITERATOR_FILTER_HPP_INCLUDED

#ifdef _MSC_VER
  #pragma once
#endif

#include "DM/Iterator.hpp"
#include "DM/IFilter.hpp"
#include "DM/IPoint.hpp"
#include "DM/IPolyline.hpp"
#include "DM/IPolygon.hpp"

DM_NAMESPACE_BEGIN

//forward declaration
template<class T>
class DM_API InsertIteratorFilter;

class DM_API FilterHelper {
protected:
  static void add_filtered(const IPoint         &pt,      FilterHandle filter, InsertIterator<IPoint>   &insIt);
  static void add_filtered(const PointHandle    &pt,      FilterHandle filter, InsertIterator<IPoint>   &insIt);
  //static void add_filtered(FilterHandle filter, InsertIterator<IPoint> &insIt); //final call

  static void add_filtered(const IPolyline      &line,    FilterHandle filter, InsertIterator<IPolyline>&insIt);
  static void add_filtered(const PolylineHandle &line,    FilterHandle filter, InsertIterator<IPolyline>&insIt);
  static void add_filtered(FilterHandle filter, InsertIterator<IPolyline> &insIt);  //final call

  static void add_filtered(const IPolygon       &polygon, FilterHandle filter, InsertIterator<IPolygon> &insIt);
  static void add_filtered(const PolygonHandle  &polygon, FilterHandle filter, InsertIterator<IPolygon> &insIt);
  static void add_filtered(FilterHandle filter, InsertIterator<IPolygon> &insIt); //final call

  static void add_filtered(const IGeometry      &geometry, FilterHandle filter, InsertIterator<IGeometry> &insIt);
  static void add_filtered(const GeometryHandle &geometry,  FilterHandle filter, InsertIterator<IGeometry> &insIt);
  static void add_filtered(FilterHandle filter, InsertIterator<IGeometry> &insIt);  //final call

  template<class T>
  friend class InsertIteratorFilter;
};

// Derive your custom filtered insert iterator from this interface
// to speed-up the iteration over the point index'es tiles:
// Tiles for which filter() says that no data at all will pass through (according to tile extents and attributes),
// will not be loaded at all!
class DM_API IInsertIteratorFilter
{
public:
  virtual ~IInsertIteratorFilter();
  virtual const FilterHandle filter() const = 0;
};

template<class T>
class DM_API InsertIteratorFilter : public InsertIterator<T>,
                                    public IInsertIteratorFilter
{
  typedef InsertIterator<T>       base;
  typedef InsertIteratorFilter  self;

public:
  /// creates a insert iterator filter for which the user has to take care of the correct live time of the provided insert iterator object
  InsertIteratorFilter(InsertIterator<T> &rInsIt, FilterHandle filter) : InsIt(rInsIt), Filter(filter), h_InsIt() {}
  /// creates a insert iterator filter and overtake ownership of the provided insert iterator object
  InsertIteratorFilter(InsertIterator<T> *pInsIt, FilterHandle filter) : InsIt(*pInsIt), Filter(filter), h_InsIt(pInsIt) {}
  virtual ~InsertIteratorFilter() {}

  virtual base& operator=(typename base::const_reference value)         { FilterHelper::add_filtered(value, Filter, InsIt);   return *this; }
  virtual base& operator=(typename base::const_handle_reference handle) { FilterHelper::add_filtered(handle, Filter, InsIt);  return *this; }

  virtual base& operator*()  { return *this; }
  virtual base& operator++() { return *this; };

  virtual void finished() { /*FilterHelper::add_filtered(Filter, InsIt);*/  }

  virtual const FilterHandle filter() const { return Filter; }
protected:
  InsertIterator<T> &InsIt;
  FilterHandle    Filter;
  Handle< InsertIterator<T> > h_InsIt;  //helper object to take the ownership of the actual insert iterator object if needed
};


/// creates a insert iterator filter for which the user has to take care of the correct live time of the provided insert iterator object
template<class T>
inline InsertIteratorFilter<T> filterInserter(InsertIterator<T> &insIt, FilterHandle filter) 
{
  return InsertIteratorFilter<T>(insIt, filter);
}


/// creates a insert iterator filter and overtake ownership of the provided insert iterator object (need to have the Delete function being overloaded)
template<class T>
inline InsertIteratorFilter<T> filterInserter(InsertIterator<T> *pInsIt, FilterHandle filter) 
{
  return InsertIteratorFilter<T>(pInsIt, filter);
}

DM_NAMESPACE_END

#endif //DM_INSERT_ITERATOR_FILTER_HPP_INCLUDED