Group.hpp

// Copyright 2015 GEOSYSTEMS SRL
// All Rights Reserved.

#ifndef FIRE_GEAR_GROUP__HPP_INCLUDED
#define FIRE_GEAR_GROUP__HPP_INCLUDED

#include <geos/index/SpatialIndex.h>

#include <boost/smart_ptr/shared_ptr.hpp>

#include <exception>
#include <vector>

#include "fire/export.hpp"

#include "fire/Group.hpp"
#include "fire/gear/geom/SpatialIndexType.hpp"
#include "fire/gear/Filter.hpp"
#include "fire/gear/event/EntityEventListener.hpp"
#include "fire/gear/event/EntityEvent.hpp"

namespace fire {
namespace gear {
class Entity;
}  // namespace gear
}  // namespace fire

namespace fire {
namespace gear {
class FIRE_ENGINE_DLL Group : public fire::Group< Entity* > {
 private:
  class EntityEventListener : public gear::event::EntityEventListener {
   private:
    Group* _group;

   public:
    explicit EntityEventListener(Group* group) {
      try {
        _group = group;
      } catch (const std::exception& exception) {
        throw;
      }
    }

    void handle(const gear::event::EntityEvent& entityEvent) {
      try {
        Entity* entity = entityEvent.getEntity();
        switch (entityEvent.getType()) {
          case gear::event::EntityEventType::Unknown:
          case gear::event::EntityEventType::AfterDestroy: {
            break;
          }
          case gear::event::EntityEventType::BeforeUpdate: {
            _group->beforeUpdate(entity);
            break;
          }
          case gear::event::EntityEventType::AfterUpdate: {
            _group->afterUpdate(entity);
            break;
          }
          case gear::event::EntityEventType::BeforeDestroy: {
            _group->exclude(entity);
            break;
          }
        }
      } catch (const std::exception& exception) {
        throw;
      }
    }
  };

 private:
  geom::SpatialIndexType::SpatialIndexType _spatialIndexType;
  boost::shared_ptr< geos::index::SpatialIndex > _spatialIndex;
  int _srid;
  Group::EntityEventListener* _entityEventListener;
  void InitSpatialIndexSrid(const geom::SpatialIndexType::SpatialIndexType& spatialIndexType, const int& srid);

 public:
  Group();
  explicit Group(const geom::SpatialIndexType::SpatialIndexType& spatialIndexType);
  Group(const geom::SpatialIndexType::SpatialIndexType& spatialIndexType, const int& srid);
  explicit Group(fire::Group< Entity* > group);
  Group(const Group& group);
  Group& operator=(const Group& group);
  virtual ~Group();
  void include(Entity* entity);
  using fire::Group< Entity* >::include;
  void exclude(Entity* entity);
  using fire::Group< Entity* >::exclude;
  void clear();
  using fire::Group< Entity* >::clear;
  bool contains(Entity* entity) const;
  using fire::Group< Entity* >::contains;
  Group filter(const Filter& filter) const;
  using fire::Group< Entity* >::filter;
  Group operator%(const Filter& filter) const;
  using fire::Group< Entity* >::operator%;
  void applySpatialIndex(const geom::SpatialIndexType::SpatialIndexType& spatialIndexType);
  void applySpatialIndex(const geom::SpatialIndexType::SpatialIndexType& spatialIndexType, const int& srid);
  void revokeSpatialIndex();
  bool isIndexed();
  void setSrid(int srid);
  void beforeUpdate(Entity* entity);
  void afterUpdate(Entity* entity);
  std::vector< geom::Geometry* > toGeometryVector() const;
  std::vector< Entity* > spatialIndexQuery(Entity* entity, int& spatialSize, int& depth);
};
}  // namespace gear
}  // namespace fire

#endif