public static bool Equals(Path first, Path second, PathComparison comparison = PathComparison.Default)
{
if (ReferenceEquals(first, null) && ReferenceEquals(second, null))
{
return(true);
}
if (ReferenceEquals(first, null) || ReferenceEquals(second, null))
{
return(false);
}
return(first.Equals(second, comparison));
}
/// <summary>Vergleicht das aktuelle Objekt mit einem anderen Objekt desselben Typs.</summary>
/// <returns>Ein Wert, der die relative Reihenfolge der verglichenen Objekte angibt. Der Rückgabewert hat folgende Bedeutung: Wert Bedeutung Kleiner als 0 Dieses Objekt ist kleiner als der <paramref name="other" />-Parameter. Zero Dieses Objekt ist gleich <paramref name="other" />. Größer als 0 (null) Dieses Objekt ist größer als <paramref name="other" />.</returns>
/// <param name="other">Ein Objekt, das mit diesem Objekt verglichen werden soll.</param>
/// <param name="comparisonType">Art des Stringvergleiches</param>
public int CompareTo(Path other, PathComparison comparisonType)
{
StringComparison stringComparison = comparisonType.ConvertToStringComparison().OrDefault(DefaultComparison);
for (var i = 0; i < m_parts.Count && i < other.m_parts.Count; i++)
{
int result = string.Compare(m_parts[i], other.m_parts[i], stringComparison);
if (result != 0)
{
return(result);
}
}
return(m_parts.Count.CompareTo(other.m_parts.Count));
}
public static int CompareTo(Path first, Path second, PathComparison comparison = PathComparison.Default)
{
if (ReferenceEquals(first, null) && ReferenceEquals(second, null))
{
return(0);
}
if (ReferenceEquals(first, null))
{
return(-1);
}
if (ReferenceEquals(second, null))
{
return(1);
}
return(first.CompareTo(second, comparison));
}
public bool StartsWith(Path start, PathComparison comparison = PathComparison.Default)
{
if (start.Count > Count)
{
return(false);
}
StringComparison stringComparison = comparison.ConvertToStringComparison().OrDefault(DefaultComparison);
for (var i = 0; i < start.Count; i++)
{
if (!string.Equals(this[i], start[i], stringComparison))
{
return(false);
}
}
return(true);
}
public StringComparisonConvertable(PathComparison pc)
{
m_pc = pc;
}
public static Convertable <StringComparison> ConvertToStringComparison(this PathComparison pc) => new StringComparisonConvertable(pc);
/// <summary>Gibt an, ob das aktuelle Objekt gleich einem anderen Objekt des gleichen Typs ist.</summary>
/// <returns>true, wenn das aktuelle Objekt gleich dem <paramref name="other" />-Parameter ist, andernfalls false.</returns>
/// <param name="other">Ein Objekt, das mit diesem Objekt verglichen werden soll.</param>
/// <param name="comparisonType">Art des Stringvergleiches</param>
public bool Equals(Path other, PathComparison comparisonType)
{
return(CompareTo(other, comparisonType) == 0);
}
public Path RemoveStart(Path remove, PathComparison comparison = PathComparison.Default)
{
return(ReplaceFromStart(remove, Empty(Separator, DefaultComparison), comparison));
}
public int IndexOf(string item, int index = 0, PathComparison comparison = PathComparison.Default)
{
StringComparison stringComparison = comparison.ConvertToStringComparison().OrDefault(DefaultComparison);
return(m_parts.FindIndex(index, part => string.Equals(part, item, stringComparison)));
}
public Path ReplaceFromStart(string search, string replace, PathComparison comparison = PathComparison.Default)
{
return(Replace(search, replace, comparison, 0));
}
public Path Replace([NotNull] string search, [NotNull] string replace, PathComparison comparison = PathComparison.Default, int maxStartIndex = int.MaxValue)
{
return(Replace(new Path(search, Separator), new Path(replace, Separator), comparison, maxStartIndex));
}
public Path Replace([NotNull] Path search, [NotNull] Path replace, PathComparison comparison = PathComparison.Default, int maxStartIndex = int.MaxValue)
{
if (search == null)
{
throw new ArgumentNullException(nameof(search));
}
if (replace == null)
{
throw new ArgumentNullException(nameof(replace));
}
if (Count < search.Count)
{
return(this);
}
int startIndex = IndexOf(search.m_parts[0], 0, comparison);
if (startIndex > maxStartIndex)
{
return(this);
}
if (startIndex < 0)
{
return(this);
}
if (Count + startIndex < search.Count)
{
return(this);
}
StringComparison stringComparison = comparison.ConvertToStringComparison().OrDefault(DefaultComparison);
while (startIndex > -1)
{
bool equal = true;
for (var i = 0; i + startIndex < m_parts.Count && i < search.m_parts.Count; i++)
{
if (!string.Equals(m_parts[i + startIndex], search.m_parts[i], stringComparison))
{
startIndex = IndexOf(search.m_parts[0], i + startIndex + 1);
if (startIndex > maxStartIndex)
{
return(this);
}
equal = false;
break;
}
}
if (equal)
{
break;
}
}
if (startIndex == -1)
{
return(this);
}
return(new Path(this.Take(startIndex).Concat(replace).Concat(this.Skip(startIndex + search.Count)), Separator, DefaultComparison));
}
/// <summary>Vergleicht das aktuelle Objekt mit einem anderen Objekt desselben Typs.</summary>
/// <returns>Ein Wert, der die relative Reihenfolge der verglichenen Objekte angibt. Der Rückgabewert hat folgende Bedeutung: Wert Bedeutung Kleiner als 0 Dieses Objekt ist kleiner als der <paramref name="other" />-Parameter. Zero Dieses Objekt ist gleich <paramref name="other" />. Größer als 0 (null) Dieses Objekt ist größer als <paramref name="other" />.</returns>
/// <param name="other">Ein Objekt, das mit diesem Objekt verglichen werden soll.</param>
/// <param name="comparisonType">Art des Stringvergleiches</param>
public int CompareTo(string other, PathComparison comparisonType)
{
return(CompareTo(new Path(other, Separator), comparisonType));
}
