Entity.hpp

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

#ifndef FIRE_GEAR_ENTITY_HPP_INCLUDED
#define FIRE_GEAR_ENTITY_HPP_INCLUDED

#include <vector>

#include "fire/export.hpp"

#include "fire/gear/event/EntityEvent.hpp"
#include "fire/gear/geom/GeometryType.hpp"
#include "fire/gear/geom/event/GeometryEventListener.hpp"

namespace fire {
namespace gear {
namespace geom {
class Geometry;
class Envelope;
}  // namespace geom
}  // namespace gear
}  // namespace fire

namespace fire {
namespace gear {
class FIRE_ENGINE_DLL Entity : public fire::Object {
 private:
  class GeometryEventListener : public geom::event::GeometryEventListener {
   private:
    gear::event::EntityEvent* _entityEvent;

   public:
    explicit GeometryEventListener(gear::event::EntityEvent* entityEvent) {
      try {
        _entityEvent = entityEvent;
      } catch (const std::exception& exception) {
        throw;
      }
    }
    void handle(const geom::event::GeometryEvent& geometryEvent) {
      try {
        switch (geometryEvent.getType()) {
          case geom::event::GeometryEventType::Unknown:
          case geom::event::GeometryEventType::AfterDestroy: {
            _entityEvent->raise(gear::event::EntityEventType::Unknown);
            break;
          }
          case geom::event::GeometryEventType::BeforeUpdate: {
            _entityEvent->raise(gear::event::EntityEventType::BeforeUpdate);
            break;
          }
          case geom::event::GeometryEventType::AfterUpdate: {
            _entityEvent->raise(gear::event::EntityEventType::AfterUpdate);
            break;
          }
          case geom::event::GeometryEventType::BeforeDestroy: {
            _entityEvent->raise(gear::event::EntityEventType::BeforeDestroy);
            break;
          }
        }
      } catch (const std::exception& exception) {
        throw;
      }
    }
  };

 public:
  typedef std::vector< geom::Geometry* > vectorGeomType;
  typedef std::vector< geom::Geometry* >::iterator iterator;
  typedef std::vector< geom::Geometry* >::const_iterator const_iterator;
  typedef std::vector< geom::Geometry* >::reverse_iterator reverse_iterator;
  typedef std::vector< geom::Geometry* >::const_reverse_iterator const_reverse_iterator;

 private:
  vectorGeomType _geometriesVector;
  gear::event::EntityEvent _entityEvent;
  std::auto_ptr< GeometryEventListener > _geometryEventListener;
  void clearGeometry();

 protected:
  void addGeometry(geom::Geometry* geometry);
  void removeGeometry(geom::Geometry* geometry);

 public:
  Entity();
  Entity(const Entity& entity);
  Entity& operator=(const Entity& entity);
  virtual ~Entity();
  virtual vectorGeomType getGeometries();
  virtual iterator begin();
  virtual const_iterator begin() const;
  virtual iterator end();
  virtual const_iterator end() const;
  virtual reverse_iterator rbegin();
  virtual const_reverse_iterator rbegin() const;
  virtual reverse_iterator rend();
  virtual const_reverse_iterator rend() const;
  virtual geom::Envelope* getEnvelope(int srid);
  gear::event::EntityEvent& getEvent();
  virtual geom::GeometryType::GeometryType getGeometryType() const;
};
}  // namespace gear
}  // namespace fire

#endif