/// <summary>
/// Determines if a path segment contains a Windows directory separator.
/// </summary>
public static bool ContainsMixedDirectorySeparator(string pathSegment)
{
var output = DirectorySeparatorGood.ContainsWindowsDirectorySeparator(pathSegment) &&
DirectorySeparatorGood.ContainsNonWindowsDirectorySeparator(pathSegment);
return(output);
}
/// <summary>
/// Between the Windows ('\') and the non-Windows ('/') directory separator, given one, return the other.
/// Checked - Validates the directory separator first.
/// </summary>
public static string GetAlternateDirectorySeparator(string directorySeparator)
{
DirectorySeparatorGood.Validate(directorySeparator);
var alternateDirectorySeparator = DirectorySeparatorGood.GetAlternateDirectorySeparatorUnchecked(directorySeparator);
return(alternateDirectorySeparator);
}
/// <summary>
/// Determines if the specified directory separator is detected for the path segment.
/// The input directory separator is validated.
/// </summary>
public static bool IsDirectorySeparatorDetected(string pathSegment, string directorySeparator)
{
DirectorySeparatorGood.Validate(directorySeparator);
var isDetected = DirectorySeparatorGood.IsDirectorySeparatorDetectedUnchecked(pathSegment, directorySeparator);
return(isDetected);
}
/// <summary>
/// Determine if the non-Windows directory separator is detected in a path segment, but if no directory separator is detected, assume the non-Windows directory separator was detected (return true).
/// </summary>
public static bool IsNonWindowsDirectorySeparatorDetectedAssumeNonWindows(string pathSegment)
{
var directorySeparator = DirectorySeparatorGood.DetectDirectorySeparatorOrDefaultNonWindows(pathSegment);
var isNonWindows = DirectorySeparatorGood.IsNonWindowsDirectorySeparator(directorySeparator);
return(isNonWindows);
}
/// <summary>
/// Checks that the specified directory separator argument is actually a directory separator, and throws an exception if it is not.
/// </summary>
/// <exception cref="ArgumentException">Thrown if the <paramref name="directorySeparator"/> is not a valid directory separator according to <see cref="DirectorySeparatorGood.IsValid(string)"/>.</exception>
public static void Validate(string directorySeparator, string argumentName)
{
if (!DirectorySeparatorGood.IsValid(directorySeparator))
{
var exception = DirectorySeparatorGood.GetInvalidDirectorySeparatorValueArgumentException(directorySeparator, argumentName);
throw exception;
}
}
/// <summary>
/// Determines if a path segment contains a specified directory separator.
/// Detecting the use of a directory-separator by a path-segment requires an extra step beyond just determining if the path-segment contains the directory-separator.
/// A path-segment can contain both Windows and non-Windows directory-separators, in which case the first directory-separator is the detected directory-separator because it is dominant.
/// Validation is performed on the directory separator.
/// </summary>
public static bool ContainsDirectorySeparator(string pathSegment, string directorySeparator)
{
DirectorySeparatorGood.Validate(directorySeparator);
var output = DirectorySeparatorGood.ContainsDirectorySeparatorUnchecked(pathSegment, directorySeparator);
return(output);
}
public static Exception GetInvalidDirectorySeparatorValueException(string found)
{
var message = DirectorySeparatorGood.GetInvalidDirectorySeparatorValueExceptionMessage(found);
var exception = new Exception(message);
return(exception);
}
public static ArgumentException GetNonWindowsDirectorySeparatorValueExpectedArgumentException(string found, string parameterName)
{
var message = DirectorySeparatorGood.GetNonWindowsDirectorySeparatorValueExpectedExceptionMessage(found);
var exception = new ArgumentException(message, parameterName);
return(exception);
}
public static Exception GetNonWindowsDirectorySeparatorValueExpectedException(string notNonWindowsDirectorySeparator)
{
var message = DirectorySeparatorGood.GetNonWindowsDirectorySeparatorValueExpectedExceptionMessage(notNonWindowsDirectorySeparator);
var exception = new Exception(message);
return(exception);
}
/// <summary>
/// Checks that the specified directory separator is actually a directory separator, and throws an exception if it is not.
/// </summary>
/// <exception cref="Exception">Thrown if the <paramref name="directorySeparator"/> is not a valid directory separator according to <see cref="DirectorySeparatorGood.IsValid(string)"/>.</exception>
public static void Validate(string directorySeparator)
{
var isValid = DirectorySeparatorGood.IsValid(directorySeparator);
if (!isValid)
{
var exception = DirectorySeparatorGood.GetInvalidDirectorySeparatorValueException(directorySeparator);
throw exception;
}
}
/// <summary>
/// Detects the directory separator used in a path segment.
/// If no directory separator can be detected, throws an exception.
/// </summary>
/// <exception cref="Exception">Thrown when a path segment a directory separator cannot be detected (i.e. contains no directory separators).</exception>
public static string DetectDirectorySeparator(string pathSegment)
{
var detectionSuccess = DirectorySeparatorGood.TryDetectDirectorySeparator(pathSegment, out var directorySeparator);
if (!detectionSuccess)
{
throw new Exception($@"Unable to detect platform for path '{pathSegment}'.");
}
return(directorySeparator);
}
public static void ValidateWindows(string windowsDirectorySeparator)
{
DirectorySeparatorGood.Validate(windowsDirectorySeparator);
var isWindows = DirectorySeparatorGood.IsWindowsDirectorySeparator(windowsDirectorySeparator);
if (!isWindows)
{
var exception = DirectorySeparatorGood.GetWindowsDirectorySeparatorValueExpectedException(windowsDirectorySeparator);
throw exception;
}
}
/// <summary>
/// Determines if the specified directory separator is detected for the path segment.
/// Unchecked - No validation is performed on the input directory separator.
/// </summary>
public static bool IsDirectorySeparatorDetectedUnchecked(string pathSegment, string directorySeparator)
{
var isAnySeparatorDetected = DirectorySeparatorGood.TryDetectDirectorySeparatorOrInvalid(pathSegment, out var outDirectorySeparator);
if (isAnySeparatorDetected)
{
var isDetected = directorySeparator == outDirectorySeparator;
return(isDetected);
}
return(false);
}
public static void ValidateNonWindows(string nonWindowsDirectorySeparator, string argumentName)
{
DirectorySeparatorGood.Validate(nonWindowsDirectorySeparator);
var isWindows = DirectorySeparatorGood.IsNonWindowsDirectorySeparator(nonWindowsDirectorySeparator);
if (!isWindows)
{
var exception = DirectorySeparatorGood.GetNonWindowsDirectorySeparatorValueExpectedArgumentException(nonWindowsDirectorySeparator, argumentName);
throw exception;
}
}
/// <summary>
/// Determines if a string is a valid directory separator.
/// Checks that specified directory separator is not the <see cref="DirectorySeparatorGood.InvalidValue"/>, then if it is one of the Windows of non-Windows directory separators.
/// </summary>
public static bool IsValid(string directorySeparator)
{
var isInvalid = DirectorySeparatorGood.IsInvalid(directorySeparator);
if (isInvalid)
{
return(false);
}
var output = DirectorySeparatorGood.IsDirectorySeparator(directorySeparator);
return(output);
}
/// <summary>
/// Between the Windows ('\') and the non-Windows ('/') directory separator, given one, return the other.
/// Unchecked - If the input directory separator is neither the Windows nor non-Windows separator, the Windows separator is returned.
/// </summary>
public static string GetAlternateDirectorySeparatorUnchecked(string directorySeparator)
{
var isWindows = DirectorySeparatorGood.IsWindowsDirectorySeparator(directorySeparator);
if (isWindows)
{
return(DirectorySeparatorGood.NonWindowsValue);
}
else
{
return(DirectorySeparatorGood.WindowsValue);
}
}
/// <summary>
/// Determines if the specified value equals the specified directory-separator, and if the specified directory separator is actually a directory separator.
/// </summary>
public static bool IsDirectorySeparator(char value, char possibleDirectorySeparator)
{
var areEqual = value == possibleDirectorySeparator;
if (!areEqual)
{
return(false);
}
var isDirectorySeparator = DirectorySeparatorGood.IsDirectorySeparator(possibleDirectorySeparator);
if (!isDirectorySeparator)
{
return(false);
}
return(true);
}
/// <summary>
/// Determines if a character is a valid directory-separator.
/// Since there is no invalid directory separator character, this is identical to whether the specified character is one of the Windows of non-Windows directory separators.
/// </summary>
public static bool IsValid(char directorySeparator)
{
var isValid = DirectorySeparatorGood.IsDirectorySeparator(directorySeparator);
return(isValid);
}
/// <summary>
/// Determines if a path segment contains a Windows directory separator.
/// </summary>
public static bool ContainsNonWindowsDirectorySeparator(string pathSegment)
{
var output = DirectorySeparatorGood.ContainsDirectorySeparatorUnchecked(pathSegment, DirectorySeparatorGood.NonWindowsValue);
return(output);
}
/// <summary>
/// Determine if the non-Windows directory separator is detected in a path segment.
/// </summary>
public static bool IsNonWindowsDirectorySeparatorDetected(string pathSegment)
{
var isNonWindows = DirectorySeparatorGood.IsDirectorySeparatorDetectedUnchecked(pathSegment, DirectorySeparatorGood.NonWindowsValue);
return(isNonWindows);
}
/// <summary>
/// Determines if any directory separator can be detected for a path segment.
/// </summary>
public static bool IsDirectorySeparatorDetected(string pathSegment)
{
var isAnySeparatorDetected = DirectorySeparatorGood.TryDetectDirectorySeparatorOrInvalid(pathSegment, out var _);
return(isAnySeparatorDetected);
}
/// <summary>
/// Detects the directory separator used in a path segment, or if no directory separator can be detected, defaults to the non-Windows value.
/// </summary>
public static string DetectDirectorySeparatorOrDefaultNonWindows(string pathSegment)
{
var directorySeparator = DirectorySeparatorGood.DetectDirectorySeparatorOrDefault(pathSegment, DirectorySeparatorGood.NonWindowsValue);
return(directorySeparator);
}
public static bool IsNonWindowsDirectorySeparator(string directorySeparator)
{
var isWindows = DirectorySeparatorGood.IsDirectorySeparator(directorySeparator, DirectorySeparatorGood.NonWindowsValue);
return(isWindows);
}
/// <summary>
/// Attempts to detect the directory separator (Windows or non-Windows) used within a path segment.
/// Returns true if a directory separator can be detected, false otherwise.
/// If no directory separator is detected, the output <paramref name="directorySeparator"/> is set to the <see cref="DirectorySeparatorGood.InvalidValue"/>.
/// </summary>
public static bool TryDetectDirectorySeparatorOrInvalid(string pathSegment, out string directorySeparator)
{
var output = DirectorySeparatorGood.TryDetectDirectorySeparator(pathSegment, out directorySeparator, DirectorySeparatorGood.InvalidValue);
return(output);
}
/// <summary>
/// Attempts to detect the directory separator (Windows or non-Windows) used within a path segment, setting the output <paramref name="directorySeparator"/> to the <see cref="DirectorySeparatorGood.DefaultValue"/> if no directory separator can be detected.
/// Returns true if a directory separator can be detected, false otherwise.
/// </summary>
public static bool TryDetectDirectorySeparator(string pathSegment, out string directorySeparator)
{
var output = DirectorySeparatorGood.TryDetectDirectorySeparatorOrDefault(pathSegment, out directorySeparator);
return(output);
}
/// <summary>
/// Detects the directory separator used in a path segment.
/// If a directory separator cannot be detected (for example, if the path segment is a file-name, or the un-directory-indicated relative path between parent a child directory, which is just the directory name), return the specified default.
/// </summary>
public static string DetectDirectorySeparatorOrDefault(string pathSegment, string defaultDirectorySeparator)
{
DirectorySeparatorGood.TryDetectDirectorySeparator(pathSegment, out var directorySeparator, defaultDirectorySeparator);
return(directorySeparator);
}
public static bool IsWindowsDirectorySeparator(char directorySeparator)
{
var isWindows = DirectorySeparatorGood.IsDirectorySeparator(directorySeparator, DirectorySeparatorGood.WindowsValueChar);
return(isWindows);
}