Java Code Examples for org.apache.kafka.common.config.ConfigDef#Validator

protected ConfigDef.Validator getDefaultValidator(Method method) {
  CustomTypeHandler<?> customTypeHandler = customTypeMap.get(method.getReturnType());
  if (customTypeHandler != null) {
    ConfigDef.Validator v = customTypeHandler.validator();
    if (v != null) {
      return v;
    }
  }

  if (method.getReturnType().isEnum()) {
    //noinspection unchecked
    return new EnumValidator((Class<? extends Enum<?>>) method.getReturnType());
  }

  return null;
}
 

@SuppressWarnings("unchecked")
public static <T> ConfigDef.Validator validate(SimpleValidator<T> validator, String description) {
  return new ConfigDef.Validator() {
    @Override
    public String toString() {
      return description;
    }

    @Override
    public void ensureValid(String name, Object value) {
      try {
        validator.validate((T) value);
      } catch (Exception e) {
        throw new ConfigException(name, value, e.getMessage());
      }
    }
  };
}
 

@Test
public void ensureValid() throws Exception {
    ConfigDef.Validator validator = ValidClass.isSubclassOf(A.class);
    // same class
    validator.ensureValid("myname", A.class);
    // anonymous subclass
    validator.ensureValid("myname", B.class);
}
 

protected ConfigDef.Validator getValidator(Method method) {
  ConfigDef.Validator userProvided = (ConfigDef.Validator) invokeCompanion(method, "Validator");
  if (userProvided != null) {
    return userProvided;
  }

  return getDefaultValidator(method);
}
 

@SuppressWarnings("unused")
static ConfigDef.Validator stringValueValidator() {
  return (name, value) -> {
    if (((String) value).contains("z")) {
      throw new ConfigException(name, value, "The letter 'z' has been outlawed.");
    }
  };
}
 

private static List<String> enumer(ConfigDef.Validator validator) {
    try {
        Field f = getField(ConfigDef.ValidString.class, "validStrings");
        return (List) f.get(validator);
    } catch (ReflectiveOperationException e) {
        throw new RuntimeException(e);
    }
}
 

public static ValidatorWithOperators withStringDef(
    final String validatorString, final ConfigDef.Validator validator) {
  return new ValidatorWithOperators() {
    @Override
    public void ensureValid(final String name, final Object value) {
      validator.ensureValid(name, value);
    }

    @Override
    public String toString() {
      return validatorString;
    }
  };
}
 

@Test
public void display() {
  ConfigDef.Validator validator = new ValidCharset("UTF-8");
  final String expected = "Valid values: 'UTF-8'";
  final String actual = validator.toString();
  System.out.println(actual);
  assertEquals(expected, actual);
}
 

default ValidatorWithOperators or(ConfigDef.Validator other) {
    return (name, value) -> {
        try {
            this.ensureValid(name, value);
        } catch (ConfigException e) {
            other.ensureValid(name, value);
        }
    };
}
 

@Test
public void list() {
  ConfigDef.Validator validator = new ValidCharset();
  validator.ensureValid("testing", Arrays.asList("UTF-8", "UTF-16"));
  System.out.println(validator);
}
 

@Test
public void utf8() {
  ConfigDef.Validator validator = new ValidCharset();
  validator.ensureValid("testing", "utf8");
}
 

public static ConfigDef.Validator of(ConfigDef.Validator validator) {
  return new BlankOrValidator(validator);
}
 

@Test(expected = ConfigException.class)
public void ensureValidNotSubclass() {
    ConfigDef.Validator validator = ValidClass.isSubclassOf(A.class);
    validator.ensureValid("myname", C.class);

}
 

BlankOrValidator(ConfigDef.Validator validator) {
  Preconditions.checkNotNull(validator, "validator cannot be null.");
  this.validator = validator;
}
 

@Test(expected = ConfigException.class)
public void ensureValidNotAccessible() {
    // not instantiable
    ConfigDef.Validator validator = ValidClass.isSubclassOf(A.class);
    validator.ensureValid("myname", E.class);
}
 

public ConfigDef.Validator validator() {
  return this.validator;
}
 

@SuppressWarnings("unused")
static ConfigDef.Validator defaultCollectionValidator() {
  return validate(ScopeAndCollection::parse, "A collection name qualified by a scope name (scope.collection)");
}
 

@SuppressWarnings("unused")
static ConfigDef.Validator topicToCollectionValidator() {
  return validate(TopicMap::parse, "topic=scope.collection,...");
}
 

@Nullable
ConfigDef.Validator getValidator();
 

default ValidatorWithOperators and(ConfigDef.Validator other) {
    return  (name, value) -> {
        this.ensureValid(name, value);
        other.ensureValid(name, value);
    };
}