public bool TryResolve(IEnumerable <KeyValuePair <string, string> > values, out IAbsoluteDirectoryPath resolvedDirectoryPath,
out string failureMessage)
{
Debug.Assert(values != null);
IReadOnlyList <string> unresolvedVariables;
var status = TryResolve(values, out resolvedDirectoryPath, out unresolvedVariables);
switch (status)
{
default:
Debug.Assert(status == VariablePathResolvingStatus.Success);
failureMessage = null;
return(true);
case VariablePathResolvingStatus.ErrorUnresolvedVariable:
Debug.Assert(unresolvedVariables != null);
Debug.Assert(unresolvedVariables.Count > 0);
failureMessage = VariablePathHelpers.GetUnresolvedVariableFailureReason(unresolvedVariables);
return(false);
case VariablePathResolvingStatus.ErrorVariableResolvedButCannotConvertToAbsolutePath:
failureMessage = GetVariableResolvedButCannotConvertToAbsolutePathFailureReason(values, "directory");
return(false);
}
}
protected VariablePathBase(string pathString) :
base(pathString)
{
Debug.Assert(pathString != null);
Debug.Assert(pathString.Length > 0);
Debug.Assert(pathString.IsNormalized());
Debug.Assert(m_PathString != null);
Debug.Assert(m_PathString.Length > 0);
Debug.Assert(m_PathString.IsNormalized());
// It is important to use m_PathString and not pathString in IsAVariablePath() !
// Indeed, since InnerSpecialDir have been resolved, some variable might have disappeared
// like if pathString was "$(v1)\$(v2)\.." and m_PathString became "$(v1)"
IReadOnlyList <string> variables;
string failureReasonUnused;
var b = VariablePathHelpers.IsAVariablePath(m_PathString, out variables, out failureReasonUnused);
Debug.Assert(b);
Debug.Assert(variables != null);
Debug.Assert(variables.Count > 0);
Debug.Assert(variables.All(v => v != null));
Debug.Assert(variables.All(v => v.Length > 0));
m_Variables = variables;
}
public bool TryResolve(IEnumerable <KeyValuePair <string, string> > variables, out IAbsoluteFilePath resolvedPath, out string failureMessage)
{
Argument.IsNotNull(nameof(variables), variables);
IReadOnlyList <string> unresolvedVariables;
var variablesList = variables as IList <KeyValuePair <string, string> > ?? variables.ToList();
var status = TryResolve(variablesList, out resolvedPath, out unresolvedVariables);
switch (status)
{
default:
//Debug.Assert(status == VariablePathResolvingStatus.Success);
failureMessage = null;
return(true);
case VariablePathResolvingStatus.UnresolvedVariable:
//Debug.Assert(unresolvedVariables != null);
//Debug.Assert(unresolvedVariables.Count > 0);
failureMessage = VariablePathHelpers.GetUnresolvedVariableFailureReason(unresolvedVariables);
return(false);
case VariablePathResolvingStatus.CannotConvertToAbsolutePath:
failureMessage = GetVariableResolvedButCannotConvertToAbsolutePathFailureReason(variablesList, "file");
return(false);
}
}
protected VariablePathBase(string path)
: base(path)
{
//Debug.Assert(path.IsNormalized());
//Debug.Assert(CurrentPath != null);
//Debug.Assert(CurrentPath.Length > 0);
//Debug.Assert(CurrentPath.IsNormalized());
// It is important to use m_PathString and not pathString in IsAVariablePath() !
// Indeed, since InnerSpecialDir have been resolved, some variable might have disappeared
// like if pathString was "$(v1)\$(v2)\.." and m_PathString became "$(v1)"
IReadOnlyList <string> variables;
string failureMessage;
VariablePathHelpers.IsAVariablePath(CurrentPath, out variables, out failureMessage);
//Debug.Assert(b);
//Debug.Assert(variables != null);
//Debug.Assert(variables.Count > 0);
//Debug.Assert(variables.All(v => v != null));
//Debug.Assert(variables.All(v => v.Length > 0));
AllVariables = variables;
}
protected bool TryResolve(IEnumerable <KeyValuePair <string, string> > values, out string pathStringResolved,
out IReadOnlyList <string> unresolvedVariables)
{
Debug.Assert(values != null);
var pathString = m_PathString;
var unresolvedVariablesList = new List <string>();
var nbVariablesToResolve = AllVariables.Count;
Debug.Assert(nbVariablesToResolve > 0);
for (var i = 0; i < nbVariablesToResolve; i++)
{
var variableNameToResolve = AllVariables[i];
Debug.Assert(variableNameToResolve != null);
Debug.Assert(variableNameToResolve.Length > 0);
var resolved = false;
foreach (var pair in values)
{
var pairVariableName = pair.Key;
// Support these two cases!
if (pairVariableName == null)
{
continue;
}
if (pairVariableName.Length == 0)
{
continue;
} //
if (String.Compare(pairVariableName, variableNameToResolve, true) != 0)
{
continue;
} // true for ignore case! variable names are case insensitive
resolved = true;
var variableValue = pair.Value;
if (variableValue == null)
{
// Treat null variableValue as empty string.
variableValue = "";
}
pathString = VariablePathHelpers.ReplaceVariableWithValue(pathString, variableNameToResolve, variableValue);
}
if (!resolved)
{
unresolvedVariablesList.Add(variableNameToResolve);
}
}
if (unresolvedVariablesList.Count > 0)
{
unresolvedVariables = unresolvedVariablesList.ToReadOnlyWrappedList();
pathStringResolved = null;
return(false);
}
unresolvedVariables = null;
pathStringResolved = pathString;
return(true);
}
protected bool TryResolve(IEnumerable <KeyValuePair <string, string> > variables, out string resolvedPath, out IReadOnlyList <string> unresolvedVariables)
{
Argument.IsNotNull(nameof(variables), variables);
var path = CurrentPath;
var unresolvedVariablesList = new List <string>();
var variablesToResolve = AllVariables.Count;
//Debug.Assert(nbVariablesToResolve > 0);
var variablesList = variables as IList <KeyValuePair <string, string> > ?? variables.ToList();
for (var i = 0; i < variablesToResolve; i++)
{
var variableNameToResolve = AllVariables[i];
//Debug.Assert(variableNameToResolve != null);
//Debug.Assert(variableNameToResolve.Length > 0);
var resolved = false;
foreach (var pair in variablesList)
{
var pairVariableName = pair.Key;
// Support these two cases!
if (pairVariableName == null)
{
continue;
}
if (pairVariableName.Length == 0)
{
continue;
} //
if (string.Compare(pairVariableName, variableNameToResolve, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
} // true for ignore case! variable names are case insensitive
resolved = true;
var variableValue = pair.Value ?? string.Empty;
path = VariablePathHelpers.ReplaceVariableWithValue(path, variableNameToResolve, variableValue);
}
if (!resolved)
{
unresolvedVariablesList.Add(variableNameToResolve);
}
}
if (unresolvedVariablesList.Count > 0)
{
unresolvedVariables = unresolvedVariablesList.ToReadOnlyWrappedList();
resolvedPath = null;
return(false);
}
unresolvedVariables = null;
resolvedPath = path;
return(true);
}
