Source: RecordSet.js

/**
 * @content 记录集功能组件
 * @author  2019-09-16
 */
import { NativeModules } from 'react-native';

let RS = NativeModules.JSRecordSet;

import Record from './Record.js';
import Fields from './Fields.js';
import Geometry from './Geometry.js';
import GeomInfo from './GeomInfo.js';
import GeoPoints from './GeoPoints.js'
import GeoVarLine from './GeoVarLine.js'
import GeoPolygon from './GeoPolygon.js'
import GeoPolygons from './GeoPolygons.js'
import GeoAnno from './GeoAnno.js'
import PntInfo from './PntInfo.js'
import LinInfo from './LinInfo.js'
import RegInfo from './RegInfo.js'
import TextAnnInfo from './TextAnnInfo.js'

/**
 * @class RecordSet
 * @description 扩展字段头
 */
export default class RecordSet {
  /**
   * 构造一个新的 RecordSet 对象。
   * @memberOf RecordSet
   * @returns {Promise.<RecordSet>} RecordSet 对象
   */
  async createObj() {
    try {
      var { RecordSetId } = await RS.createObj();
      var recordSet = new RecordSet();
      recordSet._MGRecordSetId = RecordSetId;
      return recordSet;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 光标移到最前
   * @memberOf RecordSet
   * @return {Promise} 光标位置 成功:>0;失败：<=0
   */
  async moveFirst() {
    try {
      return await RS.moveFirst(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 光标移到下一条
   * @memberOf RecordSet
   * @return {Promise} 光标位置 成功:>0;失败：<=0
   */
  async moveNext() {
    try {
      return await RS.moveNext(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取属性
   * @memberOf RecordSet
   * @return {Promise.<Record>} 属性信息
   */
  async getAtt() {
    try {
      let { RecordId } = await RS.getAtt(this._MGRecordSetId);
      var record = new Record();
      record._MGRecordId = RecordId;
      return record;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取当前记录ID
   * @memberOf RecordSet
   * @return {Promise} 当前记录ID
   */
  async getCurrentID() {
    try {
      return await RS.getCurrentID(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取属性结构
   * @memberOf RecordSet
   * @return {Promise.<Fields>} 属性结构
   */
  async getFields() {
    try {
      let { FieldsId } = await RS.getFields(this._MGRecordSetId);
      var fields = new Fields();
      fields._MGFieldsId = FieldsId;
      return fields;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取几何
   * @memberOf RecordSet
   * @return {Promise.<Geometry>} 几何
   */
  async getGeometry() {
    try {
      let { GeometryId,GeometryType } = await RS.getGeometry(this._MGRecordSetId);
      let geometry = null;
      switch(GeometryType)
      {
        case 2:
            geometry = new GeoPoints();
            geometry._MGGeometryId = GeometryId;
          break;
          case 12:
            geometry = new GeoVarLine();
            geometry._MGGeometryId = GeometryId;
          break;
          case 14:
            geometry = new GeoPolygon();
            geometry._MGGeometryId = GeometryId;
          break;
          case 15:
            geometry = new GeoPolygons();
            geometry._MGGeometryId = GeometryId;
          break;
          case 17:
            geometry = new GeoAnno();
            geometry._MGGeometryId = GeometryId;
            break;
          default:
            break;
      }
      return geometry;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取几何图形参数
   * @memberOf RecordSet
   * @return {Promise.<GeomInfo>} 图形参数
   */
  async getInfo() {
    try {
      let { GeomInfoId,GeometryType } = await RS.getInfo(this._MGRecordSetId);
      let geomInfo = null;
      switch(GeometryType)
      {
        case 2:
            geomInfo = new PntInfo();
            geomInfo._MGGeomInfoId = GeomInfoId;
          break;
          case 12:
            geomInfo = new LinInfo();
            geomInfo._MGGeomInfoId = GeomInfoId;
          break;
          case 14:
            geomInfo = new RegInfo();
            geomInfo._MGGeomInfoId = GeomInfoId;
          break;
          case 15:
            geomInfo = new RegInfo();
            geomInfo._MGGeomInfoId = GeomInfoId;
          break;
          case 17:
            geomInfo = new TextAnnInfo();
            geomInfo._MGGeomInfoId = GeomInfoId;
            break;
          default:
            break;
      }
      return geomInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 判断当前记录的位置是否在记录集中第一条记录的前面（当然第一条记录的前面是没有数据的），如果是返回 true；否则返回 false。
   * @memberOf RecordSet
   * @return {Promise<Bool>} 当前记录是否在第一条记录的前面
   */
  async isBOF() {
    try {
      return await RS.isBOF(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 判断当前记录的位置是否在记录集中的最后一条记录的后面，如果是，返回 true；否则返回 false。
   * @memberOf RecordSet
   * @return {Promise<Bool>}当前记录是否在最后一条记录的后面
   */
  async isEOF() {
    try {
      return await RS.isEOF(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取要素矩形范围
   * @memberOf RecordSet
   * @param rc 矩形范围对象
   * @return {Promise<void>}
   */
  async getRect(rc) {
    try {
      await RS.getRect(this._MGRecordSetId, rc._MGRectId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取对象信息
   * @memberOf RecordSet
   * @param geom 对象几何信息
   * @param rcd 对象属性信息
   * @param info 对象的图形信息
   * @return {Promise}成功：>0;失败：<=0
   */
  async get(geom, rcd, info) {
    try {
      return await RS.get(
        this._MGRecordSetId,
        geom._MGGeometryId,
        rcd._MGRecordId,
        info._MGGeomInfoId
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取几何类型或注记类型
   * @memberOf RecordSet
   * @return 几何类型或注记类型
   */
  async getGeometryType() {
    try {
      return await RS.getGeometryType(this._MGRecordSetId);
    } catch (e) {
      console.error(e);
    }
  }
}