content: package com.taobao.qa.ruleengine.rules.primitives;
  
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  public class ConstraintsClassMethods {
  
      /**
       * 输入值最小值判断，对应自定义函数"最小值约束"，例如 !最小值约束(ratio,0) or !最大值约束(ratio,10)
       * @param input 被判断的值
       * @param min 允许的最小值
       * @return 如果input大于等于min，则返回true；否则返回false
       */
      public static boolean min(String input, Double min) {
          return Double.parseDouble(input) >= min;
      }
  
      /**
       * 输入值最大值判断，对应自定义函数"最大值约束"，例如 !最小值约束(ratio,0) or !最大值约束(ratio,10)
       * @param input 被判断的值
       * @param max 允许的最大值
       * @return 如果input小于等于max，则返回true；否则返回false
       */
      public static boolean max(String input, Double max) {
          return Double.parseDouble(input) <= max;
      }
  
      /**
       * 输入值是否在指定范围内，对应自定义函数"取值范围约束"，例如 !取值范围约束("15",0,20)
       * @param input 被判断的输入值
       * @param min 允许的最大值
       * @param max 允许的最小值
       * @return 如果input在[min,max]范围内，则返回true，否则返回false
       */
      public static boolean inRange(String input, Double min, Double max) {
          Double inputDouble = Double.parseDouble(input);
          return inputDouble >= min && inputDouble <= max;
      }
  
      /**
       * 判断输入值是否在指定的取值集合内，对应自定义函数"取值集合约束"，例如 !取值范围约束(val,"0","1"，"2")
       * @param input 被判断值
       * @param set 取值集合
       * @return 如果input取值在指定set集合内，则返回true，否则返回false
       */
      public static boolean inSet(String input, String...set) {
          for(String item:set) {
              if(input.equals(item.trim())) {
                  return true;
              }
          }
          return false;
      }
  
      /**
       * 判断输入值是否是整数，对应自定义函数"isInterger"。例如 if( isInterger("123") or isFloat("123"))
       * @param input 被判断值
       * @return input是整数，则返回true，否则返回false
       */
      public static boolean isInteger(String input) {
          try {
              Long.parseLong(input);
          } catch (NumberFormatException e) {
              return false;
          }
          return true;
      }
  
      /**
       * 判断输入值是否是浮点数,对应自定义函数"isFloat"。例如 if( isInterger("123") or isFloat("123"))
       * @param input 被判断值
       * @return input是浮点数，则返回true，否则返回false
       */
      public static boolean isFloat(String input) {
          if(!input.contains(".")) {
              return false;
          }
  
          try {
              Double.parseDouble(input);
          } catch(NumberFormatException e) {
              return false;
          }
          return true;
      }
  
      /**
       * 判断输入值是否是数字，对应自定义函数"isNumberic"。例如 !isNumberic("te1249813")
       * @param input
       * @return
       */
      public static boolean isNumeric(String input) {
          return isInteger(input) || isFloat(input);
      }
  
      /**
       * 判断输入值是非负整数，对应自定义函数"为非负整数"，例如 为非负整数("-123")
       * @param input 被判断值
       * @return input是非负整数，返回true，否则返回false
       */
      public static boolean isNonNegativeInteger(String input) {
          return isInteger(input) && min(input,0d);
      }
  
      /**
       * 判断输入值是否符合给定的正则表达式，对应自定义函数"matchPattern"，例如 if(!matchPattern(real,"\\d+.\\d+%"))
       * @param input 被判断的值
       * @param regexpr 正则表达式
       * @return input符合正则regexpr，则返回true，否则返回false
       */
      public static boolean matchPattern(String input, String regexpr) {
          Pattern pattern = Pattern.compile(regexpr);
          Matcher m = pattern.matcher(input);
          return m.matches();
      }
  
      /**
       * 除法，相当于java中的算数运算符/,对应自定义函数"整除",例如  pageno = 整除(offset,cnt) + 1
       * @param divdend 被除数
       * @param divs 除数
       * @return 整数类型结果值
       */
      public static Integer diver(String divdend,String divs){
          int val = Integer.parseInt(divdend)/Integer.parseInt(divs);
          return val;
      }
  
      /**
       * 乘法，相当于java中的标准算数运算符*，对应自定义函数"相乘"，例如 price = 相乘（"1"，"5"）
       * @param fir 乘数1
       * @param sec 乘数2
       * @return fir和sec的乘积，=fir*sec
       */
      public static String multiply(String fir,String sec){
          Double val =  Double.parseDouble(fir) * Double.parseDouble(sec);
          int tmp = val.intValue();
          return String.valueOf(tmp);
      }
  
      /**
       * 判断两个字符数组是否相等，对应自定义函数"字符串无序是否相等比较"，例如 if(字符串无序是否相等比较(exptArr,titleArr) == false)
       * @param arr1
       * @param arr2
       * @return
       */
      public static boolean strArrEqualNoOrder(String[] arr1,String[] arr2){
          if(arr1.length != arr2.length){ return false; }
          int j;
          for(int i=0;i<arr1.length;i++) {
              String val = arr1[i];
  
              for (j = 0; j < arr2.length; j++) {
                  if (arr2[j].compareTo(arr1[i]) == 0) {
                      break;
                  }
              }
              if (j >= arr2.length) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * 在第一个字符数组中存在在第二个字符数组中不存在字符串，对应自定义函数"第一个字符数组中存在第二个字符数组中不存在的字段"，例如 lessreturn = 第一个字符数组中存在第二个字符数组中不存在的字段(exptArr,titleArr);
       * @param arr1 字符数组1
       * @param arr2 字符数组2
       * @return 在arr1中存在但在arr2中不存在的字符用,拼接组成的全新字符串
       */
      public static String strArrsubtract(String[] arr1,String[] arr2){
          String str = "";
          for(int i=0;i<arr1.length;i++){
              String val = arr1[i];
              boolean flag = false;
              for(int j=0;j<arr2.length;j++){
                 if(arr2[j].compareTo(val) == 0){
                     flag = true;
                     break;
                 }
              }
              if(flag == false){
                  if(str.isEmpty()){
                      str = val;
                  }else {
                      str = str + "," + val;
                  }
              }
          }
          return str;
      }
  
  
      /**
       * 判断字符串是否为空
       * @param str
       * @return
       */
      public static boolean isEmpty(String str){
          return str.isEmpty();
      }
      public static void main(String[] args) {
          System.out.println("Enter "+ ConstraintsClassMethods.class.getName());
          String input = "9999.00";
          String pattern = "\\d+\\.\\d\\d";
  
          System.out.format("matchPattern: %s\n",matchPattern(input,pattern));
      }
  }
  
  