/// <summary>
/// Create a dependency.
/// </summary>
/// <param name="usingItem">The using item.</param>
/// <param name="usedItem">The used item.</param>
/// <param name="source">Name of the file.</param>
/// <param name="markers"></param>
/// <param name="ct"></param>
/// <param name="questionableCt"></param>
/// <param name="badCt"></param>
/// <param name="notOkReason"></param>
/// <param name="exampleInfo"></param>
/// <param name="ignoreCaseDefault"></param>
internal Dependency([NotNull] Item usingItem, [NotNull] Item usedItem,
[CanBeNull] ISourceLocation source, [CanBeNull] IMarkerSet markers,
int ct, int questionableCt = 0, int badCt = 0, string notOkReason = null,
[CanBeNull] string exampleInfo = null, bool?ignoreCaseDefault = null) : base(usingItem, usedItem, source)
{
if (usingItem == null)
{
throw new ArgumentNullException(nameof(usingItem));
}
if (usedItem == null)
{
throw new ArgumentNullException(nameof(usedItem));
}
_ct = ct;
_questionableCt = questionableCt;
_badCt = badCt;
_exampleInfo = exampleInfo;
bool ignoreCase = ignoreCaseDefault ?? usingItem.Type.IgnoreCase | usedItem.Type.IgnoreCase;
_markerSet = new MutableMarkerSet(ignoreCase, markers);
// Make sure that "no reason" is null so that ?? works.
_notOkReason = string.IsNullOrWhiteSpace(notOkReason) ? null : notOkReason;
CheckNotOkReason();
}
private void RecursivelyFlood(Item root, Item from, HashSet <Item> visited, Dictionary <FromTo, Dependency> checkPresence,
DependencyPattern idempotentPattern, Dictionary <Item, Dependency[]> outgoing, IEnumerable <ItemMatch> toItemMatches,
List <DependencyMatch> matches, List <DependencyMatch> excludes, Dictionary <string, int> markersToAddOrNull,
List <Dependency> result, Dependency collectedEdge, [NotNull] Action checkAbort, WorkingGraph workingGraph, bool ignoreCase)
{
if (outgoing.ContainsKey(from))
{
checkAbort();
foreach (var d in outgoing[from].Where(d => d.IsMarkerMatch(matches, excludes)))
{
Item target = d.UsedItem;
if (visited.Add(target))
{
Dependency rootToTarget = collectedEdge == null
? d
: workingGraph.CreateDependency(root, target, d.Source,
new MutableMarkerSet(ignoreCase,
markersToAddOrNull
?? MutableMarkerSet.ConcatOrUnionWithMarkers(collectedEdge.AbstractMarkerSet,
d.AbstractMarkerSet, ignoreCase)),
collectedEdge.Ct + d.Ct, collectedEdge.QuestionableCt + d.QuestionableCt,
collectedEdge.BadCt + d.BadCt, collectedEdge.NotOkReason ?? d.NotOkReason, d.ExampleInfo);
if (IsMatch(toItemMatches, target))
{
Dependency alreadyThere;
var rootTargetKey = new FromTo(root, target);
if (checkPresence.TryGetValue(rootTargetKey, out alreadyThere) && idempotentPattern.IsMatch(alreadyThere))
{
// we do not add a dependency
}
else
{
checkPresence[rootTargetKey] = rootToTarget;
result.Add(rootToTarget);
}
}
// Continue search
RecursivelyFlood(root, target, visited, checkPresence, idempotentPattern, outgoing,
toItemMatches, matches, excludes, markersToAddOrNull, result, rootToTarget,
checkAbort, workingGraph, ignoreCase);
}
}
}
}
public override int Transform([NotNull] GlobalContext globalContext, Ignore Ignore,
[NotNull] TransformOptions transformOptions, [NotNull][ItemNotNull] IEnumerable <Dependency> dependencies,
[NotNull] List <Dependency> transformedDependencies)
{
_transformRunCt++;
MutableMarkerSet.AddComputedMarkerIfNoMarkers(transformOptions.MarkersToAdd,
transformOptions.FromItemMatches, transformOptions.ToItemMatches, "" + _transformRunCt);
WorkingGraph currentWorkingGraph = globalContext.CurrentGraph;
DependencyPattern idempotentPattern = new DependencyPattern("'" + string.Join("+", transformOptions.MarkersToAdd), globalContext.IgnoreCase);
Dictionary <FromTo, Dependency> checkPresence = transformOptions.Idempotent
? FromTo.AggregateAllDependencies(currentWorkingGraph, dependencies)
: new Dictionary <FromTo, Dependency>();
Dictionary <Item, Dependency[]> outgoing = Item.CollectOutgoingDependenciesMap(dependencies);
IEnumerable <Item> matchingFroms = outgoing.Keys.Where(i => IsMatch(transformOptions.FromItemMatches, i));
Dictionary <string, int> markersToAddAsDictionary = transformOptions.MarkersToAdd.Distinct().ToDictionary(s => s, s => 1);
var result = new List <Dependency>();
foreach (var from in matchingFroms)
{
RecursivelyFlood(from, from, new HashSet <Item> {
from
}, checkPresence, idempotentPattern, outgoing,
transformOptions.ToItemMatches, transformOptions.Matches, transformOptions.Excludes,
markersToAddAsDictionary, result, null, globalContext.CheckAbort,
currentWorkingGraph, globalContext.IgnoreCase);
}
transformedDependencies.AddRange(dependencies);
transformedDependencies.AddRange(result);
Log.WriteInfo($"... added {result.Count} new dependencies");
return(Program.OK_RESULT);
}
protected internal Item([NotNull] ItemType type, string[] values) : base(type, values)
{
_markerSet = new MutableMarkerSet(type.IgnoreCase, markers: null);
}
