private Object destination;
    private final Cached<MavenPomFileGenerator.MavenPomSpec> mavenPomSpec = Cached.of(() ->
        MavenPomFileGenerator.generateSpec((MavenPomInternal) getPom())
    );

    @Inject
    protected FileResolver getFileResolver() {
        throw new UnsupportedOperationException();
    }

    /**
     * Get the version range mapper.
     *

        given:
        file('src/main/java/Test.java') << """
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Test {
    private static final Log logger = LogFactory.getLog(Test.class);
}
"""

        and:
        buildFile << """
apply plugin: 'java'

${mavenCentralRepository()}

dependencies {
    compileOnly 'commons-logging:commons-logging:1.2'
}
"""

    @Override
    public ModuleArtifact getArtifact(String relativePath) {
        return backingModule.getArtifact(relativePath);
    }

    @Override
    public ModuleArtifact getPom() {
        return backingModule.getPom();
    }

    @Override
    public ModuleArtifact getModuleMetadata() {
        return backingModule.getModuleMetadata();
    }

    @Override
    public String getArtifactId() {

 * transformed to the first argument, and the callable kind becomes static). For Groovy properties,
 * the name of the callable is also transformed from "foo" to "getFoo".
 * It is possible to specify the custom name for the extension implementation, if needed.
 */
public @interface WithExtensionReferences {
    Class<?> toClass();
    String methodName() default "";

        super(backingModule)
        this.bucket = bucket
        this.server = server
        this.backingModule = backingModule
        this.repositoryPath = repositoryPath
    }

    GcsArtifact getPom() {
        return new GcsArtifact(server, pomFile, repositoryPath, bucket)
    }

    GcsArtifact getModuleMetadata() {
        return new GcsArtifact(server, backingModule.moduleMetadata.file, repositoryPath, bucket)

        artifact(classifier: "javadoc")
        return this
    }

    MavenHttpModule withNoPom() {
        backingModule.withNoPom()
        return this
    }

    PomHttpArtifact getPom() {
        return new PomHttpArtifact(server, uriPath, backingModule)
    }

    @Override
    HttpArtifact getModuleMetadata() {
        return getArtifact(type: 'module')
    }

    }

    private final long pos;

    private BlockPointer(long pos) {
        this.pos = pos;
    }

    public boolean isNull() {
        return pos < 0;
    }

    public long getPos() {
        return pos;
    }

    @Override
    public String toString() {
        return String.valueOf(pos);
    }

    @Override
    public boolean equals(Object obj) {

		key := "pods/" + obj.Namespace + "/" + obj.Name
		out := &example.Pod{}
		err := etcdStorage.Create(context.TODO(), key, obj, out, 0)
		require.NoError(t, err)
		return out
	}
	getPod := func(name, ns string) *example.Pod {
		key := "pods/" + ns + "/" + name
		out := &example.Pod{}
		err := etcdStorage.Get(context.TODO(), key, storage.GetOptions{}, out)
		require.NoError(t, err)
		return out
	}

import org.gradle.api.tasks.TaskProvider;

public interface MavenPublicationInternal extends MavenPublication, PublicationInternal<MavenArtifact> {

    @Override
    MavenPomInternal getPom();

    void setPomGenerator(TaskProvider<? extends Task> pomGenerator);

    void setModuleDescriptorGenerator(TaskProvider<? extends Task> moduleMetadataGenerator);

     * method directly whenever you need the logger, it is fast enough and needs no caching.
     *
     * @see org.apache.maven.plugin.Mojo#getLog()
     * @deprecated Use SLF4J directly
     */
    @Deprecated
    @Override
    public Log getLog() {
        if (log == null) {
            log = new SystemStreamLog();
        }

        return log;
    }

    @Override