this.versionProcessor = versionProcessor;
        return this;
    }

    public DefaultModelBuilderFactory setTransformer(ModelSourceTransformer transformer) {
        this.transformer = transformer;
        return this;
    }

    public DefaultModelBuilderFactory setModelVersionParser(ModelVersionParser versionParser) {
        this.versionParser = versionParser;
        return this;

    useSiteSession: FirSession,
    classId: ClassId,
    transformer: (index: Int, annotation: FirAnnotation) -> KaAnnotation?,
): List<KaAnnotation> = mapIndexedNotNull { index, annotation ->
    if (annotation.toAnnotationClassId(useSiteSession) != classId) {
        return@mapIndexedNotNull null
    }

    transformer(index, annotation)
}

private fun computeTargetAnnotationArguments(

                accessResult.setAccessResultData(null);
                try {
                    final Transformer transformer = ComponentUtil.getComponent(accessResultData.getTransformerName());
                    if (transformer == null) {
                        // no transformer
                        logger.warn("No transformer: {}", accessResultData.getTransformerName());
                        continue;
                    }

    }

    public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
        source.getAST().getStatementBlock().visit(transformer);
        for (Object method : source.getAST().getMethods()) {
            MethodNode methodNode = (MethodNode) method;
            methodNode.getCode().visit(transformer);
        }
    }

    public static ClassNode getScriptClass(SourceUnit source) {

        private final Transformer<String, String> transformer;

        public TransformerBackedFilterAction(Transformer<String, String> transformer) {
            this.transformer = transformer;
        }

        @Override
        public void execute(FileCopyDetails fileCopyDetails) {
            fileCopyDetails.filter(transformer);
        }
    }

        return this;
    }

    @Override
    public DeploymentDescriptor withXml(Closure closure) {
        transformer.addAction(closure);
        return this;
    }

    @Override
    public DeploymentDescriptor withXml(Action<? super XmlProvider> action) {
        transformer.addAction(action);
        return this;
    }

    @Override
    public boolean readFrom(Object path) {

		groupResource: groupResource,
		versioner:     versioner,
		transformer:   transformer,
	}
	if newFunc == nil {
		w.objectType = "<unknown>"
	} else {
		w.objectType = reflect.TypeOf(newFunc()).String()
	}
	s := &store{
		client:              c,
		codec:               codec,
		versioner:           versioner,
		transformer:         transformer,
		pathPrefix:          pathPrefix,

                if (responseProcessor instanceof DefaultResponseProcessor) {
                    final Transformer transformer = ((DefaultResponseProcessor) responseProcessor).getTransformer();
                    final ResultData resultData = transformer.transform(responseData);
                    final byte[] data = resultData.getData();
                    if (data != null) {

        getMainSpec().filter(closure);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public AbstractCopyTask filter(Transformer<String, String> transformer) {
        getMainSpec().filter(transformer);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public AbstractCopyTask expand(Map<String, ?> properties) {

                .<FileTransformer> singleton("fileTransformer", FileTransformer.class, transformer -> {
                    transformer.setName("fileTransformer");
                    transformer.setFeatureMap(featureMap);
                    transformer.setPropertyMap(propertyMap);
                    transformer.setChildUrlRuleMap(childUrlRuleMap);