private static void ValidateReordering(List<INode> chain1, List<INode> chain2, int closestParentIndex, IDiagInfo diagInfo)
{
var invalidNode1 = GetInvalidNode(chain1, closestParentIndex);
var invalidNode2 = GetInvalidNode(chain2, closestParentIndex);
if (invalidNode1 == null && invalidNode2 == null)
{
return;
}
var fixNode1 = invalidNode1 ?? chain1.Last();
var fixNode2 = invalidNode2 ?? chain2.Last();
var exceptionMessage = $"There is an uncertainty between {chain1.Last()} (a) and {chain2.Last()} (b)" + Environment.NewLine +
$"{GetInvalidateString("a", chain1.Last(), invalidNode1)}{GetInvalidateString("b", chain2.Last(), invalidNode2)}" +
$"To deal with this uncertainty, you can either make {fixNode1} depend on {chain2.Last()} or {fixNode2} depend on {chain1.Last()}";
var tuples = new List<Tuple<IToken, IDiagInfo>>
{
GetNodeTuple(fixNode1),
GetNodeTuple(chain1.Last()),
GetNodeTuple(fixNode2),
GetNodeTuple(chain2.Last())
};
throw new DetailedRegistrationException(exceptionMessage, tuples, diagInfo);
}
public static void CreateNonEqualFilter(this TreeContext context,
INode node1,
INode node2,
IFilterGroup parentGroup,
IDiagInfo diagInfo)
{
if (node1.Token.Type != node2.Token.Type)
{
return;
}
var tuple = new Tuple<IToken, IToken>(node1.Token, node2.Token);
var reverseTuple = new Tuple<IToken, IToken>(node2.Token, node1.Token);
if (context.NonEqualFilters.Contains(tuple) || context.NonEqualFilters.Contains(reverseTuple))
{
return;
}
context.NonEqualFilters.Add(tuple);
var dep1 = new SingleDependency(node1.Token);
var dep2 = new SingleDependency(node2.Token);
var newInfo = new FilterInfo(context.Store.NextId, diagInfo, parentGroup?.FilterInfo.FilterToken);
var filter = new Filter2<IResolutionContext, IResolutionContext>(dep1, dep2, (x, y) => !x.Equals(y), newInfo);
context.Filters.Add(filter);
}
public FilterInfo(int id, IDiagInfo diagInfo = null,
IFilterToken parentGroupToken = null,
int priority = TestingContext.DefaultPriority)
{
FilterToken = new FilterToken();
ParentGroupToken = parentGroupToken;
Priority = priority;
DiagInfo = diagInfo;
Id = id;
}
public GroupProvider(IEnumerable<IDependency> dependencies,
IFilterGroup group,
TokenStore store,
IDiagInfo diagInfo)
{
Dependencies = dependencies;
DiagInfo = diagInfo;
this.group = group;
this.store = store;
}
private static void ReorderNodes(INode node1, INode node2, IDiagInfo diagInfo)
{
if (node1.IsChildOf(node2) || node2.IsChildOf(node1))
{
return;
}
var chain1 = node1.GetParentalChain();
var chain2 = node2.GetParentalChain();
var closestParentIndex = FindClosestParent(chain1, chain2);
ValidateReordering(chain1, chain2, closestParentIndex, diagInfo);
if (GetBranchWeight(chain1, closestParentIndex) >= GetBranchWeight(chain2, closestParentIndex))
{
var firstChild2 = chain2[closestParentIndex + 1];
firstChild2.Parent = node1;
}
else
{
var firstChild1 = chain1[closestParentIndex + 1];
firstChild1.Parent = node2;
}
}
public void Exists <T>(IDiagInfo diagInfo, string name, Func <IEnumerable <T> > srcFunc) => store.SaveToken(diagInfo, name, inner.Exists(diagInfo, srcFunc).Token);
public IHaveToken <T> Exists <T>(IDiagInfo diagInfo, Func <IEnumerable <T> > srcFunc) => inner.Exists(diagInfo, srcFunc);
public RegistrationException(string message, IDiagInfo diag = null, Exception inner = null) : base(message + Environment.NewLine + "Diagnostics: " + diag, inner)
{
Diag = diag;
}
public void Each <T2>(IDiagInfo diagInfo, string name, Func <T1, IEnumerable <T2> > srcFunc) => store.SaveToken(diagInfo, name, Inner.Declare(diagInfo, srcFunc).Each(diagInfo).Token);
public void DoesNotExist <T2>(IDiagInfo diagInfo, string name, Func <T1, IEnumerable <T2> > srcFunc) => store.SaveToken(diagInfo, name, Inner.Declare(diagInfo, srcFunc).DoesNotExist(diagInfo).Token);
public void Exists <T>(IDiagInfo diagInfo, string name, Func <IEnumerable <T> > srcFunc) => reg.Exists(diagInfo, name, srcFunc);
public IHaveToken <T2> DoesNotExist <T2>(IDiagInfo diagInfo, Func <T1, IEnumerable <T2> > srcFunc) => Inner.Declare(diagInfo, srcFunc).DoesNotExist(diagInfo);
public IFilterToken IsTrue(IDiagInfo diagInfo, Func <T1, bool> filter) => Inner.IsTrue(diagInfo, filter);
public void Exists <T3>(IDiagInfo diagInfo, string name, Func <T1, T2, IEnumerable <T3> > srcFunc) => store.SaveToken(diagInfo, name, inner.Declare(diagInfo, srcFunc).Exists(diagInfo).Token);
public IHaveToken <T3> Exists <T3>(IDiagInfo diagInfo, Func <T1, T2, IEnumerable <T3> > srcFunc) => inner.Declare(diagInfo, srcFunc).Exists(diagInfo);
public DetailedRegistrationException(string message, List<Tuple<IToken, IDiagInfo>> detailedDiagnostics, IDiagInfo diagInfo = null)
: base(message, diagInfo)
{
DetailedDiagnostics = detailedDiagnostics;
}
public IHaveToken <T2> Each <T2>(IDiagInfo diagInfo, Func <T1, IEnumerable <T2> > srcFunc) => Inner.Declare(diagInfo, srcFunc).Each(diagInfo);
public DetailedRegistrationException(string message, List <Tuple <IToken, IDiagInfo> > detailedDiagnostics, IDiagInfo diagInfo = null)
: base(message, diagInfo)
{
DetailedDiagnostics = detailedDiagnostics;
}
