gerrit.onap Code Review - ccsdk/sli.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                         reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.ccsdk.sli.adaptors.util.expr;
  23
  24 import java.util.Map;
  25
  26 public class ExpressionEvaluator {
  27
  28     public static long evalLong(String expr, Map<String, Object> vars) {
  29         return (long) evalFloat(expr, vars);
  30     }
  31
  32     public static float evalFloat(String expr, Map<String, Object> vars) {
  33         expr = expr.trim();
  34         int sl = expr.length();
  35         if (sl == 0)
  36             throw new IllegalArgumentException("Cannot interpret empty string.");
  37
  38         // Remove parentheses if any
  39         if (expr.charAt(0) == '(' && expr.charAt(sl - 1) == ')')
  40             return evalFloat(expr.substring(1, sl - 1), vars);
  41
  42         // Look for operators in the order of least priority
  43         String[] sss = findOperator(expr, "-", true);
  44         if (sss != null)
  45             return evalFloat(sss[0], vars) - evalFloat(sss[1], vars);
  46
  47         sss = findOperator(expr, "+", true);
  48         if (sss != null)
  49             return evalFloat(sss[0], vars) + evalFloat(sss[1], vars);
  50
  51         sss = findOperator(expr, "/", true);
  52         if (sss != null)
  53             return evalFloat(sss[0], vars) / evalFloat(sss[1], vars);
  54
  55         sss = findOperator(expr, "*", true);
  56         if (sss != null)
  57             return evalFloat(sss[0], vars) * evalFloat(sss[1], vars);
  58
  59         // Check if expr is a number
  60         try {
  61             return Float.valueOf(expr);
  62         } catch (Exception e) {
  63         }
  64
  65         // Must be a variable
  66         Object v = vars.get(expr);
  67         if (v != null) {
  68             if (v instanceof Float)
  69                 return (Float) v;
  70             if (v instanceof Long)
  71                 return (Long) v;
  72             if (v instanceof Integer)
  73                 return (Integer) v;
  74         }
  75         return 0;
  76     }
  77
  78     public static boolean evalBoolean(String expr, Map<String, Object> vars) {
  79         expr = expr.trim();
  80         int sl = expr.length();
  81         if (sl == 0)
  82             throw new IllegalArgumentException("Cannot interpret empty string.");
  83
  84         if (expr.equalsIgnoreCase("true"))
  85             return true;
  86
  87         if (expr.equalsIgnoreCase("false"))
  88             return false;
  89
  90         // Remove parentheses if any
  91         if (expr.charAt(0) == '(' && expr.charAt(sl - 1) == ')')
  92             return evalBoolean(expr.substring(1, sl - 1), vars);
  93
  94         // Look for operators in the order of least priority
  95         String[] sss = findOperator(expr, "or", true);
  96         if (sss != null)
  97             return evalBoolean(sss[0], vars) || evalBoolean(sss[1], vars);
  98
  99         sss = findOperator(expr, "and", true);
 100         if (sss != null)
 101             return evalBoolean(sss[0], vars) && evalBoolean(sss[1], vars);
 102
 103         sss = findOperator(expr, "not", true);
 104         if (sss != null)
 105             return !evalBoolean(sss[1], vars);
 106
 107         sss = findOperator(expr, "!=", false);
 108         if (sss == null)
 109             sss = findOperator(expr, "<>", false);
 110         if (sss != null)
 111             return evalLong(sss[0], vars) != evalLong(sss[1], vars);
 112
 113         sss = findOperator(expr, "==", false);
 114         if (sss == null)
 115             sss = findOperator(expr, "=", false);
 116         if (sss != null)
 117             return evalLong(sss[0], vars) == evalLong(sss[1], vars);
 118
 119         sss = findOperator(expr, ">=", false);
 120         if (sss != null)
 121             return evalLong(sss[0], vars) >= evalLong(sss[1], vars);
 122
 123         sss = findOperator(expr, ">", false);
 124         if (sss != null)
 125             return evalLong(sss[0], vars) > evalLong(sss[1], vars);
 126
 127         sss = findOperator(expr, "<=", false);
 128         if (sss != null)
 129             return evalLong(sss[0], vars) <= evalLong(sss[1], vars);
 130
 131         sss = findOperator(expr, "<", false);
 132         if (sss != null)
 133             return evalLong(sss[0], vars) < evalLong(sss[1], vars);
 134
 135         throw new IllegalArgumentException("Cannot interpret '" + expr + "': Invalid expression.");
 136     }
 137
 138     private static String[] findOperator(String s, String op, boolean delimiterRequired) {
 139         int opl = op.length();
 140         int sl = s.length();
 141         String delimiters = " \0\t\r\n()";
 142         int pcount = 0, qcount = 0;
 143         for (int i = 0; i < sl; i++) {
 144             char c = s.charAt(i);
 145             if (c == '(' && qcount == 0)
 146                 pcount++;
 147             else if (c == ')' && qcount == 0) {
 148                 pcount--;
 149                 if (pcount < 0)
 150                     throw new IllegalArgumentException("Cannot interpret '" + s + "': Parentheses do not match.");
 151             } else if (c == '\'')
 152                 qcount = (qcount + 1) % 2;
 153             else if (i <= sl - opl && pcount == 0 && qcount == 0) {
 154                 String ss = s.substring(i, i + opl);
 155                 if (ss.equalsIgnoreCase(op)) {
 156                     boolean found = true;
 157                     if (delimiterRequired) {
 158                         // Check for delimiter before and after to make sure it is not part of another word
 159                         char chbefore = '\0';
 160                         if (i > 0)
 161                             chbefore = s.charAt(i - 1);
 162                         char chafter = '\0';
 163                         if (i < sl - opl)
 164                             chafter = s.charAt(i + opl);
 165                         found = delimiters.indexOf(chbefore) >= 0 && delimiters.indexOf(chafter) >= 0;
 166                     }
 167                     if (found) {
 168                         // We've found the operator, split the string
 169                         String[] sss = new String[2];
 170                         sss[0] = s.substring(0, i);
 171                         sss[1] = s.substring(i + opl);
 172                         return sss;
 173                     }
 174                 }
 175             }
 176         }
 177         if (pcount > 0)
 178             throw new IllegalArgumentException("Cannot interpret '" + s + "': Parentheses do not match.");
 179         if (qcount > 0)
 180             throw new IllegalArgumentException("Cannot interpret '" + s + "': No closing '.");
 181         return null;
 182     }
 183
 184     private static Object parseObject(String s) {
 185         s = s.trim();
 186         int sl = s.length();
 187         if (sl == 0)
 188             throw new IllegalArgumentException("Cannot interpret empty string.");
 189         if (s.equalsIgnoreCase("null"))
 190             return null;
 191         if (s.charAt(0) == '\'') {
 192             if (sl < 2 || s.charAt(sl - 1) != '\'')
 193                 throw new IllegalArgumentException("Cannot interpret '" + s + "': No closing '.");
 194             return s.substring(1, sl - 1);
 195         }
 196         // Not in quotes - must be a number
 197         try {
 198             return Long.valueOf(s);
 199         } catch (Exception e) {
 200         }
 201         try {
 202             return Double.valueOf(s);
 203         } catch (Exception e) {
 204             throw new IllegalArgumentException("Cannot interpret '" + s + "': Invalid number.");
 205         }
 206     }
 207 }