/// <summary>
/// Gives a hash code based on the normalized version string.
/// </summary>
public int GetHashCode(SimpleVersion obj)
{
if (Object.ReferenceEquals(obj, null))
{
return(0);
}
string verString = string.Empty;
VersionFormatter formatter = new VersionFormatter();
if (_mode == VersionComparison.Default || _mode == VersionComparison.VersionRelease)
{
verString = obj.ToString("V-R", formatter).ToUpperInvariant();
}
else if (_mode == VersionComparison.Version)
{
verString = obj.ToString("V", formatter);
}
else if (_mode == VersionComparison.VersionReleaseMetadata)
{
verString = String.Format(CultureInfo.InvariantCulture, "{0}+{1}",
obj.ToString("V-R", formatter).ToUpperInvariant(),
obj.ToString("M", formatter));
}
if (String.IsNullOrEmpty(verString))
{
verString = obj.ToNormalizedString().ToUpperInvariant();
}
return(verString.GetHashCode());
}
private static bool?IsPrerelease(SimpleVersion version)
{
bool?b = null;
SemanticVersion semVer = version as SemanticVersion;
if (semVer != null)
{
b = semVer.IsPrerelease;
}
return(b);
}
/// <summary>
/// Creates a VersionRange with the given min and max.
/// </summary>
/// <param name="minVersion">Lower bound of the version range.</param>
/// <param name="includeMinVersion">True if minVersion satisfies the condition.</param>
/// <param name="maxVersion">Upper bound of the version range.</param>
/// <param name="includeMaxVersion">True if maxVersion satisfies the condition.</param>
/// <param name="includePrerelease">True if prerelease versions should satisfy the condition.</param>
public VersionRange(SimpleVersion minVersion = null, bool includeMinVersion = true, SimpleVersion maxVersion = null,
bool includeMaxVersion = false, bool?includePrerelease = null)
{
_minVersion = minVersion;
_maxVersion = maxVersion;
_includeMinVersion = includeMinVersion;
_includeMaxVersion = includeMaxVersion;
if (includePrerelease == null)
{
_includePrerelease = (_maxVersion != null && IsPrerelease(_maxVersion) == true) ||
(_minVersion != null && IsPrerelease(_minVersion) == true);
}
else
{
_includePrerelease = includePrerelease == true;
}
}
/// <summary>
/// Determines if an NuGetVersion meets the requirements using the version comparer.
/// </summary>
/// <param name="version">SemVer to compare.</param>
/// <param name="comparer">Version comparer used to determine if the version criteria is met.</param>
/// <returns>True if the given version meets the version requirements.</returns>
public bool Satisfies(SimpleVersion version, IVersionComparer comparer)
{
if (version == null)
{
throw new ArgumentNullException("version");
}
// Determine if version is in the given range using the comparer.
bool condition = true;
if (HasLowerBound)
{
if (IsMinInclusive)
{
condition &= comparer.Compare(MinVersion, version) <= 0;
}
else
{
condition &= comparer.Compare(MinVersion, version) < 0;
}
}
if (HasUpperBound)
{
if (IsMaxInclusive)
{
condition &= comparer.Compare(MaxVersion, version) >= 0;
}
else
{
condition &= comparer.Compare(MaxVersion, version) > 0;
}
}
if (!IncludePrerelease)
{
condition &= IsPrerelease(version) != true;
}
return(condition);
}
/// <summary>
/// Determines if an NuGetVersion meets the requirements using the given mode.
/// </summary>
/// <param name="version">SemVer to compare</param>
/// <param name="versionComparison">VersionComparison mode used to determine the version range.</param>
/// <returns>True if the given version meets the version requirements.</returns>
public bool Satisfies(SimpleVersion version, VersionComparison versionComparison)
{
return(Satisfies(version, new VersionComparer(versionComparison)));
}
/// <summary>
/// Determines if an NuGetVersion meets the requirements.
/// </summary>
/// <param name="version">SemVer to compare</param>
/// <returns>True if the given version meets the version requirements.</returns>
public bool Satisfies(SimpleVersion version)
{
// ignore metadata by default when finding a range.
return(Satisfies(version, VersionComparer.VersionRelease));
}
/// <summary>
/// Compare versions.
/// </summary>
public int Compare(SimpleVersion x, SimpleVersion y)
{
// null checks
if (Object.ReferenceEquals(x, null) && Object.ReferenceEquals(y, null))
{
return(0);
}
if (Object.ReferenceEquals(y, null))
{
return(1);
}
if (Object.ReferenceEquals(x, null))
{
return(-1);
}
SemanticVersion semX = x as SemanticVersion;
SemanticVersion semY = y as SemanticVersion;
if (semX != null && semY != null)
{
// compare version
int result = semX.Major.CompareTo(semY.Major);
if (result != 0)
{
return(result);
}
result = semX.Minor.CompareTo(semY.Minor);
if (result != 0)
{
return(result);
}
result = semX.Patch.CompareTo(semY.Patch);
if (result != 0)
{
return(result);
}
NuGetVersion legacyX = x as NuGetVersion;
NuGetVersion legacyY = y as NuGetVersion;
result = CompareLegacyVersion(legacyX, legacyY);
if (result != 0)
{
return(result);
}
if (_mode != VersionComparison.Version)
{
// compare release labels
if (semX.IsPrerelease && !semY.IsPrerelease)
{
return(-1);
}
if (!semX.IsPrerelease && semY.IsPrerelease)
{
return(1);
}
if (semX.IsPrerelease && semY.IsPrerelease)
{
result = CompareReleaseLabels(semX.ReleaseLabels, semY.ReleaseLabels);
if (result != 0)
{
return(result);
}
}
// compare the metadata
if (_mode == VersionComparison.VersionReleaseMetadata)
{
result = StringComparer.OrdinalIgnoreCase.Compare(semX.Metadata ?? string.Empty, semY.Metadata ?? string.Empty);
if (result != 0)
{
return(result);
}
}
}
}
return(0);
}
/// <summary>
/// Compares the given versions using the VersionComparison mode.
/// </summary>
public static int Compare(SimpleVersion version1, SimpleVersion version2, VersionComparison versionComparison)
{
IVersionComparer comparer = new VersionComparer(versionComparison);
return(comparer.Compare(version1, version2));
}
/// <summary>
/// Determines if both versions are equal.
/// </summary>
public bool Equals(SimpleVersion x, SimpleVersion y)
{
return(Compare(x, y) == 0);
}
