super(metadata, path, timestamp);
        this.buildNumber = buildNumber;
    }

    @Deprecated
    @Override
    public MavenMetadata setFile(File file) {
        return new RemoteSnapshotMetadata(metadata, file.toPath(), timestamp, buildNumber);
    }

    @Override
    public MavenMetadata setPath(Path path) {

        DefaultProjectIdentifier id = new DefaultProjectIdentifier(owner.getBuildRootDir(), project.getProjectPath().getPath());
        BasicGradleProject converted = new BasicGradleProject()
            .setName(project.getName())
            .setProjectIdentifier(id)
            .setBuildTreePath(project.getIdentityPath().getPath())
            .setProjectDirectory(project.getProjectDir());

	b[i/64] |= ^uint64(0) << (i % 64)
	for k := i/64 + 1; k < j/64; k++ {
		b[k] = ^uint64(0)
	}
	// Set trailing bits.
	b[j/64] |= (uint64(1) << (j%64 + 1)) - 1
}

// setAll sets all the bits of b.
func (b *pageBits) setAll() {
	for i := range b {
		b[i] = ^uint64(0)
	}
}

// setBlock64 sets the 64-bit aligned block of bits containing the i'th bit that
// are set in v.

        if (inheritedFilter != null && !inheritedFilter.include(dependencyArtifact)) {
            return null;
        }

        if (Artifact.SCOPE_SYSTEM.equals(effectiveScope)) {
            dependencyArtifact.setFile(new File(dependency.getSystemPath()));
        }

        dependencyArtifact.setDependencyFilter(createDependencyFilter(dependency, inheritedFilter));

        return dependencyArtifact;
    }

    public void resolve(final TypeMetaData type, final ClassMetaData classMetaData) {
        type.visitTypes(new Action<TypeMetaData>() {
            @Override
            public void execute(TypeMetaData t) {
                t.setName(resolve(t.getName(), classMetaData));
            }
        });
    }

    /**
     * Resolves a source type name into a fully qualified type name.
     */

        ContainerConfiguration containerConfiguration = new DefaultContainerConfiguration()
                .setClassWorld(new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader()))
                .setName("mavenCore").setClassPathScanning(PlexusConstants.SCANNING_INDEX).setAutoWiring(true);

        DefaultPlexusContainer container = new DefaultPlexusContainer(containerConfiguration);

     */

    static class ThreadExecuter implements Action<Runnable> {
        @Override
        public void execute(Runnable runnable) {
            Thread thread = new Thread(runnable);
            thread.setName("DisconnectableInputStream source reader");
            thread.setDaemon(true);
            thread.start();
        }
    }

    public DisconnectableInputStream(InputStream source) {
        this(source, 1024);

    private Set<File> sources = new LinkedHashSet<>();

    /**
     * The name of the library.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * The type of the library.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {

	{112, "EHOSTDOWN", "host is down"},
	{113, "EHOSTUNREACH", "no route to host"},
	{114, "EALREADY", "operation already in progress"},
	{115, "EINPROGRESS", "operation now in progress"},
	{116, "ESTALE", "stale file handle"},
	{117, "EUCLEAN", "structure needs cleaning"},
	{118, "ENOTNAM", "not a XENIX named type file"},
	{119, "ENAVAIL", "no XENIX semaphores available"},
	{120, "EISNAM", "is a named type file"},

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    public List<String> findVersions(Artifact artifact) {
        return Collections.emptyList();
    }

    public String getId() {