# Source: GeoLines.js

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

    let GLS = NativeModules.JSGeoLines;

    import GeometryExp from './GeometryExp.js';
    import GeoLine from './GeoLine.js';

    /**
     * @class GeoLines
     */
    export default class GeoLines extends GeometryExp {
      constructor() {
        super();
        Object.defineProperty(this, '_MGGeoLinesId', {
          get: function() {
            return this._MGGeometryId;
          },
          set: function(_MGGeoLinesId) {
            this._MGGeometryId = _MGGeoLinesId;
          },
        });
      }

      /**
       * 构造一个新的 GeoLines 对象
       * @memberOf GeoLines
       * @return {Promise<GeoLines>}
       */
      async createObj() {
        try {
          var { GeoLinesId } = await GLS.createObj();
          var geoLines = new GeoLines();
          geoLines._MGGeoLinesId = GeoLinesId;
          return geoLines;
        } catch (e) {
          console.error(e);
        }
      }

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

      /**
       * 获取几何对象的维数
       * @memberOf GeoLines
       * @return {Promise}维数
       */
      async getDimension() {
        try {
          return await GLS.getDimension(this._MGGeoLinesId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 计算两个几何对象间的距离
       * @memberOf GeoLines
       * @param type 距离类型
       * @param destGeom 第二个几何对象
       * @return {Promise}距离长度
       */
      async distance(type, destGeom) {
        try {
          return await GLS.distance(
            this._MGGeoLinesId,
            type,
            destGeom._MGGeometryId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 删除线
       * @memberOf GeoLines
       * @param index 待删除线序号
       * @return {Promise}删除成功返回1，失败返回0
       */
      async del(index) {
        try {
          return await GLS.del(this._MGGeoLinesId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取线数目
       * @memberOf GeoLines
       * @return {Promise}线的条数
       */
      async getNum() {
        try {
          return await GLS.getNum(this._MGGeoLinesId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加一条线操作
       * @memberOf GeoLines
       * @param line 待添加的线对象
       * @return {Promise}添加成功返回1，失败返回0
       */
      async append(line) {
        try {
          return await GLS.append(this._MGGeoLinesId, line._MGGeoLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 更新线
       * @memberOf GeoLines
       * @param index 待更新线的序号
       * @param line 要更新的线对象
       * @return {Promise}更新成功返回1，失败返回0
       */
      async update(index, line) {
        try {
          return await GLS.update(this._MGGeoLinesId, index, line._MGGeoLineId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取线类型
       * @memberOf GeoLines
       * @param index 待取线的类型
       * @return {Promise}线类型
       */
      async getLineType(index) {
        try {
          return await GLS.getLineType(this._MGGeoLinesId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 按序号取一条线
       * @memberOf GeoLines
       * @param index 待取线的序号
       * @return {Promise<GeoLine>}获取的线对象
       */
      async getLine(index) {
        try {
          var { GeoLineId } = await GLS.getLine(this._MGGeoLinesId, index);
          var geoLine = new GeoLine();
          geoLine._MGGeoLineId = GeoLineId;
          return geoLine;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 计算线实地长度
       * @memberOf GeoLines
       * @param sRef 投影系参数
       * @return {Promise}实地长度
       */
      async calLengthOfSRef(sRef) {
        try {
          return await GLS.calLength(this._MGGeoLinesId, sRef._MGSRefDataId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 计算线平面长度
       * @memberOf GeoLines
       * @return {Promise}平面长度
       */
      async calLength() {
        try {
          return await GLS.calLength(this._MGGeoLinesId);
        } catch (e) {
          console.error(e);
        }
      }
    }