How to use io.yawp.repository.query.condition

@Override
public BaseCondition not() {
  BaseCondition[] reversedConditions = new BaseCondition[conditions.length];
  for (int i = 0; i < conditions.length; i++) {
    reversedConditions[i] = conditions[i].not();
  }
  return new JoinedCondition(logicalOperator.not(), reversedConditions);
}

public QueryBuilder<T> where(BaseCondition c) {
  if (condition == null) {
    condition = c;
  } else {
    condition = Condition.and(condition, c);
  }
  condition.init(r, clazz);
  return this;
}

@Override
public BaseCondition not() {
  return new SimpleCondition(field, whereOperator.reverse(), whereValue);
}

@Override
public boolean evaluate(Object object) {
  try {
    Object objectValue = new ConditionReference(field, clazz, object).getValue();
    return whereOperator.evaluate(objectValue, whereValue);
  } catch (ConditionForChildException e) {
    return true;
  }
}

private void verifyIfConditionIsForChild() throws ConditionForChildException {
  if (clazz != null && isObjectAcenstor() && isReferenceForChild()) {
    throw new ConditionForChildException();
  }
}

public static BaseCondition c(String field, String operator, Object comparison) {
  return c(field, WhereOperator.toOperator(operator), comparison);
}

private boolean evaluateAnd(Object object) {
  for (BaseCondition condition : conditions) {
    if (!condition.evaluate(object)) {
      return false;
    }
  }
  return true;
}

public void or(BaseCondition condition) {
  if (this.condition != null) {
    this.condition = Condition.or(this.condition, condition);
    return;
  }
  this.condition = condition;
}

private boolean isQueryById() {
  if (condition == null || !(condition instanceof SimpleCondition)) {
    return false;
  }
  SimpleCondition c = (SimpleCondition) condition;
  return c.isIdField() && c.isEqualOperator();
}

private void initConditions() {
  if (condition == null) {
    return;
  }
  condition.init(r, endpointClazz);
}

@Override
public boolean evaluate(Object object) {
  if (logicalOperator == LogicalOperator.AND) {
    return evaluateAnd(object);
  }
  return evaluateOr(object);
}

private static boolean listContainsLessThanOrEqual(List list, Object whereValue) {
  for (Object value : list) {
    if (compareObjects(value, whereValue) <= 0) {
      return true;
    }
  }
  return false;
}

public static BaseCondition and(BaseCondition... conditions) {
  if (conditions.length == 1) {
    return conditions[0];
  }
  return new JoinedCondition(LogicalOperator.AND, conditions);
}

public SimpleCondition(String field, WhereOperator whereOperator, Object value) {
  this.field = field;
  this.whereOperator = whereOperator;
  this.whereValue = value;
  if (whereOperator == WhereOperator.IN) {
    assertIsList(value);
  }
}

@Override
public boolean hasPostFilter() {
  return !hasPreFilter();
}

  @Override
  public boolean evaluate(Object object) {
    return condition.evaluate(object);
  }
}

private static boolean listContainsGreaterThanOrEqual(List list, Object whereValue) {
  for (Object value : list) {
    if (compareObjects(value, whereValue) >= 0) {
      return true;
    }
  }
  return false;
}

public static BaseCondition or(BaseCondition... conditions) {
  if (conditions.length == 1) {
    return conditions[0];
  }
  return new JoinedCondition(LogicalOperator.OR, conditions);
}

private static boolean listContainsGreaterThan(List list, Object whereValue) {
  for (Object value : list) {
    if (compareObjects(value, whereValue) > 0) {
      return true;
    }
  }
  return false;
}

private static boolean listContainsLessThan(List list, Object whereValue) {
  for (Object value : list) {
    if (compareObjects(value, whereValue) < 0) {
      return true;
    }
  }
  return false;
}