EnvelopeSh.hpp

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

#ifndef FIRE_GEAR_GEOM_SHARED_ENVELOPESH_HPP_INCLUDED
#define FIRE_GEAR_GEOM_SHARED_ENVELOPESH_HPP_INCLUDED

#include <string>
#include <exception>

#include "fire/shared/Shared.hpp"
#include "fire/gear/geom/Envelope.hpp"

namespace fire {
namespace gear {
namespace geom {
namespace shared {

class EnvelopeSh : public fire::shared::Shared< Envelope > {
 public:
  EnvelopeSh(): Shared(NULL) {
    Envelope* env = new Envelope();
    _ptr.reset(env);
  }

  explicit EnvelopeSh(Envelope* ptr): Shared(ptr) {
  }

  explicit EnvelopeSh(const Envelope & e): Shared(NULL) {
        Envelope* env = new Envelope(e);
        _ptr.reset(env);
  }

  EnvelopeSh(EnvelopeSh const & c): Shared(c) {
  }

  /*
  explicit EnvelopeSh(int const & srid = 0): Shared(NULL) {
      Envelope* env = new Envelope(srid);
      _ptr.reset(env);
  }
  */

  EnvelopeSh(const double& x1, const double& x2, const double& y1, const double& y2, int const & srid = 0) {
      Envelope* env = new Envelope(x1, x2, y1, y2, srid);
      _ptr.reset(env);
  }

  EnvelopeSh(const Coordinate& c1, const Coordinate& c2, int const & srid = 0) {
      Envelope* env = new Envelope(c1, c2, srid);
      _ptr.reset(env);
  }

  explicit EnvelopeSh(const Coordinate& c, int const & srid = 0) {
      Envelope* env = new Envelope(c, srid);
      _ptr.reset(env);
  }

  inline EnvelopeSh clone() const {
        EnvelopeSh ret(*_getPtr());
        return ret;
  }

  inline bool operator!=(EnvelopeSh const & r) const {
      return !(this->operator ==(r));
  }

  inline bool operator==(EnvelopeSh const & r) const {
        if (!r)
          return false;

        if (Shared::operator ==(r))
            return true;

        const Envelope& lEnv = *this;
        const Envelope& rEnv = r;
        return lEnv.equals(rEnv);
  }

  void init(int const & srid = 0) {
      _ptr->init(srid);
  }

  void init(const double& x1, const double& x2, const double& y1, const double& y2, int const & srid = 0)  {
      _ptr->init(x1, x2, y1, y2, srid);
  }

  void init(const Coordinate& c1, const Coordinate& c2, int const & srid = 0) {
      _ptr->init(c1, c2, srid);
  }

  void init(const Coordinate& c, int const & srid = 0) {
      _ptr->init(c, srid);
  }

  void setToNull()  {
      _ptr->setToNull();
  }

  bool isNull() const  {
      return _ptr->isNull();
  }

  double getWidth() const  {
      return _ptr->getWidth();
  }

  double getHeight() const  {
      return _ptr->getHeight();
  }

  double getArea() const  {
      return _ptr->getArea();
  }

  double getMaxX() const {
      return _ptr->getMaxX();
  }

  double getMaxY() const {
      return _ptr->getMaxY();
  }

  double getMinX() const {
      return _ptr->getMinX();
  }

  double getMinY() const {
      return _ptr->getMinY();
  }

  int getSrid() const {
      return _ptr->getSrid();
  }

  bool centre(Coordinate & c) const {
      return _ptr->centre(c);
  }

  void translate(const double& dx, const double& dy) {
      return _ptr->translate(dx, dy);
  }

  void expandBy(const double& dx, const double& dy) {
      _ptr->expandBy(dx, dy);
  }

  void expandBy(const double& distance) {
      _ptr->expandBy(distance);
  }

  void expandToInclude(const double& x, const double& y) {
      _ptr->expandToInclude(x, y);
  }

  void expandToInclude(const Coordinate& c) {
      _ptr->expandToInclude(c);
  }

  void expandToInclude(const Envelope& e) {
      _ptr->expandToInclude(e);
  }

  void setSrid(int const & srid) {
      _ptr->setSrid(srid);
  }

  bool contains(const double& x, const double& y) const {
      return _ptr->contains(x, y);
  }

  bool contains(const Coordinate& c) const {
      return _ptr->contains(c);
  }

  bool contains(const Envelope& e) const {
      return _ptr->contains(e);
  }

  bool intersects(const double& x, const double& y) const {
      return _ptr->intersects(x, y);
  }

  bool intersects(const Coordinate& c) const {
      return _ptr->intersects(c);
  }

  bool intersects(const Envelope& e) const {
      return _ptr->intersects(e);
  }

  bool intersection(const Envelope& e, Envelope& r) const {
      return _ptr->intersection(e, r);
  }

  fire::gear::geom::Geometry* toGeometry() const {
      return _ptr->toGeometry();
  }

  bool isPoint() const {
      return _ptr->isPoint();
  }

  bool isLine() const {
      return _ptr->isLine();
  }

  bool covers(const double& x, const double& y) const {
      return _ptr->covers(x, y);
  }

  bool covers(const Coordinate& c) const {
      return _ptr->covers(c);
  }

  bool covers(const Envelope& e) const {
      return _ptr->covers(e);
  }

  bool equals(const fire::gear::geom::Envelope& e) const {
      return _ptr->equals(e);
  }

  std::string toString() const {
      return _ptr->toString();
  }

  double distance(const Envelope& e) const {
      return _ptr->distance(e);
  }
};
}  // namespace shared
}  // namespace geom
}  // namespace gear
}  // namespace fire

#endif