*
     * @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);

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

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

import org.gradle.api.artifacts.transform.InputArtifact;
import org.gradle.api.artifacts.transform.TransformOutputs;
import org.gradle.api.file.FileSystemLocation;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.Classpath;

import org.gradle.api.artifacts.transform.TransformParameters

// tag::artifact-transform-countloc[]
abstract class CountLoc implements TransformAction<TransformParameters.None> {

    @Inject                                                             // <1>
    abstract InputChanges getInputChanges()

    @PathSensitive(PathSensitivity.RELATIVE)
    @InputArtifact
    abstract Provider<FileSystemLocation> getInput()

    @Override

                @Override
                String toString() {
                    return "BiFunction with $provider"
                }
            }
            transform.provider = new BiProvider(String, Providers.of("A"), Providers.of("B"), transform)
            return transform.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [TO_STRING, GET_PRODUCER]
        }

 *
 * <p>The constraints allows certain optimizations. Currently, this is limited to skipping the transform when the provider presence is queried, but other optimizations may be added in the future.
 * Also, because the transform does not use the value content, this provider also skips checks to verify that the content has been built when the value is queried.</p>
 *
 * @see ProviderInternal for a discussion of the "value" and "value contents".

        this.typeRegistry = typeRegistry;
        this.transform = transform;
    }

    @Override
    public final void transform(File destination) {
        resultBuilder().accept(destination, builder -> {
            try {
                visitEntries(builder);
            } catch (FileException e) {
                // Badly formed archive, so discard the contents and produce an empty JAR

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.resolve.transform

import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest
import org.gradle.util.internal.ToBeImplemented

 */

package org.gradle.tooling.events.transform;

import org.gradle.tooling.events.ProgressEvent;

/**
 * Root interface for all events that signal progress while executing a transform.
 *
 * @since 5.1
 */
public interface TransformProgressEvent extends ProgressEvent {
    /**
     * Returns the description of the transform for which progress is reported.
     *

 * limitations under the License.
 */
package gradlebuild.docs;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

    private final String rootProjectLocation;
    private final String producerBuildTreePath;
    private final MutableWorkspaceProvider workspaceProvider;

    public MutableTransformExecution(
        Transform transform,
        File inputArtifact,
        TransformDependencies dependencies,
        TransformStepSubject subject,
        ProjectInternal producerProject,

        TransformExecutionListener transformExecutionListener,