Package revxrsal.commands.process

Interface ValueResolverFactory

All Known Implementing Classes:
EntitySelectorResolver
public interface ValueResolverFactory
Creates a ValueResolver for specific types of parameters. These are most useful in the following cases:
  • Creating a value resolver for only a specific type of parameters, for example those with a specific annotation
  • Creating value resolvers for a common interface or class

For example, the following is a resolver factory that finds values for enums, while respecting CaseSensitive parameters. 


 enum EnumResolverFactory implements ValueResolverFactory {

     INSTANCE;

     @Override public @Nullable ValueResolver<?> create(@NotNull CommandParameter parameter) {
         Class<?> type = parameter.getType();
         if (!type.isEnum()) return null;
         Class<? extends Enum> enumType = type.asSubclass(Enum.class);
         Map<String, Enum<?>> values = new HashMap<>();
         boolean caseSensitive = parameter.hasAnnotation(CaseSensitive.class);
         for (Enum<?> enumConstant : enumType.getEnumConstants()) {
             if (caseSensitive)
                 values.put(enumConstant.name(), enumConstant);
             else
                 values.put(enumConstant.name().toLowerCase(), enumConstant);
         }
         return (ValueResolver<Enum<?>>) (arguments, actor, parameter1, command) -> {
             String value = arguments.pop();
             Enum<?> v = values.get(caseSensitive ? value : value.toLowerCase());
             if (v == null)
                 throw new EnumNotFoundException(parameter, value, actor);
             return v;
         };
     }
 }

Note that ValueResolverFactoryies must be registered with CommandHandler.registerValueResolverFactory(ValueResolverFactory).

  • Method Details

    • create

      @Nullable @Nullable ValueResolver<?> create(@NotNull @NotNull CommandParameter parameter)
      Creates a value resolver for the specified type, or null if this type is not supported by this factory.
      Parameters:
      parameter - The parameter to create for
      Returns:
      The ValueResolver, or null if not supported.

    • forType

      @NotNull static <T> @NotNull ValueResolverFactory forType(Class<T> type, ValueResolver<T> resolver)
      Creates a ValueResolverFactory that will return the same resolver for all parameters that match a specific type
      Type Parameters:
      T - The resolver value type
      Parameters:
      type - Type to check for
      resolver - The value resolver to use
      Returns:
      The resolver factory

    • forHierarchyType

      @NotNull static <T> @NotNull ValueResolverFactory forHierarchyType(Class<T> type, ValueResolver<T> resolver)
      Creates a ValueResolverFactory that will return the same resolver for all parameters that match or extend a specific type
      Type Parameters:
      T - The resolver value type
      Parameters:
      type - Type to check for
      resolver - The value resolver to use
      Returns:
      The resolver factory