class JavaGenerator implements Generator {
    
	private static final Pattern[] IGNORED = compileAll(
        "^void$",
		"^byte$",
        "^short$",
        "^char$",
        "^int$",
        "^long$",
        "^boolean$",
        "^float$",
        "^double$",
        "^java\\.lang\\.[^\\.]+$"
    );

	private final Generator inner;


    /**
     * Instantiates the JavaGenerator.
     */
    public JavaGenerator() {
        this(new JavaTransformFactory());
    }
	
    /**
     * Instantiates the JavaGenerator using an array of custom 
     * {@link TransformFactory}.
     * <p>
     * Warning! If you use this constructor, no transforms will be installed
     * by default!
     * 
     * @param factory  the transform factory to use
     */
	public JavaGenerator(TransformFactory factory) {
	    inner = Generator.create(DependencyManager.create(IGNORED), factory);
	}

    @Override
    public DependencyManager getDependencyMgr() {
        return inner.getDependencyMgr();
    }

    @Override
    public RenderStack getRenderStack() {
        return inner.getRenderStack();
    }

    @Override
    public <A, B> Stream<Meta<A, B>> metaOn(A from, Class<B> to) {
        return inner.metaOn(from, to);
    }

    @Override
    public <A, B> Stream<Meta<A, B>> metaOn(A from, Class<B> to, Class<? extends Transform<A, B>> transform) {
        return inner.metaOn(from, to, transform);
    }

    @Override
    public <M> Stream<Meta<M, String>> metaOn(M model) {
        return inner.metaOn(model);
    }

    @Override
    public <A> Stream<Meta<A, String>> metaOn(Collection<A> models) {
        return inner.metaOn(models);
    }

    @Override
    public <A, B> Stream<Meta<A, B>> metaOn(Collection<A> models, Class<B> to) {
        return inner.metaOn(models, to);
    }

    @Override
    public <A, B> Stream<Meta<A, B>> metaOn(Collection<A> models, Class<B> to, Class<? extends Transform<A, B>> transform) {
        return inner.metaOn(models, to, transform);
    }

    @Override
    public Optional<String> on(Object model) {
        return inner.on(model);
    }

    @Override
    public <M> Stream<String> onEach(Collection<M> models) {
        return inner.onEach(models);
    }

    @Override
    public <A, B> Optional<Meta<A, B>> transform(Transform<A, B> transform, A model, TransformFactory factory) {
        return inner.transform(transform, model, factory);
    }

    public static Generator create(DependencyManager mgr, TransformFactory factory) {
        return Generator.create(mgr, factory);
    }

    private static Pattern[] compileAll(String... regexp) {<FILL_FUNCTION_BODY>}
}

        final Set<Pattern> patterns = Stream.of(regexp)
            .map(Pattern::compile)
            .collect(Collectors.toSet());

        return patterns.toArray(new Pattern[patterns.size()]);
    
<no_super_class>