private void ResolveVariables(int errorIndex)
{
bool resolveAgain = false;
for (int i = LinkedVariables.Count - 1; i >= 0; ++i)
{
var tuple = LinkedVariables[i];
if (UsedVariables.ContainsKey(tuple.Item1))
{
LinkVariable(errorIndex, tuple.Item2, UsedVariables[tuple.Item1]);
LinkedVariables.RemoveAt(i);
resolveAgain = true;
}
else if (UsedVariables.ContainsKey(tuple.Item2))
{
LinkVariable(errorIndex, tuple.Item1, UsedVariables[tuple.Item2]);
LinkedVariables.RemoveAt(i);
resolveAgain = true;
}
}
if (resolveAgain)
{
ResolveVariables(errorIndex);
}
}
public void Clear()
{
_schema = null;
Path.Clear();
Fragments.Clear();
UsedVariables.Clear();
UnusedVariables.Clear();
DeclaredVariables.Clear();
Errors.Clear();
}
private bool ContainsOppositeLiteral()
{
foreach (var literal in UsedVariables)
{
if (UsedVariables.Contains(literal.GetOppositeLiteral()))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Retourne la liste des variables inutilisées mais déclarées
/// Ignore dans la réponse les variables rattachées à des collections, car potentiellement usitées par d'autres projets
/// </summary>
/// <param name="environment">Le nom de l'environnement</param>
/// <returns>La liste des noms de variables inutilisées</returns>
public List <string> GetUnusedVariabledForEnvironment(string environment)
{
if (!DeclaredVariablesByEnvironment.Keys.Contains(environment))
{
return(new List <string>());
}
return(DeclaredVariablesByEnvironment[environment]
.Where(v => v.Origin.Equals(VarOrigin.AppVar))
.Where(v => !UsedVariables.Any(uv => uv.Name.Equals(v.Name)))
.Select(v => v.Name)
.ToList());
}
public void LinkVariable(int errorIndex, string id, Engine.ValueType type)
{
if (UsedVariables.ContainsKey(id) && UsedVariables[id] != type)
{
throw new ReasonException(errorIndex,
"we are trying to use the variable \"" + id +
"\" as a " + type + ", but it has already been " +
"used as a " + UsedVariables[id] + "!"
);
}
UsedVariables[id] = type;
ResolveVariables(errorIndex);
}
public void AddToUsedVar(string matchValue, VarUsage usage, string context = null)
{
var varName = Regex.Replace(matchValue, varPattern, "$1");
if (UsedVariables.Any(v => v.Name.Equals(varName)))
{
var variable = UsedVariables.Single(v => v.Name.Equals(varName));
variable.Usage = variable.Usage & usage;
variable.Context.Add(context);
}
else
{
UsedVariables.Add(new ProcessVar(varName, usage, context));
}
}
public void Clear()
{
_schema = null;
Path.Clear();
Variables.Clear();
Fragments.Clear();
UsedVariables.Clear();
UnusedVariables.Clear();
DeclaredVariables.Clear();
Names.Clear();
Types.Clear();
Directives.Clear();
OutputFields.Clear();
InputFields.Clear();
Errors.Clear();
IsInError = false;
}
/// <summary>
/// Retourne la liste des variables utilisées et non déclarées.
/// Les variables propres à Octopus sont ignorées (variables systèmes)
/// </summary>
/// <param name="environment">Le nom de l'environnement</param>
/// <returns>La liste des variables dont la définition manque</returns>
public List <ProcessVar> GetMissingVariablesForEnvironment(string environment)
{
var result = new List <ProcessVar>();
if (DeclaredVariablesByEnvironment.Keys.Contains(environment))
{
result = UsedVariables
.Where(uv => !DeclaredVariablesByEnvironment[environment].Any(ev => ev.Name.Equals(uv.Name)) && !uv.Name.StartsWith("Octopus."))
.Where(uv => uv.Usage != VarUsage.AppSettings) // Les AppSettings ne sont pas forcément à remplacer.
.ToList();
}
else
{
result = UsedVariables.ToList();
}
return(result);
}
internal void AddLiteral(Literal literal)
{
UsedVariables.Add(literal);
}