MtasFunctionParserFunctionBasic.java

  1. package mtas.parser.function.util;

  3. import java.io.IOException;
  4. import java.util.ArrayList;

  6. import mtas.codec.util.CodecUtil;
  7. import mtas.parser.function.ParseException;

  9. /**
  10.  * The Class MtasFunctionParserFunctionBasic.
  11.  */
  12. public class MtasFunctionParserFunctionBasic
  13.     extends MtasFunctionParserFunction {

  15.   /** The first type. */
  16.   private String firstType;

  18.   /** The first id. */
  19.   private int firstId;

  21.   /** The tmp parser longs. */
  22.   private ArrayList<MtasFunctionParserFunction> tmpParserLongs = new ArrayList<>();

  24.   /** The tmp parser doubles. */
  25.   private ArrayList<MtasFunctionParserFunction> tmpParserDoubles = new ArrayList<>();

  27.   /** The tmp constant longs. */
  28.   private ArrayList<Long> tmpConstantLongs = new ArrayList<>();

  30.   /** The tmp constant doubles. */
  31.   private ArrayList<Double> tmpConstantDoubles = new ArrayList<>();

  33.   /** The number. */
  34.   private int number;

  36.   /** The operator list. */
  37.   private String[] operatorList;

  39.   /** The type list. */
  40.   private String[] typeList;

  42.   /** The id list. */
  43.   private int[] idList;

  45.   /** The tmp operator list. */
  46.   private ArrayList<String> tmpOperatorList = new ArrayList<>();

  48.   /** The tmp type list. */
  49.   private ArrayList<String> tmpTypeList = new ArrayList<>();

  51.   /** The tmp id list. */
  52.   private ArrayList<Integer> tmpIdList = new ArrayList<>();

  54.   /** The Constant BASIC_OPERATOR_ADD. */
  55.   public static final String BASIC_OPERATOR_ADD = "add";

  57.   /** The Constant BASIC_OPERATOR_SUBTRACT. */
  58.   public static final String BASIC_OPERATOR_SUBTRACT = "subtract";

  60.   /** The Constant BASIC_OPERATOR_MULTIPLY. */
  61.   public static final String BASIC_OPERATOR_MULTIPLY = "multiply";

  63.   /** The Constant BASIC_OPERATOR_DIVIDE. */
  64.   public static final String BASIC_OPERATOR_DIVIDE = "divide";

  66.   /** The Constant BASIC_OPERATOR_POWER. */
  67.   public static final String BASIC_OPERATOR_POWER = "power";

  69.   /**
  70.    * Instantiates a new mtas function parser function basic.
  71.    *
  72.    * @param item the item
  73.    * @throws ParseException the parse exception
  74.    */
  75.   public MtasFunctionParserFunctionBasic(MtasFunctionParserItem item)
  76.       throws ParseException {
  77.     sumRule = true;
  78.     String type = item.getType();
  79.     MtasFunctionParserFunction parser;
  80.     firstType = type;
  81.     degree = item.getDegree();
  82.     switch (type) {
  83.     case MtasFunctionParserItem.TYPE_N:
  84.       firstId = 0;
  85.       dataType = CodecUtil.DATA_TYPE_LONG;
  86.       needPositions = true;
  87.       break;
  88.     case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  89.       firstId = tmpConstantLongs.size();
  90.       dataType = CodecUtil.DATA_TYPE_LONG;
  91.       tmpConstantLongs.add(item.getValueLong());
  92.       break;
  93.     case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  94.       firstId = tmpConstantDoubles.size();
  95.       dataType = CodecUtil.DATA_TYPE_DOUBLE;
  96.       tmpConstantDoubles.add(item.getValueDouble());
  97.       break;
  98.     case MtasFunctionParserItem.TYPE_ARGUMENT:
  99.       firstType = type;
  100.       firstId = item.getId();
  101.       dataType = CodecUtil.DATA_TYPE_LONG;
  102.       needArgument.add(item.getId());
  103.       break;
  104.     case MtasFunctionParserItem.TYPE_PARSER_LONG:
  105.       parser = item.getParser();
  106.       parser.close();
  107.       if (parser.getType().equals(CodecUtil.DATA_TYPE_LONG)) {
  108.         firstId = tmpParserLongs.size();
  109.         tmpParserLongs.add(parser);
  110.         sumRule = parser.sumRule();
  111.         dataType = CodecUtil.DATA_TYPE_LONG;
  112.         needPositions = needPositions ? needPositions : parser.needPositions();
  113.         needArgument.addAll(parser.needArgument);
  114.       } else {
  115.         throw new ParseException("incorrect dataType");
  116.       }
  117.       break;
  118.     case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  119.       parser = item.getParser();
  120.       parser.close();
  121.       if (parser.getType().equals(CodecUtil.DATA_TYPE_DOUBLE)) {
  122.         firstId = tmpParserDoubles.size();
  123.         tmpParserDoubles.add(parser);
  124.         sumRule = parser.sumRule();
  125.         dataType = CodecUtil.DATA_TYPE_DOUBLE;
  126.         needPositions = needPositions ? needPositions : parser.needPositions();
  127.         needArgument.addAll(parser.needArgument);
  128.       } else {
  129.         throw new ParseException("incorrect dataType");
  130.       }
  131.       break;
  132.     default:
  133.       throw new ParseException("unknown type");
  134.     }
  135.   }

  137.   /*
  138.    * (non-Javadoc)
  139.    * 
  140.    * @see mtas.parser.function.util.MtasFunctionParserFunction#close()
  141.    */
  142.   @Override
  143.   public void close() throws ParseException {
  144.     if (!defined()) {
  145.       super.close();
  146.       if (!tmpParserLongs.isEmpty()) {
  147.         parserLongs = new MtasFunctionParserFunction[tmpParserLongs.size()];
  148.         parserLongs = tmpParserLongs.toArray(parserLongs);
  149.       }
  150.       if (!tmpParserDoubles.isEmpty()) {
  151.         parserDoubles = new MtasFunctionParserFunction[tmpParserDoubles.size()];
  152.         parserDoubles = tmpParserDoubles.toArray(parserDoubles);
  153.       }
  154.       if (!tmpConstantLongs.isEmpty()) {
  155.         constantLongs = new long[tmpConstantLongs.size()];
  156.         for (int i = 0; i < tmpConstantLongs.size(); i++) {
  157.           constantLongs[i] = tmpConstantLongs.get(i);
  158.         }
  159.       }
  160.       if (!tmpConstantDoubles.isEmpty()) {
  161.         constantDoubles = new Double[tmpConstantDoubles.size()];
  162.         for (int i = 0; i < tmpConstantDoubles.size(); i++) {
  163.           constantDoubles[i] = tmpConstantDoubles.get(i);
  164.         }
  165.       }
  166.       if (firstType == null) {
  167.         throw new ParseException("incorrect definition: no firstType");
  168.       }
  169.       if (!tmpOperatorList.isEmpty()) {
  170.         number = tmpOperatorList.size();
  171.         if ((tmpTypeList.size() != number) || (tmpIdList.size() != number)) {
  172.           throw new ParseException("incorrect definition additional items");
  173.         } else {
  174.           operatorList = new String[number];
  175.           operatorList = tmpOperatorList.toArray(operatorList);
  176.           typeList = new String[number];
  177.           typeList = tmpTypeList.toArray(typeList);
  178.           idList = new int[number];
  179.           for (int i = 0; i < number; i++) {
  180.             idList[i] = tmpIdList.get(i).intValue();
  181.           }
  182.         }
  183.       } else {
  184.         number = 0;
  185.         operatorList = null;
  186.         typeList = null;
  187.         idList = null;
  188.       }
  189.     }
  190.   }

  192.   /**
  193.    * Adds the.
  194.    *
  195.    * @param item the item
  196.    * @throws ParseException the parse exception
  197.    */
  198.   public void add(MtasFunctionParserItem item) throws ParseException {
  199.     basic(BASIC_OPERATOR_ADD, item);
  200.   }

  202.   /**
  203.    * Subtract.
  204.    *
  205.    * @param item the item
  206.    * @throws ParseException the parse exception
  207.    */
  208.   public void subtract(MtasFunctionParserItem item) throws ParseException {
  209.     basic(BASIC_OPERATOR_SUBTRACT, item);
  210.   }

  212.   /**
  213.    * Multiply.
  214.    *
  215.    * @param item the item
  216.    * @throws ParseException the parse exception
  217.    */
  218.   public void multiply(MtasFunctionParserItem item) throws ParseException {
  219.     basic(BASIC_OPERATOR_MULTIPLY, item);
  220.   }

  222.   /**
  223.    * Divide.
  224.    *
  225.    * @param item the item
  226.    * @throws ParseException the parse exception
  227.    */
  228.   public void divide(MtasFunctionParserItem item) throws ParseException {
  229.     basic(BASIC_OPERATOR_DIVIDE, item);
  230.   }

  232.   /**
  233.    * Power.
  234.    *
  235.    * @param item the item
  236.    * @throws ParseException the parse exception
  237.    */
  238.   public void power(MtasFunctionParserItem item) throws ParseException {
  239.     basic(BASIC_OPERATOR_POWER, item);
  240.   }

  242.   /**
  243.    * Basic.
  244.    *
  245.    * @param operator the operator
  246.    * @param item the item
  247.    * @throws ParseException the parse exception
  248.    */
  249.   private void basic(String operator, MtasFunctionParserItem item)
  250.       throws ParseException {
  251.     if (!defined()) {
  252.       String type = item.getType();
  253.       MtasFunctionParserFunction parser;
  254.       tmpOperatorList.add(operator);
  255.       if (operator.equals(BASIC_OPERATOR_DIVIDE)) {
  256.         dataType = CodecUtil.DATA_TYPE_DOUBLE;
  257.       }
  258.       switch (type) {
  259.       case MtasFunctionParserItem.TYPE_N:
  260.         tmpTypeList.add(type);
  261.         tmpIdList.add(0);
  262.         needPositions = true;
  263.         if (sumRule && degree != null) {
  264.           if (operator.equals(BASIC_OPERATOR_ADD)
  265.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  266.             if (degree < 0) {
  267.               sumRule = false;
  268.               degree = null;
  269.             } else if (degree > 0) {
  270.               sumRule = false;
  271.             }
  272.           } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
  273.             sumRule = false;
  274.             degree = null;
  275.           }
  276.         }
  277.         break;
  278.       case MtasFunctionParserItem.TYPE_ARGUMENT:
  279.         tmpTypeList.add(type);
  280.         tmpIdList.add(item.getId());
  281.         needArgument.add(item.getId());
  282.         if (sumRule && degree != null) {
  283.           if (operator.equals(BASIC_OPERATOR_ADD)
  284.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  285.             if (degree != 1) {
  286.               sumRule = false;
  287.             }
  288.             if (degree >= 0) {
  289.               degree = Math.max(degree, 1);
  290.             } else {
  291.               degree = null;
  292.             }
  293.           } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
  294.             if (degree != 0) {
  295.               sumRule = false;
  296.             }
  297.             degree += 1;
  298.           } else if (operator.equals(BASIC_OPERATOR_DIVIDE)) {
  299.             sumRule = false;
  300.             degree -= 1;
  301.           } else if (operator.equals(BASIC_OPERATOR_POWER)) {
  302.             sumRule = false;
  303.             degree = null;
  304.           }
  305.         }
  306.         break;
  307.       case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  308.         tmpTypeList.add(type);
  309.         tmpIdList.add(tmpConstantLongs.size());
  310.         tmpConstantLongs.add(item.getValueLong());
  311.         if (sumRule && degree != null) {
  312.           if (operator.equals(BASIC_OPERATOR_ADD)
  313.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  314.             if (degree < 0) {
  315.               sumRule = false;
  316.               degree = null;
  317.             } else if (degree > 0) {
  318.               sumRule = false;
  319.             }
  320.           } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
  321.             sumRule = false;
  322.             degree = null;
  323.           }
  324.         }
  325.         break;
  326.       case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  327.         tmpTypeList.add(type);
  328.         tmpIdList.add(tmpConstantDoubles.size());
  329.         dataType = CodecUtil.DATA_TYPE_DOUBLE;
  330.         tmpConstantDoubles.add(item.getValueDouble());
  331.         if (sumRule && degree != null) {
  332.           if (operator.equals(BASIC_OPERATOR_ADD)
  333.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  334.             if (degree < 0) {
  335.               sumRule = false;
  336.               degree = null;
  337.             } else if (degree > 0) {
  338.               sumRule = false;
  339.             }
  340.           } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
  341.             sumRule = false;
  342.             degree = null;
  343.           }
  344.         }
  345.         break;
  346.       case MtasFunctionParserItem.TYPE_PARSER_LONG:
  347.         tmpTypeList.add(type);
  348.         tmpIdList.add(tmpParserLongs.size());
  349.         parser = item.getParser();
  350.         parser.close();
  351.         tmpParserLongs.add(parser);
  352.         sumRule = sumRule ? parser.sumRule() : false;
  353.         needPositions = needPositions ? needPositions : parser.needPositions();
  354.         needArgument.addAll(parser.needArgument);
  355.         if (sumRule && degree != null) {
  356.           if (operator.equals(BASIC_OPERATOR_ADD)
  357.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  358.             if (!parser.degree.equals(degree)) {
  359.               sumRule = false;
  360.               if (degree < 0) {
  361.                 degree = null;
  362.               } else {
  363.                 degree = Math.max(degree, parser.degree);
  364.               }
  365.             }
  366.           } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
  367.             if (degree != 0 || parser.degree != 0) {
  368.               sumRule = false;
  369.             }
  370.             degree += parser.degree;
  371.           } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
  372.             sumRule = false;
  373.             degree = null;
  374.           }
  375.         }
  376.         break;
  377.       case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  378.         tmpTypeList.add(type);
  379.         tmpIdList.add(tmpParserDoubles.size());
  380.         dataType = CodecUtil.DATA_TYPE_DOUBLE;
  381.         parser = item.getParser();
  382.         parser.close();
  383.         tmpParserDoubles.add(parser);
  384.         sumRule = sumRule ? parser.sumRule() : false;
  385.         needPositions = needPositions ? needPositions : parser.needPositions();
  386.         needArgument.addAll(parser.needArgument);
  387.         if (sumRule && degree != null) {
  388.           if (operator.equals(BASIC_OPERATOR_ADD)
  389.               || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  390.             if (!parser.degree.equals(degree)) {
  391.               sumRule = false;
  392.               if (degree < 0) {
  393.                 degree = null;
  394.               } else {
  395.                 degree = Math.max(degree, parser.degree);
  396.               }
  397.             }
  398.           } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
  399.             if (degree != 0 || parser.degree != 0) {
  400.               sumRule = false;
  401.             }
  402.             degree += parser.degree;
  403.           } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
  404.             sumRule = false;
  405.             degree = null;
  406.           }
  407.         }
  408.         break;
  409.       default:
  410.         throw new ParseException("incorrect type");
  411.       }
  412.     } else {
  413.       throw new ParseException("already defined");
  414.     }
  415.   }

  417.   /*
  418.    * (non-Javadoc)
  419.    * 
  420.    * @see
  421.    * mtas.parser.function.util.MtasFunctionParserFunction#getValueDouble(long[],
  422.    * long)
  423.    */
  424.   @Override
  425.   public double getValueDouble(long[] args, long n) throws IOException {
  426.     double sum;
  427.     switch (firstType) {
  428.     case MtasFunctionParserItem.TYPE_ARGUMENT:
  429.       sum = args[firstId];
  430.       break;
  431.     case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  432.       sum = parserDoubles[firstId].getValueDouble(args, n);
  433.       break;
  434.     case MtasFunctionParserItem.TYPE_PARSER_LONG:
  435.       sum = parserLongs[firstId].getValueLong(args, n);
  436.       break;
  437.     case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  438.       sum = constantDoubles[firstId];
  439.       break;
  440.     case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  441.       sum = constantLongs[firstId];
  442.       break;
  443.     case MtasFunctionParserItem.TYPE_N:
  444.       sum = n;
  445.       break;
  446.     default:
  447.       throw new IOException("no first value");
  448.     }
  449.     for (int i = 0; i < number; i++) {
  450.       switch (operatorList[i]) {
  451.       case BASIC_OPERATOR_ADD:
  452.         switch (typeList[i]) {
  453.         case MtasFunctionParserItem.TYPE_ARGUMENT:
  454.           sum += args[idList[i]];
  455.           break;
  456.         case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  457.           sum += parserDoubles[idList[i]].getValueDouble(args, n);
  458.           break;
  459.         case MtasFunctionParserItem.TYPE_PARSER_LONG:
  460.           sum += parserLongs[idList[i]].getValueLong(args, n);
  461.           break;
  462.         case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  463.           sum += constantDoubles[idList[i]];
  464.           break;
  465.         case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  466.           sum += constantLongs[idList[i]];
  467.           break;
  468.         case MtasFunctionParserItem.TYPE_N:
  469.           sum += n;
  470.           break;
  471.         default:
  472.           throw new IOException("unknown type");
  473.         }
  474.         break;
  475.       case BASIC_OPERATOR_SUBTRACT:
  476.         switch (typeList[i]) {
  477.         case MtasFunctionParserItem.TYPE_ARGUMENT:
  478.           sum -= args[idList[i]];
  479.           break;
  480.         case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  481.           sum -= parserDoubles[idList[i]].getValueDouble(args, n);
  482.           break;
  483.         case MtasFunctionParserItem.TYPE_PARSER_LONG:
  484.           sum -= parserLongs[idList[i]].getValueLong(args, n);
  485.           break;
  486.         case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  487.           sum -= constantDoubles[idList[i]];
  488.           break;
  489.         case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  490.           sum -= constantLongs[idList[i]];
  491.           break;
  492.         case MtasFunctionParserItem.TYPE_N:
  493.           sum -= n;
  494.           break;
  495.         default:
  496.           throw new IOException("unknown type");
  497.         }
  498.         break;
  499.       case BASIC_OPERATOR_MULTIPLY:
  500.         switch (typeList[i]) {
  501.         case MtasFunctionParserItem.TYPE_ARGUMENT:
  502.           sum *= args[idList[i]];
  503.           break;
  504.         case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  505.           sum *= parserDoubles[idList[i]].getValueDouble(args, n);
  506.           break;
  507.         case MtasFunctionParserItem.TYPE_PARSER_LONG:
  508.           sum *= parserLongs[idList[i]].getValueLong(args, n);
  509.           break;
  510.         case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  511.           sum *= constantDoubles[idList[i]];
  512.           break;
  513.         case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  514.           sum *= constantLongs[idList[i]];
  515.           break;
  516.         case MtasFunctionParserItem.TYPE_N:
  517.           sum *= n;
  518.           break;
  519.         default:
  520.           throw new IOException("unknown type");
  521.         }
  522.         break;
  523.       case BASIC_OPERATOR_DIVIDE:
  524.         double v;
  525.         switch (typeList[i]) {
  526.         case MtasFunctionParserItem.TYPE_ARGUMENT:
  527.           v = args[idList[i]];
  528.           break;
  529.         case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  530.           v = parserDoubles[idList[i]].getValueDouble(args, n);
  531.           break;
  532.         case MtasFunctionParserItem.TYPE_PARSER_LONG:
  533.           v = parserLongs[idList[i]].getValueLong(args, n);
  534.           break;
  535.         case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  536.           v = constantDoubles[idList[i]];
  537.           break;
  538.         case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  539.           v = constantLongs[idList[i]];
  540.           break;
  541.         case MtasFunctionParserItem.TYPE_N:
  542.           v = n;
  543.           break;
  544.         default:
  545.           throw new IOException("unknown type");
  546.         }
  547.         if (v != 0) {
  548.           sum /= v;
  549.         } else {
  550.           throw new IOException("division by zero");
  551.         }
  552.         break;
  553.       case BASIC_OPERATOR_POWER:
  554.         switch (typeList[i]) {
  555.         case MtasFunctionParserItem.TYPE_ARGUMENT:
  556.           sum = Math.pow(sum, args[idList[i]]);
  557.           break;
  558.         case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  559.           sum = Math.pow(sum, parserDoubles[idList[i]].getValueDouble(args, n));
  560.           break;
  561.         case MtasFunctionParserItem.TYPE_PARSER_LONG:
  562.           sum = Math.pow(sum, parserLongs[idList[i]].getValueLong(args, n));
  563.           break;
  564.         case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  565.           sum = Math.pow(sum, constantDoubles[idList[i]]);
  566.           break;
  567.         case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  568.           sum = Math.pow(sum, constantLongs[idList[i]]);
  569.           break;
  570.         case MtasFunctionParserItem.TYPE_N:
  571.           sum = Math.pow(sum, n);
  572.           break;
  573.         default:
  574.           throw new IOException("unknown type");
  575.         }
  576.         break;
  577.       default:
  578.         throw new IOException("unknown operator");
  579.       }
  580.     }
  581.     return sum;
  582.   }

  584.   /*
  585.    * (non-Javadoc)
  586.    * 
  587.    * @see
  588.    * mtas.parser.function.util.MtasFunctionParserFunction#getValueLong(long[],
  589.    * long)
  590.    */
  591.   @Override
  592.   public long getValueLong(long[] args, long n) throws IOException {
  593.     try {
  594.       long sum;
  595.       switch (firstType) {
  596.       case MtasFunctionParserItem.TYPE_ARGUMENT:
  597.         sum = args[firstId];
  598.         break;
  599.       case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  600.         sum = (long) parserDoubles[firstId].getValueDouble(args, n);
  601.         break;
  602.       case MtasFunctionParserItem.TYPE_PARSER_LONG:
  603.         sum = parserLongs[firstId].getValueLong(args, n);
  604.         break;
  605.       case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  606.         sum = constantDoubles[firstId].longValue();
  607.         break;
  608.       case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  609.         sum = constantLongs[firstId];
  610.         break;
  611.       case MtasFunctionParserItem.TYPE_N:
  612.         sum = n;
  613.         break;
  614.       default:
  615.         throw new IOException("no first value");
  616.       }
  617.       for (int i = 0; i < number; i++) {
  618.         switch (operatorList[i]) {
  619.         case BASIC_OPERATOR_ADD:
  620.           switch (typeList[i]) {
  621.           case MtasFunctionParserItem.TYPE_ARGUMENT:
  622.             sum += args[idList[i]];
  623.             break;
  624.           case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  625.             sum += (long) parserDoubles[idList[i]].getValueDouble(args, n);
  626.             break;
  627.           case MtasFunctionParserItem.TYPE_PARSER_LONG:
  628.             sum += parserLongs[idList[i]].getValueLong(args, n);
  629.             break;
  630.           case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  631.             sum += constantDoubles[idList[i]].longValue();
  632.             break;
  633.           case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  634.             sum += constantLongs[idList[i]];
  635.             break;
  636.           case MtasFunctionParserItem.TYPE_N:
  637.             sum += n;
  638.             break;
  639.           default:
  640.             throw new IOException("unknown type");
  641.           }
  642.           break;
  643.         case BASIC_OPERATOR_SUBTRACT:
  644.           switch (typeList[i]) {
  645.           case MtasFunctionParserItem.TYPE_ARGUMENT:
  646.             sum -= args[idList[i]];
  647.             break;
  648.           case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  649.             sum -= (long) parserDoubles[idList[i]].getValueDouble(args, n);
  650.             break;
  651.           case MtasFunctionParserItem.TYPE_PARSER_LONG:
  652.             sum -= parserLongs[idList[i]].getValueLong(args, n);
  653.             break;
  654.           case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  655.             sum -= constantDoubles[idList[i]].longValue();
  656.             break;
  657.           case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  658.             sum -= constantLongs[idList[i]];
  659.             break;
  660.           case MtasFunctionParserItem.TYPE_N:
  661.             sum -= n;
  662.             break;
  663.           default:
  664.             throw new IOException("unknown type");
  665.           }
  666.           break;
  667.         case BASIC_OPERATOR_MULTIPLY:
  668.           switch (typeList[i]) {
  669.           case MtasFunctionParserItem.TYPE_ARGUMENT:
  670.             sum *= args[idList[i]];
  671.             break;
  672.           case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  673.             sum *= (long) parserDoubles[idList[i]].getValueDouble(args, n);
  674.             break;
  675.           case MtasFunctionParserItem.TYPE_PARSER_LONG:
  676.             sum *= parserLongs[idList[i]].getValueLong(args, n);
  677.             break;
  678.           case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  679.             sum *= constantDoubles[idList[i]].longValue();
  680.             break;
  681.           case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  682.             sum *= constantLongs[idList[i]];
  683.             break;
  684.           case MtasFunctionParserItem.TYPE_N:
  685.             sum *= n;
  686.             break;
  687.           default:
  688.             throw new IOException("unknown type");
  689.           }
  690.           break;
  691.         case BASIC_OPERATOR_DIVIDE:
  692.           long v;
  693.           switch (typeList[i]) {
  694.           case MtasFunctionParserItem.TYPE_ARGUMENT:
  695.             v = args[idList[i]];
  696.             break;
  697.           case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  698.             v = (long) parserDoubles[idList[i]].getValueDouble(args, n);
  699.             break;
  700.           case MtasFunctionParserItem.TYPE_PARSER_LONG:
  701.             v = parserLongs[idList[i]].getValueLong(args, n);
  702.             break;
  703.           case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  704.             v = constantDoubles[idList[i]].longValue();
  705.             break;
  706.           case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  707.             v = constantLongs[idList[i]];
  708.             break;
  709.           case MtasFunctionParserItem.TYPE_N:
  710.             v = n;
  711.             break;
  712.           default:
  713.             throw new IOException("unknown type");
  714.           }
  715.           if (v != 0) {
  716.             sum /= v;
  717.           } else {
  718.             throw new IOException("division by zero");
  719.           }
  720.           break;
  721.         case BASIC_OPERATOR_POWER:
  722.           switch (typeList[i]) {
  723.           case MtasFunctionParserItem.TYPE_ARGUMENT:
  724.             sum = sum ^ args[idList[i]];
  725.             break;
  726.           case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
  727.             sum = sum ^ (long) parserDoubles[idList[i]].getValueDouble(args, n);
  728.             break;
  729.           case MtasFunctionParserItem.TYPE_PARSER_LONG:
  730.             sum = sum ^ parserLongs[idList[i]].getValueLong(args, n);
  731.             break;
  732.           case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
  733.             sum = sum ^ constantDoubles[idList[i]].longValue();
  734.             break;
  735.           case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
  736.             sum = sum ^ constantLongs[idList[i]];
  737.             break;
  738.           case MtasFunctionParserItem.TYPE_N:
  739.             sum = sum ^ n;
  740.             break;
  741.           default:
  742.             throw new IOException("unknown type");
  743.           }
  744.           break;
  745.         default:
  746.           throw new IOException("unknown operator");
  747.         }
  748.       }
  749.       return sum;
  750.     } catch (java.lang.ArithmeticException e) {
  751.       throw new IOException(e);
  752.     }
  753.   }

  755.   /*
  756.    * (non-Javadoc)
  757.    * 
  758.    * @see java.lang.Object#toString()
  759.    */
  760.   @Override
  761.   public String toString() {
  762.     if (firstType != null) {
  763.       StringBuilder text = new StringBuilder(toString(firstType, firstId));
  764.       for (int i = 0; i < tmpOperatorList.size(); i++) {
  765.         String operator = tmpOperatorList.get(i);
  766.         if (operator.equals(BASIC_OPERATOR_ADD)) {
  767.           text.append(" + ");
  768.         } else if (operator.equals(BASIC_OPERATOR_SUBTRACT)) {
  769.           text.append(" - ");
  770.         } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
  771.           text.append(" * ");
  772.         } else if (operator.equals(BASIC_OPERATOR_DIVIDE)) {
  773.           text.append(" / ");
  774.         } else if (operator.equals(BASIC_OPERATOR_POWER)) {
  775.           text.append(" ^ ");
  776.         } else {
  777.           text.append(" ? ");
  778.         }
  779.         text.append(toString(tmpTypeList.get(i), tmpIdList.get(i)));
  780.       }
  781.       return text.toString();
  782.     } else {
  783.       return "?";
  784.     }
  785.   }

  787.   /**
  788.    * To string.
  789.    *
  790.    * @param type the type
  791.    * @param id the id
  792.    * @return the string
  793.    */
  794.   private String toString(String type, int id) {
  795.     if (type.equals(MtasFunctionParserItem.TYPE_CONSTANT_LONG)) {
  796.       return tmpConstantLongs.get(id).toString();
  797.     } else if (type.equals(MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE)) {
  798.       return tmpConstantDoubles.get(id).toString();
  799.     } else if (type.equals(MtasFunctionParserItem.TYPE_PARSER_LONG)) {
  800.       return "(" + tmpParserLongs.get(id).toString() + ")";
  801.     } else if (type.equals(MtasFunctionParserItem.TYPE_PARSER_DOUBLE)) {
  802.       return "(" + tmpParserDoubles.get(id).toString() + ")";
  803.     } else if (type.equals(MtasFunctionParserItem.TYPE_ARGUMENT)) {
  804.       return "$q" + id;
  805.     } else if (type.equals(MtasFunctionParserItem.TYPE_N)) {
  806.       return "$n";
  807.     } else {
  808.       return "..";
  809.     }
  810.   }

  812. }
Created with JaCoCo 0.7.9.201702052155