# Source: MultiClassTheme.js

    /*
     * @Description: In User Settings Edit
     * @Author: xiaoying
     * @Date: 2019-09-03 12:00:02
     * @LastEditTime: 2019-09-09 16:05:00
     * @LastEditors: mayuanye
     */
    import { NativeModules } from 'react-native';
    import ClassItemValue from './ClassItemValue.js';
    import MultiClassThemeInfo from './MultiClassThemeInfo.js';
    import ThemeInfo from './ThemeInfo.js';
    import VectorTheme from './VectorTheme.js';
    let MCT = NativeModules.JSMultiClassTheme;

    /**
     * @class MultiClassTheme
     * @description 多表达式分段专题图
     */
    export default class MultiClassTheme extends VectorTheme {
      constructor() {
        super();
        Object.defineProperty(this, '_MGMultiClassThemeId', {
          get: function() {
            return this._MGVectorThemeId;
          },
          set: function(_MGMultiClassThemeId) {
            this._MGVectorThemeId = _MGMultiClassThemeId;
          },
        });
      }

      /**
       * 构造一个新的MultiClassTheme对象
       *
       * @memberof MultiClassTheme
       * @returns {Promise<MultiClassTheme>}
       */
      async createObj() {
        try {
          var { MultiClassThemeId } = await MCT.createObj();
          var multiClassTheme = new MultiClassTheme();
          multiClassTheme._MGMultiClassThemeId = MultiClassThemeId;
          return multiClassTheme;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取缺省专题绘制信息
       *
       * @memberof MultiClassTheme
       * @returns {Promise<ThemeInfo>}
       */
      async getDefaultInfo() {
        try {
          var { ThemeInfoId } = await MCT.getDefaultInfo(this._MGMultiClassThemeId);
          var themeInfo = new ThemeInfo();
          themeInfo._MGThemeInfoId = ThemeInfoId;
          return themeInfo;
        } catch (e) {
          console.error(e);
        }
      }

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

      /**
       * 获得分级字段表达式的数目
       *
       * @memberof MultiClassTheme
       * @returns {int} 分级字段表达式的数目
       */
      async getExpCount() {
        try {
          let expCount = await MCT.getExpCount(this._MGMultiClassThemeId);
          return expCount;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得项（做完笛卡尔积之后）的个数
       *
       * @memberof MultiClassTheme
       * @returns {int} 项（做完笛卡尔积之后）的个数
       */
      async getItemCount() {
        try {
          let itemCount = await MCT.getItemCount(this._MGMultiClassThemeId);
          return itemCount;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得专题图类型
       *
       * @memberof MultiClassTheme
       * @returns {int} 专题图类型，例：AllOtherDataItemInfoSource.DefaultThemeInfo
       */
      async getAllOtherDataItemInfoSource() {
        try {
          let itemCount = await MCT.getAllOtherDataItemInfoSource(
            this._MGMultiClassThemeId
          );
          return itemCount;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置专题图类型
       *
       * @memberof MultiClassTheme
       * @param {int} allOtherDataItemInfoSource 专题图类型，例：AllOtherDataItemInfoSource.DefaultThemeInfo
       * @returns {Promise<Void>}
       *
       */
      async setAllOtherDataItemInfoSource(allOtherDataItemInfoSource) {
        try {
          await MCT.setAllOtherDataItemInfoSource(
            this._MGMultiClassThemeId,
            allOtherDataItemInfoSource
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加分级字段表达式
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} classItemType 统计分段类型
       * @returns {int} 成功返回索引
       */
      async appendExpression(exp, classItemType) {
        try {
          let index = await MCT.appendExpression(
            this._MGMultiClassThemeId,
            exp,
            classItemType
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 移除分级字段表达式
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @returns {boolean} true-成功 ：false-失败
       */
      async removeExpression(exp) {
        try {
          let result = await MCT.removeExpression(this._MGMultiClassThemeId, exp);
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得分级字段表达式的索引
       *
       * @memberof MultiClassTheme
       * @param {String} exp
       * @returns {int} 成功返回字段表达式的索引
       */
      async indexOfExpression(exp) {
        try {
          let index = await MCT.indexOfExpression(this._MGMultiClassThemeId, exp);
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得分级字段表达式
       *
       * @memberof MultiClassTheme
       * @param {int} index 字段表达式索引
       * @returns {String} 成功返回分级字段表达式
       */
      async getExpression(index) {
        try {
          let exp = await MCT.getExpression(this._MGMultiClassThemeId, index);
          return exp;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 交换两个分级字段表达式
       *
       * @memberof MultiClassTheme
       * @param {int} index1 字段表达式的索引
       * @param {int} index2 字段表达式的索引
       * @returns {boolean} true-成功 ： false-失败
       */
      async exchangeExpressions(index1, index2) {
        try {
          let result = await MCT.exchangeExpressions(
            this._MGMultiClassThemeId,
            index1,
            index2
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得分级字段表达式的类型
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @returns {int} 成功返回字段表达式的统计分段类型，例：ClassItemType.UniqueType
       */
      async getExpressionClassItemType(exp) {
        try {
          let type = await MCT.getExpressionClassItemType(
            this._MGMultiClassThemeId,
            exp
          );
          return type;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加和字段表达式对应的分段值
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {Object} classItemValue 和字段表达式对应的分段值
       * @returns {int} 成功返回字段表达式索引
       */
      async appendSubItem(exp, classItemValue) {
        try {
          let index = await MCT.appendSubItem(
            this._MGMultiClassThemeId,
            exp,
            classItemValue._MGClassItemValueId
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 删除和字段表达式对应的分段值
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} index 和字段表达式对应的分段值的索引
       * @returns {boolean} true-成功 ；false-失败
       */
      async removeSubItem(exp, index) {
        try {
          let result = await MCT.removeSubItem(
            this._MGMultiClassThemeId,
            exp,
            index
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 合并和字段表达式对应的分段值（只对表达式值为RangeTheme类型的管用）
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} index 待合并的分段值的索引
       * @param {int} count 待合并的分段值的数目
       * @returns {boolean} true-成功 ；false-失败
       */
      async mergeSubItem(exp, index, count) {
        try {
          let result = await MCT.mergeSubItem(
            this._MGMultiClassThemeId,
            exp,
            index,
            count
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 分裂给定字段表达式对应的分段值（只对表达式值为RangeTheme类型的管用）
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} index 待分裂的分段值的索引
       * @param {double} splitValue 拆分值
       * @returns {boolean} true-成功 ；false-失败
       */
      async splitSubItem(exp, index, splitValue) {
        try {
          let result = await MCT.splitSubItem(
            this._MGMultiClassThemeId,
            exp,
            index,
            splitValue
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得给定的值在分段中的索引
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {String} itemValue  字段值
       * @returns {int} 成功返回给定的值在分段中的索引
       */
      async indexOfSubItem(exp, itemValue) {
        try {
          let index = await MCT.indexOfSubItem(
            this._MGMultiClassThemeId,
            exp,
            itemValue
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 清除给定字段表达式的所有分段
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @returns {boolean} true-成功 ；false-失败
       */
      async clearSubItems(exp) {
        try {
          let result = await MCT.clearSubItems(this._MGMultiClassThemeId, exp);
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得给定字段表达式的分段数目
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @returns {int} 成功返回给定字段表达式的分段数目
       */
      async getSubItemCount(exp) {
        try {
          let count = await MCT.getSubItemCount(this._MGMultiClassThemeId, exp);
          return count;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 修改给定字段表达式中指定索引处的值
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} index 分段索引
       * @param {Object} classItemValue 分段值
       * @returns {boolean} true-成功 ；false-失败
       */
      async setSubItemValue(exp, index, classItemValue) {
        try {
          let result = await MCT.setSubItemValue(
            this._MGMultiClassThemeId,
            exp,
            index,
            classItemValue._MGClassItemValueId
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取给定字段表达式中指定索引处的值
       *
       * @memberof MultiClassTheme
       * @param {String} exp 字段表达式
       * @param {int} index 分段索引
       * @returns {Promise<ClassItemValue>} 成功返回给定字段表达式中指定索引处的值
       */
      async getSubItemValue(exp, index) {
        try {
          var { ClassItemValueId } = await MCT.getSubItemValue(
            this._MGMultiClassThemeId,
            exp,
            index
          );
          var classItemValue = new ClassItemValue();
          classItemValue._MGClassItemValueId = ClassItemValueId;
          return classItemValue;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 生成所有的分段信息（该函数在调整了expression或者expression内部的分段信息后都需要调用）
       *
       * @memberof MultiClassTheme
       * @param {boolean} maintainExistentStyle 指示之前存在的分段的样式是否保持不变
       * @returns {boolean} true-成功 ；false-失败
       */
      async make(maintainExistentStyle) {
        try {
          let result = await MCT.make(
            this._MGMultiClassThemeId,
            maintainExistentStyle
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 返回指定项（做完笛卡尔积之后）的信息
       *
       * @memberof MultiClassTheme
       * @param {int} index 项索引
       * @returns {Promise<MultiClassThemeInfo>} 成功返回指定项的信息
       */
      async getItem(index) {
        try {
          var { MultiClassThemeInfoId } = await MCT.getItem(
            this._MGMultiClassThemeId,
            index
          );
          var multiClassThemeInfo = new MultiClassThemeInfo();
          multiClassThemeInfo._MGMultiClassThemeInfoId = MultiClassThemeInfoId;
          return multiClassThemeInfo;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置每个项（做完笛卡尔积之后）的信息
       *
       * @memberof MultiClassTheme
       * @param {int} index 项索引
       * @param {Object} multiClassThemeInfo 项信息
       * @returns {boolean} true-成功 ；false-失败
       */
      async setItem(index, multiClassThemeInfo) {
        try {
          let result = await MCT.setItem(
            this._MGMultiClassThemeId,
            index,
            multiClassThemeInfo._MGMultiClassThemeInfoId
          );
          return result;
        } catch (e) {
          console.error(e);
        }
      }
    }