How to use

contains

method

in

leap.lang.Arrays2

@Override
public boolean hasRole(String role) {
  return Arrays2.contains(roles, role);
}

public static boolean contains(Object array, Object item) {
  if(null == array || null == item){
    return false;
  }
  
  if(array instanceof Object[]) {
    return Arrays2.contains((Object[])array,item);
  }
  
  if(array.getClass().isArray()) {
    return Arrays2.containsInObjectArray(array, item);
  }
  
  throw new ElException("Invalid array object '" + array + "'");
}

  @Override
  public boolean hasAllPermission(String... permissions) {
    if(permissions == null){
      return true;
    }
    for(String permission:permissions){
      if(!Arrays2.contains(this.permissions, permission)){
        return false;
      }
    }
    return true;
  }
}

@Override
public boolean contains(Object element) {
  return Arrays2.contains(values, element);
}

@Override
public boolean hasPermission(String permission) {
  return Arrays2.contains(permissions, permission);
}

  /**
   * Checks if the expected permission are "implied by" the actual permissions.
   */
  default boolean checkPermissionImplies(String expected, String[] actual) {
    if(null == expected) {
      return true;
    }
    if(null == actual) {
      return false;
    }
    return Arrays2.contains(actual, expected);
  }
}

@Override
public boolean checkPermissionImplies(String expected, String[] actual) {
  if(null == expected) {
    return true;
  }
  if(null == actual) {
    return false;
  }
  for(PermissionChecker checker : checkers) {
    if(checker.checkPermissionImplies(expected, actual)) {
      return true;
    }
  }
  return Arrays2.contains(actual, expected);
}

protected String[] parse(String actions) {
  if(actions.equals(ALL)){
    return getAllActionsAscendingSorted();
  }
  
  if(actions.equals(NONE)){
    return Arrays2.EMPTY_STRING_ARRAY;
  }
  
  String[] values = Strings.split(actions,",",true,true);
  
  for(int i=0;i<values.length;i++){
    if(values[i].endsWith(ALL) || values[i].equals(NONE)){
      throw new IllegalArgumentException("invalid actions '" + actions + "', '*' or 'none' can not used with other actions");
    }
    
    if(!Arrays2.contains(getAllActionsAscendingSorted(), values[i])){
      throw new IllegalArgumentException("invalid action '" + values[i] + "'");
    }
  }
  
  Arrays.sort(values);
  
  return values;
}

  break;
if (Arrays2.contains(delimiters, ch)) {
  terminated = true;
  break;
  qouted = !qouted;
if (!qouted && !escaped && Arrays2.contains(delimiters,ch)) {
  terminated = true;
  break;

protected boolean validateString(Validation validation, String name, Object value) {
  if(validated.hasStringValidation()) {
    String s = Converts.toString(value);
    if(null != validated.getMaxLength() && s.length() > validated.getMaxLength()) {
      validation.addError(name, "The string's length must be <= " + validated.getMaxLength());
      return false;
    }
    if(null != validated.getMinLength() && s.length() < validated.getMinLength()) {
      validation.addError(name, "The string's length must be >= " + validated.getMinLength());
      return false;
    }
    if(null != validated.getEnums() && !Arrays2.contains(validated.getEnums(), s)) {
      validation.addError(name, "The value must be one of [" + Strings.join(validated.getEnums(), ',') + "]");
      return false;
    }
    if(null != validated.getPattern()) {
      if(!validated.getPattern().matcher(value.toString()).matches()){
        validation.addError(name, "The value did not matches the pattern!");
        return false;
      }
    }
  }
  return true;
}