/**
 * Interface describing the API to resolve concrete types for a given abstract type.
 *
 * For example, a resolver which resolves all {@link java.util.List} to {@link java.util.ArrayList},
 * and delegates other types to the default resolver:
 *
 * <pre>{@code
 * public class ListConcreteTypeResolver implements ConcreteTypeResolver {
 *   <T> List<Class<?>> getPublicConcreteSubTypesOf(final Class<T> type) {
 *     if (List.class.equals(type)) {
 *       return ArrayList.class;
 *     }
 *
 *     return ConcreteTypeResolver.defaultConcreteTypeResolver().getPublicConcreteSubTypesOf(type);
 *   }
 * }
 * }</pre>
 */
@FunctionalInterface
public interface ConcreteTypeResolver {

  /**
   * Returns a list of concrete types for the given {@code type}.
   *
   * @param type the abstract type to resolve
   * @param <T> the actual type to introspect
   * @return a list of all concrete subtypes to use
   */
  <T> List<Class<?>> getPublicConcreteSubTypesOf(final Class<T> type);

  /**
   * @return a default concrete type resolver which will scan the whole classpath for concrete types
   */
  static ConcreteTypeResolver defaultConcreteTypeResolver() {
    return ReflectionUtils::getPublicConcreteSubTypesOf;
  }
}

final CustomRandomizerRegistry randomizerRegistry = new CustomRandomizerRegistry();
final EasyRandom random = new EasyRandom(new EasyRandomParameters().randomizerRegistry(randomizerRegistry));

// the .. at the end specifies to look at all sub-packages as well
final ScanResult result = new ClassGraph().acceptPackages("com.acme.super.cool.package..").scan();
// scan all interfaces; this doesn't include abstract classes, but it shouldn't be hard to add
result.getAllInterfaces().forEach(abstractInfo -> {
  // look at all concrete classes directly implementing this interface
  abstractInfo
    .getClassesImplementing()
    .filter(ClassInfo::isStandardClass)
    .filter(info -> !info.isAbstract())
    .directOnly()
    .forEach(concreteInfo -> {
      randomizerRegistry.registerRandomizer(
        abstractInfo.loadClass(), 
        concreteInfo.loadClass(abstractInfo.loadClass())
      );
  });
});

// this will create an instance of MyConcreteType
final MyAbstractType instance = random.nextObject(MyAbstractType.class);