throw new UnsupportedOperationException()
    }

    @Override
    Class<T> getType() {
        return t.class
    }

    @Override
    <S> ProviderInternal<S> map(Transformer<? extends S, ? super T> transformer) {
        throw new UnsupportedOperationException()
    }

    @Override
    Value<? extends T> calculateValue(ValueConsumer consumer) {
        Value.ofNullable(t)
    }

        this.id = id;
        this.stage = stage;
        this.transformer = transformer;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public String getStage() {
        return stage;
    }

    @Override
    public Transformer getTransformer() {
        return transformer;
    }

    @Override
    public Object getExtractedData() {

    public FactoryBackedCompileOperation(String id, String stage, Transformer transformer, Factory<T> dataFactory, Serializer<T> serializer) {
        this.id = id;
        this.stage = stage;
        this.transformer = transformer;
        this.dataFactory = dataFactory;
        this.serializer = serializer;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public String getStage() {

    def 'can use closure as action'() {
        given:
        transformer.addAction action { Properties props ->
            props.added = 'value'
        }
        when:
        def result = transformer.transform(new Properties())
        then:
        props(added:'value') == result
    }

    def 'can chain actions'() {
        given:
        transformer.addAction action { Properties props ->
            props.remove('removed')

	if err != nil {
		return nil, err
	}

	transformer, err := NewGCMTransformer(block)
	if err != nil {
		return nil, err
	}

	return &transformerWithInfo{transformer: transformer, info: info}, nil
}

type transformerWithInfo struct {
	transformer value.Transformer
	// info are extra opaque bytes prepended to the writes from transformer and stripped from reads.

// -----

// Tests that when the weight tensor for `stablehlo.dot_general` has a
// `stablehlo.constant` -> `stablehlo.transpose` pattern, the
// `stablehlo.constant` is directly transformed to `tfl.pseudo_qconst`, which
// becomes the rhs of `tfl.fully_connected`. This is because
// `tfl.fully_connected` accepts a [o, i] format for rhs, which
// `stablehlo.constant` op already has before the transpose.

    private PropertiesTransformer transformer;

    public PropertiesFileContentMerger(PropertiesTransformer transformer) {
        this.transformer = transformer;
    }

    public PropertiesTransformer getTransformer() {
        return transformer;
    }

    public void setTransformer(PropertiesTransformer transformer) {
        this.transformer = transformer;
    }

    /**

        }

    }

    /*
     * (non-Javadoc)
     *
     * @see
     * org.codelibs.fess.crawler.transformer.Transformer#getData(org.codelibs.fess.crawler.entity
     * .AccessResultData)
     */
    @Override
    public Object getData(final AccessResultData<?> accessResultData) {
        // check transformer name
        if (!getName().equals(accessResultData.getTransformerName())) {
            throw new CrawlerSystemException(

    protected final Transformer<? extends OUT, ? super IN> transformer;

    public TransformBackedProvider(
        @Nullable Class<OUT> type,
        ProviderInternal<? extends IN> provider,
        Transformer<? extends OUT, ? super IN> transformer
    ) {
        this.type = type;
        this.transformer = transformer;
        this.provider = provider;
    }

    @Nullable

func newGCMTransformer(t testing.TB, block cipher.Block, _ []byte) value.Transformer {
	t.Helper()

	transformer, err := NewGCMTransformer(block)
	if err != nil {
		t.Fatal(err)
	}

	return transformer
}

func newGCMTransformerWithUniqueKeyUnsafeTest(t testing.TB, block cipher.Block, _ []byte) value.Transformer {
	t.Helper()