# Source: UniqueTheme.js

    /*
     * @Description: In User Settings Edit
     * @Author: xiaoying
     * @Date: 2019-09-04 11:33:00
     * @LastEditTime: 2019-09-09 15:15:31
     * @LastEditors: mayuanye
     */
    import { NativeModules } from 'react-native';
    import ThemeInfo from './ThemeInfo.js';
    import UniqueThemeInfo from './UniqueThemeInfo.js';
    import VectorTheme from './VectorTheme.js';
    let UT = NativeModules.JSUniqueTheme;

    /**
     * @class UniqueTheme
     * @description 唯一值专题图
     */
    export default class UniqueTheme extends VectorTheme {
      constructor() {
        super();
        Object.defineProperty(this, '_MGUniqueThemeId', {
          get: function() {
            return this._MGVectorThemeId;
          },
          set: function(_MGUniqueThemeId) {
            this._MGVectorThemeId = _MGUniqueThemeId;
          },
        });
      }

      /**
       * 创建一个新的UniqueTheme对象
       *
       * @memberof UniqueTheme
       * @returns {Promise<UniqueTheme>}
       */
      async createObj() {
        try {
          var { UniqueThemeId } = await UT.createObj();
          var uniqueTheme = new UniqueTheme();
          uniqueTheme._MGUniqueThemeId = UniqueThemeId;
          return uniqueTheme;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取缺省专题绘制信息
       *
       * @memberof UniqueTheme
       * @returns {Object} 专题绘制信息 (Object---ThemeInfo)
       */
      async getDefaultInfo() {
        try {
          var { ThemeInfoId } = await UT.getDefaultInfo(this._MGUniqueThemeId);
          var themeInfo = null;
          if (ThemeInfoId != null) {
            themeInfo = new ThemeInfo();
            themeInfo._MGThemeInfoId = ThemeInfoId;
          }
          return themeInfo;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置缺省专题绘制信息
       *
       * @memberof UniqueTheme
       * @param {Object} themeInfo 专题绘制信息 (Object---ThemeInfo)
       * @returns {Promise<Void>}
       */
      async setDefaultInfo(themeInfo) {
        try {
          await UT.setDefaultInfo(this._MGUniqueThemeId, themeInfo._MGThemeInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取唯一字段表达式
       *
       * @memberof UniqueTheme
       * @returns {String}
       */
      async getExpression() {
        try {
          let expression = await UT.getExpression(this._MGUniqueThemeId);
          return expression;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置唯一字段表达式
       *
       * @memberof UniqueTheme
       * @param {String} expression 唯一字段表达式
       * @returns {Promise<Void>}
       */
      async setExpression(expression) {
        try {
          await UT.setExpression(this._MGUniqueThemeId, expression);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取单值专题图项数目
       *
       * @memberof UniqueTheme
       * @returns {int} 单值专题图项数目
       */
      async getCount() {
        try {
          let count = await UT.getCount(this._MGUniqueThemeId);
          return count;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取专题图类型
       *
       * @memberof UniqueTheme
       * @returns {int} 专题图类型 例: 1--AllOtherDataItemInfoSource.DefaultThemeInfo
       */
      async getAllOtherDataItemInfoSource() {
        try {
          let allOtherDataItemInfoSource = await UT.getAllOtherDataItemInfoSource(
            this._MGUniqueThemeId
          );
          return allOtherDataItemInfoSource;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置专题图类型
       *
       * @memberof UniqueTheme
       * @param {int} allOtherDataItemInfoSource 专题图类型 例: 1--AllOtherDataItemInfoSource.DefaultThemeInfo
       * @returns {Promise<Void>}
       */
      async setAllOtherDataItemInfoSource(allOtherDataItemInfoSource) {
        try {
          await UT.setAllOtherDataItemInfoSource(
            this._MGUniqueThemeId,
            allOtherDataItemInfoSource
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加项
       *
       * @memberof UniqueTheme
       * @param {Object} uniqueThemeInfo 单值专题图信息 (Object---UniqueThemeInfo)
       * @returns {int} 成功返回添加后专题图项索引
       */
      async append(uniqueThemeInfo) {
        try {
          let index = await UT.append(
            this._MGUniqueThemeId,
            uniqueThemeInfo._MGUniqueThemeInfoId
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 删除项（删除之后的语义是图元用未分类字段的颜色）
       *
       * @memberof UniqueTheme
       * @param {int} index 单值专题图项索引
       * @returns {boolean} true-成功 ；false-失败
       */
      async removeByIndex(index) {
        try {
          let result = await UT.removeByIndex(this._MGUniqueThemeId, index);
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 移除值为value的项
       *
       * @memberof UniqueTheme
       * @param {String} value 单值专题图项的值
       * @returns {boolean} true-成功 ；false-失败
       */
      async removeByValue(value) {
        try {
          let result = await UT.removeByValue(this._MGUniqueThemeId, value);
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 寻找值为value的项索引
       *
       * @memberof UniqueTheme
       * @param {String} value 单值专题图项的值
       * @returns {int} 成功返回索引
       */
      async indexOf(value) {
        try {
          let index = await UT.indexOf(this._MGUniqueThemeId, value);
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 清空所有的项
       *
       * @memberof UniqueTheme
       * @returns {boolean} true-成功 ；false-失败
       */
      async clear() {
        try {
          let result = await UT.clear(this._MGUniqueThemeId);
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置项信息
       *
       * @memberof UniqueTheme
       * @param {int} index 单值专题图项索引
       * @param {Object} uniqueThemeInfo 单值专题图项信息 （Object -- UniqueThemeInfo ）
       * @returns {boolean} true-成功 ；false-失败
       */
      async setItem(index, uniqueThemeInfo) {
        try {
          let result = await UT.setItem(
            this._MGUniqueThemeId,
            index,
            uniqueThemeInfo._MGUniqueThemeInfoId
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取项信息
       *
       * @memberof UniqueTheme
       * @param {int} index 单值专题图项索引
       * @returns {promise<UniqueThemeInfo>} 成功返回项的信息
       */
      async getItem(index) {
        try {
          var { UniqueThemeInfoId } = await UT.getItem(
            this._MGUniqueThemeId,
            index
          );
          var uniqueThemeInfo = null;
          if (UniqueThemeInfoId != null) {
            uniqueThemeInfo = new UniqueThemeInfo();
            uniqueThemeInfo._MGUniqueThemeInfoId = UniqueThemeInfoId;
          }
          return uniqueThemeInfo;
        } catch (e) {
          console.error(e);
        }
      }
    }