/// <summary>
/// Resets this node to contain no dependees and removes this as a dependent from all dependees
/// </summary>
public void clearDependees()
{
// Unlink this as a dependents of its dependee
foreach (DependencyNode dependee in Dependees)
{
dependee.RemoveDependent(this);
}
Dependees.Clear();
}
/// <summary>
/// Removes all existing ordered pairs of the form (r,s). Then, for each
/// t in newDependees, adds the ordered pair (t,s).
/// </summary>
public void ReplaceDependees(string s, IEnumerable <string> newDependees)
{
if (Dependees.ContainsKey(s))
{
foreach (var entry in Dependencies)
{
Dependencies[entry.Key].Remove(s); // Remove self from dependencies. //
}
Dependees[s].Clear();
}
foreach (var dependee in newDependees)
{
if (!Dependees.ContainsKey(s))
{
Dependees.Add(s, new List <string>());
}
Dependees[s].Add(dependee);
}
}
/// <summary>
/// <para>Adds the ordered pair (s,t), if it doesn't exist</para>
///
/// <para>This should be thought of as:</para>
///
/// s depends on t
///
/// </summary>
/// <param name="s"> s cannot be evaluated until t is</param>
/// <param name="t"> t must be evaluated first. S depends on T</param>
public void AddDependency(string s, string t)
{
if (!Dependencies.ContainsKey(s))
{
Dependencies.Add(s, new List <string>());
}
if (Dependencies[s].Contains(t))
{
return;
}
Dependencies[s].Add(t);
if (!Dependees.ContainsKey(t))
{
Dependees.Add(t, new List <string>());
}
Dependees[t].Add(s);
}
/// <summary>
/// Removes dependee from this
/// </summary>
/// <param name="dependee">The node to be removed from the Dependees.</param>
/// <returns>True if the node was successfully removed from the set, false otherwise.</returns>
public bool RemoveDependee(DependencyNode dependee)
{
return(Dependees.Remove(dependee));
}
/// <summary>
/// Adds dependee to this
/// </summary>
/// <param name="dependee">The node to be added.</param>
/// <returns>True if the node was successfully added, false otherwise.</returns>
public bool AddDependee(DependencyNode dependee)
{
// HashSet does not allow duplicates.
return(Dependees.Add(dependee));
}
/// <summary>
/// Enumerates dependees(s).
/// </summary>
public IEnumerable <string> GetDependees(string s)
{
return(Dependees.ContainsKey(s) ? Dependees[s] : Enumerable.Empty <string>());
}
