}

    public void replace(Transformer<? extends @org.jetbrains.annotations.Nullable Provider<? extends T>, ? super Provider<T>> transformation) {
        Provider<? extends T> newValue = transformation.transform(shallowCopy());
        if (newValue != null) {
            set(newValue);
        } else {
            set((T) null);
        }
    }

 */
public enum UncategorizedBuildOperations implements BuildOperationMetadata {
    /**
     * Creates and executes the transform actions. {@link BuildOperationCategory#TRANSFORM} can include this operation.
     */
    TRANSFORM_ACTION

import org.gradle.internal.declarativedsl.analysis.ObjectOrigin
import org.gradle.internal.declarativedsl.analysis.ResolutionResult
import org.gradle.internal.declarativedsl.analysis.transformation.OriginReplacement.replaceReceivers
import org.gradle.internal.declarativedsl.evaluator.features.ResolutionResultHandler
import org.gradle.internal.declarativedsl.evaluator.softwareTypes.SOFTWARE_TYPE_ACCESSOR_PREFIX

type EndpointRestrictions interface {
	// AllowsMediaTypeTransform returns true if the endpoint allows either the requested mime type
	// or the requested transformation. If false, the caller should ignore this mime type. If the
	// target is nil, the client is not requesting a transformation.
	AllowsMediaTypeTransform(mimeType, mimeSubType string, target *schema.GroupVersionKind) bool

    const std::vector<OutputTensor>& arg_source_tensors,
    std::unique_ptr<Graph>* graph, std::vector<int>* input_permutation,
    std::vector<int>* output_permutation, NodeDef* node_def)>
    RewriteSubgraphFn;

// Transformation that finds subgraphs whose nodes are marked with
// 'group_attribute', splits those subgraphs into functions, and replaces
// the originals with function calls.
//

        // do nothing
    }

    /**
     * Checks the specified (raw) model for missing or invalid values. The raw model is the file model + buildpom filter
     * transformation and has not been subjected to inheritance, interpolation or profile/default injection.
     *
     * @param model The model to validate, must not be {@code null}.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.classpath.transforms;

import java.io.File;

/**
 * A "pending" transformation of the original jar/directory.
 */
public interface ClasspathElementTransform {
    /**
     * Transform the jar/directory into destination. The destination should be a JAR file name.
     *

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.internal.transformation;

/**
 * Exception that may be thrown by the {@link org.apache.maven.artifact.Artifact#getFile()}
 * implementation.
 */
public class TransformationFailedException extends RuntimeException {

abstract class AbstractLanguagePluginSpec extends PlatformBaseSpecification {
    abstract Class getPluginClass()

    abstract Class getLanguageSourceSet()

    abstract String getLanguageId()

    def "registers transformation for language"() {
        when:
        dsl {
            apply plugin: pluginClass
        }

        then:
        def transform = realize("languageTransforms").find { it.languageName == languageId }

 * limitations under the License.
 */

package org.gradle.api.problems.internal;

import org.gradle.api.problems.Problems;
import org.gradle.internal.operations.OperationIdentifier;

/**
 * Describes a transformation that can be applied to a problem.
 * <p>
 * These transformers could be added to the {@link Problems} service to transform problems before they are reported.
 */
public interface ProblemTransformer {

    /**