*/

package org.gradle.api.internal.artifacts.transform;

import com.google.common.collect.ImmutableList;
import org.gradle.api.Describable;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;

import java.io.File;

/**
 * Transform subject is either an initial artifact for the transform chain or a result of a previous transform step.

            }
        };
    }

    private void instrument(File sourceDir, File destination) {
        ClasspathElementTransform transform = transformFactory.createTransformer(sourceDir, new InstrumentingClassTransform(), InstrumentationTypeRegistry.EMPTY);
        transform.transform(destination);
    }

    @Nullable
    @Override
    public Object loadAlreadyProducedOutput(File workspace) {

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

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.internal.artifacts.TransformRegistration;
import org.gradle.api.internal.attributes.ImmutableAttributes;

import java.nio.file.Path;

import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.model.Model;

/**
 * The ModelTransformer is a way to transform the local pom while streaming the input.
 *
 * The {@link #transform(ModelTransformerContext, Model, Path)} method uses a Path on purpose, to ensure the
 * local pom is the original source.
 *
 * @since 4.0.0
 */
public interface ModelTransformer {

import org.gradle.api.internal.artifacts.transform.CacheableTransformTypeAnnotationHandler;
import org.gradle.api.internal.artifacts.transform.InputArtifactAnnotationHandler;
import org.gradle.api.internal.artifacts.transform.InputArtifactDependenciesAnnotationHandler;
import org.gradle.api.internal.artifacts.transform.TransformActionScheme;
import org.gradle.api.internal.artifacts.transform.TransformParameterScheme;

     *
     * @param in The object to transform.
     * @return The transformed object.
     */
    OUT transform(IN in);

// NewClientWithOptions wraps the provided RESTClient and invokes each transform on each
// newly created request.
func NewClientWithOptions(c RESTClient, transforms ...RequestTransform) RESTClient {
	if len(transforms) == 0 {
		return c
	}
	return &clientOptions{c: c, transforms: transforms}
}

type clientOptions struct {
	c          RESTClient
	transforms []RequestTransform
}

    ConfigurationIdentity getConfigurationIdentity();

    /**
     * Returns a collection containing the future artifacts for the given transform step.
     */
    FileCollection selectedArtifacts();

    /**
     * Computes the finalized dependency artifacts for the given transform step.
     */
    Try<TransformDependencies> computeArtifacts();

    void finalizeIfNotAlready();

            interpolator.setCacheAnswers(true);
            valueSources.forEach(interpolator::addValueSource);
        }

        public XmlNode transform(XmlNode node) {
            return super.transform(node);
        }

        protected String transform(String str) {
            try {
                return interpolator.interpolate(str);
            } catch (InterpolationException e) {

                .version("therev-thesha")
                .build());
        Model actual = transform(initial);
        assertTrue(equalsDeep(expected, actual));
    }

    Model transform(Model model) {
        Model transformed = model.clone();
        new BuildModelSourceTransformer().transform(pomFile, context, transformed);
        return transformed;
    }