/**
* Validates expected {@link org.terracotta.statistics.OperationStatistic} updates for the
* indicated {@code Ehcache} instance. The statistics identified in {@code changed} are checked
* for a value of {@code 1}; all other statistics in the same enumeration class are checked for a
* value of {@code 0}.
*
* @param ehcache the {@code Ehcache} instance to check
* @param changed the statistics values that should have updated values
* @param <E> the statistics enumeration type
*/
protected static <E extends Enum<E>> void validateStats(
final Ehcache<?, ?> ehcache, final EnumSet<E> changed) {
assert changed != null;
final EnumSet<E> unchanged = EnumSet.complementOf(changed);
@SuppressWarnings("unchecked")
final List<EnumSet<E>> sets = Arrays.asList(changed, unchanged);
Class<E> statsClass = null;
for (final EnumSet<E> set : sets) {
if (!set.isEmpty()) {
statsClass = set.iterator().next().getDeclaringClass();
break;
}
}
assert statsClass != null;
final OperationStatistic<E> operationStatistic = getOperationStatistic(ehcache, statsClass);
for (final E statId : changed) {
assertThat(
String.format("Value for %s.%s", statId.getDeclaringClass().getName(), statId.name()),
getStatistic(operationStatistic, statId),
StatisticMatcher.equalTo(1L));
}
for (final E statId : unchanged) {
assertThat(
String.format("Value for %s.%s", statId.getDeclaringClass().getName(), statId.name()),
getStatistic(operationStatistic, statId),
StatisticMatcher.equalTo(0L));
}
}
public static <E extends Enum<E>> E valueOf(Class<E> c, String name, boolean ignorecase) {
// trim any leading or trailing spaces from the name
name = name.trim();
if (!ignorecase) {
{
return Enum.<E>valueOf(c, name);
}
}
E[] universe = c.getEnumConstants();
if (universe == null) {
throw new IllegalArgumentException(name + " is not an enum type");
}
Map<String, E> map = cacheEnumValuesInCapitalLetters.get(c);
if (map == null) {
// populate the map with enum values and add it to cache
map = new HashMap<String, E>(2 * universe.length);
for (E e : universe) {
map.put(e.name().toUpperCase(), e);
}
cacheEnumValuesInCapitalLetters.put(c, map);
}
E result = map.get(name.toUpperCase());
if (result == null) {
throw new IllegalArgumentException("No enum const " + c.getName() + "." + name);
}
return result;
}
public EnumBytesMarshaller(@NotNull Class<E> classMarshaled, E defaultValue) {
this.defaultValue = defaultValue;
mask = interner.length - 1;
for (E e : classMarshaled.getEnumConstants()) {
map.put(e.name(), e);
int idx = hashFor(e.name());
if (!internerDup.get(idx)) {
if (interner[idx] != null) {
//noinspection UnqualifiedFieldAccess,AssignmentToNull
interner[idx] = null;
internerDup.set(idx);
} else {
interner[idx] = e;
}
}
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
public FieldsValidatingForm(final Class<F> fields, final Class<E> errors, final Editor editor) {
this.fields = fields;
this.errors = errors;
this.editor = editor;
for (final E err : errors.getEnumConstants()) {
final F field = err.getField();
if (editor.contains(field)) {
addValidation(
field.name(), err.name(), (HasValue) editor.getEditor(field), err.getValidator());
}
}
}
/**
* Constructs a new {@code EnumParam}, initialized to the default value. Limit the set of options
* with the supplied {@code EnumSet}.
*
* @param name of the {@code Param} (max 72 chars)
* @param info {@code String} for use in tooltips; a {@code null} value will be set to an empty
* {@code String} (max 256 chars)
* @param defaultValue of the {@code Param}
* @param options a subset of the option type
* @throws IllegalArgumentException if {@code name} is an empty string, {@code options} is empty,
* or the {@code defaultValue} is not included in {@code options}
*/
DefaultEnumParam(String name, String info, E defaultValue, Set<E> options) {
super(name, info, defaultValue);
checkNotNull(options);
checkArgument(!options.isEmpty(), "Options is empty");
checkArgument(options.contains(defaultValue), "Default missing from options");
this.options = Sets.immutableEnumSet(options);
// init state
state.addProperty(TYPE.toString(), ENUM.toString());
JsonArray stateOptions = new JsonArray();
for (E option : options) {
stateOptions.add(new JsonPrimitive(option.name()));
}
state.add(OPTIONS.toString(), stateOptions);
}
public <E extends Composite> E parse(String textString, Class<E> composite) {
E e;
try {
Pattern pattern;
Matcher matcher;
e = composite.newInstance();
Class component;
switch (e.name()) {
case "Word":
component = Word.class.getClass();
e = composite.newInstance();
pattern = Pattern.compile("(\\S*[\\s])");
break;
case "Symbol":
component = Symbol.class.getClass();
e = composite.newInstance();
pattern = Pattern.compile("[\\S*]");
break;
default:
component = Word.class.getClass();
pattern = Pattern.compile("[\\S*]");
}
matcher = pattern.matcher(textString);
while (matcher.find()) {
if (component == Symbol.class) {
Symbol s = new Symbol(matcher.group());
e.add(s);
System.out.print(s);
} else {
Component c = this.parse(matcher.group(), component);
e.add(c);
System.out.print(c);
}
}
return e;
} catch (InstantiationException | IllegalAccessException ignored) {
throw new RuntimeException();
}
}
protected <E extends Enum<E>> String renderEnum(E argument) {
return '\'' + argument.name() + '\'';
}
@Override
public void write(@NotNull Bytes bytes, @Nullable E e) {
bytes.writeUTFΔ(e == null ? "" : e.name());
}
protected String getGroupToken(E group) {
return group.name();
}
