public VersionInfo(Version version) {
        this.version = version;
    }

    @Override
    public Version getVersion() {
        return version;
    }

    @Override
    public boolean equals(Object other) {
        return other instanceof VersionInfo && version.equals(((VersionInfo) other).getVersion());
    }

    @Override
    public int hashCode() {
        return version.hashCode();
    }

        // TODO Should this be changed for MNG-6754 too?
        versioning.updateTimestamp();
        versioning.addVersion(artifact.getVersion());

        if (artifact.isRelease()) {
            versioning.setRelease(artifact.getVersion());
        }

        return new ArtifactRepositoryMetadata(artifact, versioning);
    }

                if (equals(existing.getVersion(), dependency.getVersion())) {
                    msg = "duplicate declaration of version " + Objects.toString(dependency.getVersion(), "(?)");
                } else {
                    msg = "version " + Objects.toString(existing.getVersion(), "(?)") + " vs "
                            + Objects.toString(dependency.getVersion(), "(?)");
                }

        return id.getComponentIdentifier().getGroup();
    }

    String getModule() {
        return id.getComponentIdentifier().getModule();
    }

    String getVersion() {
        return id.getComponentIdentifier().getVersion();
    }

    public ArtifactVerificationOperation.ArtifactKind getArtifactKind() {
        return artifactKind;
    }

    public File getFile() {
        return file;
    }

        super(String.format("The version of Gradle you are using (%s) does not %s. Support for this is available in Gradle %s and all later versions.",
              targetGradleVersion.getVersion(), feature, minSupportedGradleVersion.getVersion()));
    }

    public UnsupportedFeatureException(String message) {
        super(message);
    }

    }

    @Nullable
    private static String getVersion(PluginRequestInternal pluginRequest) {
        if (pluginRequest.getOriginalRequest() != null) {
            return pluginRequest.getOriginalRequest().getVersion();
        }
        return pluginRequest.getVersion();
    }

            return;
        }
        writeTableHeader("versions");
        for (String alias : versions) {
            write(normalizeForToml(alias) + " = ");
            writeLn(versionString(model.getVersion(alias).getVersion()));
        }
        writeLn();
    }

    private void writeLibraries(DefaultVersionCatalog model) {
        List<String> aliases = model.getLibraryAliases();
        if (aliases.isEmpty()) {

            }
            return version.getPreferredVersion();
        }

        protected ImmutableVersionConstraint findVersionConstraint(String name) {
            return config.getVersion(name).getVersion();
        }
    }

    public static class BundleFactory {
        protected final ProviderFactory providers;
        protected final DefaultVersionCatalog config;

        }
        if (result && os.getVersion() != null) {
            result = determineVersionMatch(os.getVersion());
        }
        return result;
    }

    private boolean ensureAtLeastOneNonNull(ActivationOS os) {
        return os.getArch() != null || os.getFamily() != null || os.getName() != null || os.getVersion() != null;
    }

    private boolean determineVersionMatch(String version) {

            byte protocolVersion = dataInput.readByte();
            if (protocolVersion != protocol.getVersion()) {
                throw new IllegalStateException(String.format("Unexpected lock protocol found in lock file. Expected %s, found %s.", protocol.getVersion(), protocolVersion));
            }
            return protocol.read(dataInput);
        } catch (EOFException e) {