# Source: GeoVarLine.js

    /**
     * @content 用于对多边形的几何功能组件
     * @author  2019-09-09
     */
    import { NativeModules } from 'react-native';

    let GVL = NativeModules.JSGeoVarLine;

    import GeoLine from './GeoLine.js';
    import Dot from './Dot.js';
    import Dot3D from './Dot3D.js';

    /**
     * @class GeoVarLine
     */
    export default class GeoVarLine extends GeoLine {
      constructor() {
        super();
        Object.defineProperty(this, '_MGGeoVarLineId', {
          get: function() {
            return this._MGGeoLineId;
          },
          set: function(_MGGeoVarLineId) {
            this._MGGeoLineId = _MGGeoVarLineId;
          },
        });
      }

      /**
       * 构造一个新的 GeoVarLine 对象
       * @memberOf GeoVarLine
       * @return {Promise<GeoVarLine>}
       */
      async createObj() {
        try {
          var { GeoVarLineId } = await GVL.createObj();
          var geoVarLine = new GeoVarLine();
          geoVarLine._MGGeoVarLineId = GeoVarLineId;
          return geoVarLine;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取几何对象的类型
       * @memberOf GeoVarLine
       * @return {Promise} 几何对象类型
       */
      async getType() {
        try {
          return await GVL.getType(this._MGGeoVarLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加2维点
       * @memberOf GeoVarLine
       * @param dot 待添加的二维点坐标
       * @return {Promise}添加成功返回1，失败返回0
       */
      async append2D(dot) {
        try {
          return await GVL.append2D(this._MGGeoVarLineId, dot._MGDotId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加3维点
       * @memberOf GeoVarLine
       * @param dot 待添加的三维点坐标
       * @return {Promise}添加成功返回1，失败返回0
       */
      async append3D(dot3D) {
        try {
          return await GVL.append3D(this._MGGeoVarLineId, dot3D._MGDot3DId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 删除坐标点
       * @memberOf GeoVarLine
       * @param index 待删除的点序号
       * @return {Promise}删除成功返回1，失败返回0
       */
      async del(index) {
        try {
          return await GVL.del(this._MGGeoVarLineId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取2维点
       * @memberOf GeoVarLine
       * @param index 待获取的点序号
       * @return {Promise<Dot>}获取成功返回1，失败返回0
       */
      async get2D(index) {
        try {
          let { point2DId } = await GVL.get2D(this._MGGeoVarLineId, index);
          var dot = new Dot();
          dot._MGDotId = point2DId;
          return dot;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取3维点
       * @memberOf GeoVarLine
       * @param index 待获取的点序号
       * @return {Promise<Dot3D>}获取成功返回1，失败返回0
       */
      async get3D(index) {
        try {
          let { Dot3DId } = await GVL.get3D(this._MGGeoVarLineId, index);
          var dot3D = new Dot3D();
          dot3D._MGDot3DId = Dot3DId;
          return dot3D;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取维数
       * @memberOf GeoVarLine
       * @return {Promise}维数
       */
      async getDim() {
        try {
          return await GVL.getDim(this._MGGeoVarLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取点数目
       * @memberOf GeoVarLine
       * @return {Promise}点的数目
       */
      async getDotNum() {
        try {
          return await GVL.getDotNum(this._MGGeoVarLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取X坐标值
       * @memberOf GeoVarLine
       * @param index 待获取的点序号
       * @return {Promise}获取该点的X坐标值
       */
      async getX(index) {
        try {
          return await GVL.getX(this._MGGeoVarLineId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取Y坐标值
       * @memberOf GeoVarLine
       * @param index 待获取的点序号
       * @return {Promise}获取该点的Y坐标值
       */
      async getY(index) {
        try {
          return await GVL.getY(this._MGGeoVarLineId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取Z坐标值
       * @memberOf GeoVarLine
       * @param index 待获取的点序号
       * @return {Promise}获取该点的Z坐标值
       */
      async getZ(index) {
        try {
          return await GVL.getZ(this._MGGeoVarLineId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 更新2维坐标点
       * @memberOf GeoVarLine
       * @param index 待更新的点序号
       * @param dot 待更新的点坐标
       * @return {Promise}更新成功返回1，失败返回0
       */
      async update2D(index, dot) {
        try {
          return await GVL.update2D(this._MGGeoVarLineId, index, dot._MGDotId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 更新3维坐标点
       * @memberOf GeoVarLine
       * @param index 待更新的点序号
       * @param dot 待更新的点坐标
       * @return {Promise}更新成功返回1，失败返回0
       */
      async update3D(index, dot) {
        try {
          return await GVL.update3D(this._MGGeoVarLineId, index, dot._MGDot3DId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 由三维点集合构建折线
       * @memberOf GeoVarLine
       * @param dots 用来构建线的三维点集合
       * @return {Promise}构建成功返回1，失败返回0
       */
      async setDots3D(dots) {
        try {
          return await GVL.setDots3D(this._MGGeoVarLineId, dots._MGDots3DId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 由二维点集合构建折线
       * @memberOf GeoVarLine
       * @param dots 用来构建线的二维维点集合
       * @return {Promise}构建成功返回1，失败返回0
       */
      async setDots2D(dots) {
        try {
          return await GVL.setDots2D(this._MGGeoVarLineId, dots._MGDotsId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 判断线段是否封闭
       * @memberOf GeoVarLine
       * @return {Promise}线段封闭返回true，不封闭返回false
       */
      async isClosed() {
        try {
          return await GVL.isClosed(this._MGGeoVarLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 清空数据
       * @memberOf GeoVarLine
       * @return {Promise}清空数据成功返回1，失败返回0
       */
      async empty() {
        try {
          return await GVL.empty(this._MGGeoVarLineId);
        } catch (e) {
          console.error(e);
        }
      }
    }