Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error)

	// Reset resets the state and allows a Transformer to be reused.
	Reset()
}

// SpanningTransformer extends the Transformer interface with a Span method
// that determines how much of the input already conforms to the Transformer.
type SpanningTransformer interface {
	Transformer

    private final Function<String, String> transformer;

    public ${className}(Function<String, String> transformer) {
        this.transformer = transformer;
    }

    /**
     * Transforms the given model
     */
    public ${root.name} visit(${root.name} target) {
        Objects.requireNonNull(target, "target cannot be null");
        return transform${root.name}(target);
    }

    /**

// license that can be found in the LICENSE file.

package norm

import (
	"unicode/utf8"

	"golang.org/x/text/transform"
)

// Reset implements the Reset method of the transform.Transformer interface.
func (Form) Reset() {}

// Transform implements the Transform method of the transform.Transformer
// interface. It may need to write segments of up to MaxSegmentSize at once.

 */
package org.codelibs.fess.crawler.transformer;

import org.codelibs.fess.crawler.entity.AccessResultData;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.entity.ResultData;

/**
 * @author shinsuke
 *
 */
public interface Transformer {

    ResultData transform(ResponseData responseData);

     * @param action the action to add
     */
    public void addAction(Action<? super T> action) {
        actions.add(action);
    }

    /**
     * Transforms a property list object. This will modify the
     * original.
     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override
    public T transform(T original) {

package org.gradle.internal;

/**
 * Equivalent to {@code Transformer}, but does not declare nullability due to Java 6 restrictions.
 *
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface InternalTransformer<OUT, IN> {

    def "reuses file from its origin cache when transform is none"() {
        given:
        def file = testDir.file("other/thing.jar")
        _ * globalCacheLocations.isInsideGlobalCache(file.absolutePath) >> true
        jar(file)
        def classpath = DefaultClassPath.of(file)
        transformer.transform(classpath, None)

        when:
        def cachedClasspath = transformer.transform(classpath, None)

        then:

import org.gradle.internal.Either;
import org.gradle.internal.classpath.transforms.ClassTransform;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactory;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForAgent;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForLegacy;
import org.gradle.internal.classpath.transforms.InstrumentingClassTransform;

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/transforms.h"

#include "mlir/Pass/PassManager.h"  // from @llvm-project
#include "mlir/Transforms/Passes.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/drop_savedmodel_semantics.h"
#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/legalize_tf_xla_call_module_to_stablehlo_pass.h"

     * Returns grouped output for the given transformer type and transform subject.
     */
    public GroupedTransformOutputFixture transform(String transformer, String subject) {
        List<GroupedTransformOutputFixture> foundTransforms = transforms.values().stream()
            .filter(transform -> transform.getTransformer().equals(transformer) && transform.getSubject().equals(subject))
            .collect(Collectors.toList());