FieldSh.hpp

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

#ifndef FIRE_PLUGIN_DATA_SHARED_FIELDSH_HPP_INCLUDED
#define FIRE_PLUGIN_DATA_SHARED_FIELDSH_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/Field.hpp"

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

class FIRE_GIS_DLL FieldSh: public fire::shared::Shared< Field > {
 public:
    FieldSh(): Shared(NULL) {
    }

    explicit FieldSh(Field* ptr): Shared(ptr) {
    }

    explicit FieldSh(Field const & fld): Shared(NULL) {
        Field* fldPtr = new Field(fld);
        _ptr.reset(fldPtr);
    }

    explicit FieldSh(const std::string & name, const FieldType::FieldType & type, const bool & nullable, const bool & isKeyPart, const int & nativeType = -1): Shared(NULL) {
        Field* fldPtr = new Field(name, type, nullable, isKeyPart, nativeType);
        _ptr.reset(fldPtr);
    }

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

    inline FieldSh clone() const {
          Field* fld = new Field(*_getPtr());
          FieldSh ret(fld);
          return ret;
    }

    inline bool isEqualsStricted(FieldSh const & r) const {
        return _getPtr()->isEqualsStricted(r);
    }

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

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

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

          const Field& lFld = *this;
          const Field& rFld = r;
          return lFld == rFld;
    }

    inline std::string getName() const {
      return _getPtr()->getName();
    }

    inline FieldType::FieldType getType() const {
      return _getPtr()->getType();
    }

    inline int getNativeType() const {
      return _getPtr()->getNativeType();
    }

    inline bool isNullable() const {
      return _getPtr()->isNullable();
    }

    inline bool isKeyPart() const {
      return _getPtr()->isKeyPart();
    }

    inline void setName(std::string const & name) {
      _getPtr()->setName(name);
    }

    inline void setType(FieldType::FieldType const & ft) {
      _getPtr()->setType(ft);
    }

    inline void setNullable(bool  const & nullable) {
      _getPtr()->setNullable(nullable);
    }

    inline void setKeyPart(bool const & keypart) {
      _getPtr()->setKeyPart(keypart);
    }

    inline void addExtraParam(Field::ExtraParamFieldType id, const int& val) {
        _getPtr()->addExtraParam(id, val);
      }

    inline const int getExtraParam(const Field::ExtraParamFieldType id) const {
        return _getPtr()->getExtraParam(id);
      }

    inline bool existsExtraParam(const Field::ExtraParamFieldType id) const {
        return _getPtr()->existsExtraParam(id);
      }
};

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

#endif