ByteArrayOutputStream baos = new ByteArrayOutputStream();
        InputStream transformed = filterChain.transform(new ByteArrayInputStream(input.getBytes(charset.name())));
        // We read byte-by-byte to trigger edge cases in the downstream implementations.
        int read;
        while ((read = transformed.read()) != -1) {
            baos.write(read);
        }

 */

package org.gradle.model.dsl.internal.transform;

import org.gradle.model.dsl.internal.inputs.PotentialInputs;

import javax.annotation.Nullable;

/**
 * Implemented by transformed rules closure.
 */
public interface TransformedClosure {
    /**
     * Returns the input references for this closure.
     */
    InputReferences inputReferences();

    /**

 * limitations under the License.
 */

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

/**
 * Companion type to {@link TransformStepNode} that knows how to compute extra dependent nodes aside from the to be transformed artifact.
 * Instances of this type should not be shared beyond a single transform chain.
 *
 * @see TransformUpstreamDependenciesResolverFactory
 */
public interface TransformUpstreamDependenciesResolver {
    /**

import org.gradle.api.artifacts.component.ModuleComponentSelector;

/**
 * Represents dependency information as stored in an external descriptor file (POM or IVY.XML).
 * This information is able to be transformed into a `ModuleDependencyMetadata` instance.
 */
public abstract class ExternalDependencyDescriptor {

    public abstract ModuleComponentSelector getSelector();

    public abstract boolean isOptional();

     *
     * @param problem the problem to transform
     * @param id the operation id associated with the problem
     * @return the transformed problem
     */
    Problem transform(Problem problem, OperationIdentifier id);

import org.gradle.internal.model.CalculatedValueContainer;
import org.gradle.internal.model.CalculatedValueContainerFactory;

/**
 * An artifact set containing transformed external artifacts.
 */
public class TransformedExternalArtifactSet extends AbstractTransformedArtifactSet {
    public TransformedExternalArtifactSet(
        ComponentIdentifier componentIdentifier,

import org.gradle.internal.operations.BuildOperationQueue;
import org.gradle.internal.operations.RunnableBuildOperation;

/**
 * An artifact set that is failed, capturing the failure and rethrowing when visited or transformed.
 */
public abstract class AbstractFailedResolvedArtifactSet implements ResolvedArtifactSet, ResolvedArtifactSet.Artifacts {
    protected final Throwable failure;

                boolean transformed = maybeTransformNestedMethodCall((MethodCallExpression) expression.getLeftExpression(), transformedCall);
                if (transformed) {
                    // Matches: task <identifier> <arg-list> <operator> <expression>

    /**
     * Copies this state, but with the new component ID and the artifacts transformed by the given transformer.
     */
    LocalComponentGraphResolveState copy(ComponentIdentifier newComponentId, Transformer<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> transformer);

    /**
     * We currently allow a configuration that has been partially observed for resolution to be modified

import org.gradle.api.file.FileCollection;

import java.util.Optional;

public interface TransformDependencies {
    /**
     * Returns the dependency artifacts of the artifact being transformed.
     * The order of the files match that of the dependencies in the source artifact view.
     */
    Optional<FileCollection> getFiles();