private boolean checkFilteredObject()

in hadoop-ozone/tools/src/main/java/org/apache/hadoop/ozone/debug/ldb/DBScanner.java [406:504]
93 lines of code
25 McCabe index (conditional complexity)

  private boolean checkFilteredObject(Object obj, Class<?> clazz, Map<String, Filter> fieldsSplitMap) {
    for (Map.Entry<String, Filter> field : fieldsSplitMap.entrySet()) {
      try {
        Field valueClassField = getRequiredFieldFromAllFields(clazz, field.getKey());
        Object valueObject = valueClassField.get(obj);
        Filter fieldValue = field.getValue();

        if (valueObject == null) {
          // there is no such field in the record. This filter will be ignored for the current record.
          continue;
        }
        if (fieldValue == null) {
          err().println("Malformed filter. Check input");
          throw new IOException("Invalid filter passed");
        } else if (fieldValue.getNextLevel() == null) {
          // reached the end of fields hierarchy, check if they match the filter
          try {
            switch (fieldValue.getOperator()) {
            case EQUALS:
              if (!String.valueOf(valueObject).equals(fieldValue.getValue())) {
                return false;
              }
              break;
            case GREATER:
              if (Double.parseDouble(String.valueOf(valueObject))
                  < Double.parseDouble(String.valueOf(fieldValue.getValue()))) {
                return false;
              }
              break;
            case LESSER:
              if (Double.parseDouble(String.valueOf(valueObject))
                  > Double.parseDouble(String.valueOf(fieldValue.getValue()))) {
                return false;
              }
              break;
            case REGEX:
              Pattern p = Pattern.compile(String.valueOf(fieldValue.getValue()));
              Matcher m = p.matcher(String.valueOf(valueObject));
              if (!m.find()) {
                return false;
              }
              break;
            default:
              err().println("Only EQUALS/LESSER/GREATER/REGEX operator is supported currently.");
              throw new IOException("Invalid filter passed");
            }
          } catch (NumberFormatException ex) {
            err().println("LESSER or GREATER operation can be performed only on numeric values.");
            throw new IOException("Invalid filter passed");
          }
        } else {
          Map<String, Filter> subfields = fieldValue.getNextLevel();
          if (Collection.class.isAssignableFrom(valueObject.getClass())) {
            if (!checkFilteredObjectCollection((Collection) valueObject, subfields)) {
              return false;
            }
          } else if (Map.class.isAssignableFrom(valueObject.getClass())) {
            Map<?, ?> valueObjectMap = (Map<?, ?>) valueObject;
            boolean flag = false;
            for (Map.Entry<?, ?> ob : valueObjectMap.entrySet()) {
              boolean subflag;
              if (Collection.class.isAssignableFrom(ob.getValue().getClass())) {
                subflag = checkFilteredObjectCollection((Collection)ob.getValue(), subfields);
              } else {
                subflag = checkFilteredObject(ob.getValue(), ob.getValue().getClass(), subfields);
              }
              if (subflag) {
                // atleast one item in the map/list of the record has matched the filter,
                // so record passes the filter.
                flag = true;
                break;
              }
            }
            if (!flag) {
              // none of the items in the map/list passed the filter => record doesn't pass the filter
              return false;
            }
          } else {
            if (!checkFilteredObject(valueObject, valueClassField.getType(), subfields)) {
              return false;
            }
          }
        }
      } catch (NoSuchFieldException ex) {
        err().println("ERROR: no such field: " + field);
        exception = true;
        return false;
      } catch (IllegalAccessException e) {
        err().println("ERROR: Cannot get field \"" + field + "\" from record.");
        exception = true;
        return false;
      } catch (Exception ex) {
        err().println("ERROR: field: " + field + ", ex: " + ex);
        exception = true;
        return false;
      }
    }
    return true;
  }