docs: public boolean enforce(Object... rvals) {
          if (!enabled) {
              return true;
          }
  
          Map<String, AviatorFunction> functions = new HashMap<>();
          for (Map.Entry<String, AviatorFunction> entry : fm.fm.entrySet()) {
              String key = entry.getKey();
              AviatorFunction function = entry.getValue();
  
              functions.put(key, function);
          }
          if (model.model.containsKey("g")) {
              for (Map.Entry<String, Assertion> entry : model.model.get("g").entrySet()) {
                  String key = entry.getKey();
                  Assertion ast = entry.getValue();
  
                  RoleManager rm = ast.rm;
                  functions.put(key, BuiltInFunctions.generateGFunction(key, rm));
              }
          }
          AviatorEvaluatorInstance eval = AviatorEvaluator.newInstance();
          for (AviatorFunction f : functions.values()) {
              eval.addFunction(f);
          }
  
          String expString = model.model.get("m").get("m").value;
          Expression expression = eval.compile(expString);
  
          Effect policyEffects[];
          float matcherResults[];
          int policyLen;
          if ((policyLen = model.model.get("p").get("p").policy.size()) != 0) {
              policyEffects = new Effect[policyLen];
              matcherResults = new float[policyLen];
  
              for (int i = 0; i < model.model.get("p").get("p").policy.size(); i ++) {
                  List<String> pvals = model.model.get("p").get("p").policy.get(i);
  
                  // Util.logPrint("Policy Rule: " + pvals);
  
                  Map<String, Object> parameters = new HashMap<>();
                  for (int j = 0; j < model.model.get("r").get("r").tokens.length; j ++) {
                      String token = model.model.get("r").get("r").tokens[j];
                      parameters.put(token, rvals[j]);
                  }
                  for (int j = 0; j < model.model.get("p").get("p").tokens.length; j ++) {
                      String token = model.model.get("p").get("p").tokens[j];
                      parameters.put(token, pvals.get(j));
                  }
  
                  Object result =  expression.execute(parameters);
                  // Util.logPrint("Result: " + result);
  
                  if (result instanceof Boolean) {
                      if (!((boolean) result)) {
                          policyEffects[i] = Effect.Indeterminate;
                          continue;
                      }
                  } else if (result instanceof Float) {
                      if ((float) result == 0) {
                          policyEffects[i] = Effect.Indeterminate;
                          continue;
                      } else {
                          matcherResults[i] = (float) result;
                      }
                  } else {
                      throw new Error("matcher result should be bool, int or float");
                  }
                  if (parameters.containsKey("p_eft")) {
                      String eft = (String) parameters.get("p_eft");
                      if (eft.equals("allow")) {
                          policyEffects[i] = Effect.Allow;
                      } else if (eft.equals("deny")) {
                          policyEffects[i] = Effect.Deny;
                      } else {
                          policyEffects[i] = Effect.Indeterminate;
                      }
                  } else {
                      policyEffects[i] = Effect.Allow;
                  }
  
                  if (model.model.get("e").get("e").value.equals("priority(p_eft) || deny")) {
                      break;
                  }
              }
          } else {
              policyEffects = new Effect[1];
              matcherResults = new float[1];
  
              Map<String, Object> parameters = new HashMap<>();
              for (int j = 0; j < model.model.get("r").get("r").tokens.length; j ++) {
                  String token = model.model.get("r").get("r").tokens[j];
                  parameters.put(token, rvals[j]);
              }
              for (int j = 0; j < model.model.get("p").get("p").tokens.length; j ++) {
                  String token = model.model.get("p").get("p").tokens[j];
                  parameters.put(token, "");
              }
  
              Object result = expression.execute(parameters);
              // Util.logPrint("Result: " + result);
  
              if ((boolean) result) {
                  policyEffects[0] = Effect.Allow;
              } else {
                  policyEffects[0] = Effect.Indeterminate;
              }
          }
  
          boolean result = eft.mergeEffects(model.model.get("e").get("e").value, policyEffects, matcherResults);
  
          StringBuilder reqStr = new StringBuilder("Request: ");
          for (int i = 0; i < rvals.length; i ++) {
              String rval = rvals[i].toString();
  
              if (i != rvals.length - 1) {
                  reqStr.append(String.format("%s, ", rval));
              } else {
                  reqStr.append(String.format("%s", rval));
              }
          }
          reqStr.append(String.format(" ---> %s", result));
          Util.logPrint(reqStr.toString());
  
          return result;
      }