MetadataSh.hpp

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

#ifndef FIRE_PLUGIN_DATA_SHARED_METADATASH_HPP_INCLUDED
#define FIRE_PLUGIN_DATA_SHARED_METADATASH_HPP_INCLUDED

#include <boost/shared_ptr.hpp>
#include <fire/shared/Shared.hpp>

#include <string>
#include <exception>

#include "fire/gis/export.hpp"
#include "fire/source/vector/Buffer.hpp"
#include "fire/source/vector/Metadata.hpp"

namespace fire {
namespace source {
namespace vector {
namespace shared {

class FIRE_GIS_DLL MetadataSh: public fire::shared::Shared< Metadata > {
 public:
  MetadataSh(): Shared(NULL) {
        Metadata* mtd = new Metadata();
        _ptr.reset(mtd);
  }

  explicit MetadataSh(Metadata* ptr): Shared(ptr) {
  }

  explicit MetadataSh(const Metadata& mtd): Shared(NULL) {
      Metadata* ptr = new Metadata(mtd);
      _ptr.reset(ptr);
  }

  MetadataSh(const std::string& db, const std::string& schema, const std::string& tbl): Shared(NULL) {
      Metadata* mtd = new Metadata(db, schema, tbl);
      _ptr.reset(mtd);
  }

  MetadataSh(MetadataSh const & c) {
        this->operator =(c);
  }

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

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

        bool same = Shared::operator ==(r);
        if (same)
            return same;

        const Metadata& lMtd = *this;
        const Metadata& rMtd = r;

        return lMtd == rMtd;
  }

  inline bool isEqualsStricted(MetadataSh const & r) const {
      if (!r)
        return false;

      bool same = Shared::operator ==(r);
      if (same)
          return same;

      return _getPtr()->isEqualsStricted(r);
  }

  inline void getSource(std::string& db, std::string& schema, std::string& tbl) const {
        _getPtr()->getSource(db, schema, tbl);
  }

  inline void setSource(std::string const & db, std::string const & schema, std::string const & tbl) {
        _getPtr()->setSource(db, schema, tbl);
  }

  inline void add(const Field::FieldShp& fld) {
        return _getPtr()->add(fld);
  }

  inline Field::FieldShp del(const std::string& name) {
        return _getPtr()->del(name);
  }

  inline Field::FieldShp del(const size_t &idx) {
        return _getPtr()->del(idx);
  }

  inline size_t getCount() const {
        return _getPtr()->getCount();
  }

  inline int nameToIndex(const std::string& name) const {
        return _getPtr()->nameToIndex(name);
  }

  inline std::string indexToName(const int& idx) const {
        return _getPtr()->indexToName(idx);
  }

  inline void getKeyColumns(Metadata::VctFldName & list) const {
        return _getPtr()->getKeyColumns(list);
  }

  inline void getGeometryColumns(Metadata::VctFldName & list) const {
        return _getPtr()->getGeometryColumns(list);
  }

  inline Field::FieldShp get(const std::string& name) {
        return _getPtr()->get(name);
  }

  inline Field::FieldShp const get(const std::string& name) const {
        return _getPtr()->get(name);
  }

  inline Field::FieldShp get(const size_t& idx) {
        return _getPtr()->get(idx);
  }

  inline Field::FieldShp const get(const size_t& idx) const {
        return _getPtr()->get(idx);
  }
};

}  // namespace shared
}  // namespace vector
}  // namespace source
}  // namespace fire

#endif