class TransformFactoryImpl implements TransformFactory {

    private final Map<Class<?>, Set<Map.Entry<Class<?>, Supplier<? extends Transform<?, ?>>>>> transforms;
    private final String name;

    /**
     * Instantiates the factory.
     *
     * @param name the unique name to use
     */
    public TransformFactoryImpl(String name) {
        this.name = requireNonNull(name);
        this.transforms = new ConcurrentHashMap<>();
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public <A, B, T extends Transform<A, B>> TransformFactory install(Class<A> from, Class<B> to, Supplier<T> transform) {<FILL_FUNCTION_BODY>}

    @Override
    @SuppressWarnings("unchecked")
    public <A, T extends Transform<A, ?>> Set<Map.Entry<Class<?>, T>> allFrom(Class<A> model) {
        requireNonNull(model);
        return transforms.entrySet().stream()
            .filter(e -> e.getKey().isAssignableFrom(model))
            .flatMap(e -> e.getValue().stream())
            .map(e -> toEntry(e.getKey(), (T) e.getValue().get()))
            .collect(toSet());
    }

    private static <A, T extends Transform<A, ?>> Map.Entry<Class<?>, T> toEntry(Class<?> key, T value) {
        return new AbstractMap.SimpleEntry<>(key, value);
    }
}

        requireNonNulls(from, to, transform);

        transforms.computeIfAbsent(from, f -> new HashSet<>())
            .add(new AbstractMap.SimpleEntry<>(to, transform));

        return this;
    
<no_super_class>