private void UpdateAtomicCompositionQueryForPartEquals(
AtomicComposition atomicComposition,
ComposablePartDefinition part,
AtomicCompositionQueryState state)
{
PartQueryStateNode previousNode = GetPartQueryStateNode(atomicComposition);
atomicComposition.SetValue(this, new PartEqualsQueryStateNode(part, previousNode, state));
}
private void UpdateAtomicCompositionQueryForPartInHashSet(
AtomicComposition atomicComposition,
HashSet <ComposablePartDefinition> hashset,
AtomicCompositionQueryState state)
{
PartQueryStateNode previousNode = GetPartQueryStateNode(atomicComposition);
atomicComposition.SetValue(this, new PartInHashSetQueryStateNode(hashset, previousNode, state));
}
private bool IsRejected(ComposablePartDefinition definition, AtomicComposition?atomicComposition)
{
// Check to see if we're currently working on the definition in question.
// Recursive queries always answer optimistically, as if the definition hasn't
// been rejected - because if it is we can discard all decisions that were based
// on the faulty assumption in the first place.
var forceRejectionTest = false;
if (atomicComposition != null)
{
AtomicCompositionQueryState state = QueryPartState(atomicComposition, definition);
switch (state)
{
case AtomicCompositionQueryState.TreatAsRejected:
return(true);
case AtomicCompositionQueryState.TreatAsValidated:
return(false);
case AtomicCompositionQueryState.NeedsTesting:
forceRejectionTest = true;
break;
default:
if (state != AtomicCompositionQueryState.Unknown)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
// Need to do the work to determine the state
break;
}
}
if (!forceRejectionTest)
{
// Next, anything that has been activated is not rejected
using (_lock.LockStateForRead())
{
if (_activatedParts.ContainsKey(definition))
{
return(false);
}
// Last stop before doing the hard work: check a specific registry of rejected parts
if (_rejectedParts.Contains(definition))
{
return(true);
}
}
}
// Determine whether or not the definition's imports can be satisfied
return(DetermineRejection(definition, atomicComposition));
}
private void UpdateAtomicCompositionQuery(
AtomicComposition atomicComposition,
Func <ComposablePartDefinition, bool> query,
AtomicCompositionQueryState state)
{
var parentQuery = GetAtomicCompositionQuery(atomicComposition);
Func <ComposablePartDefinition, AtomicCompositionQueryState> newQuery = definition =>
{
if (query(definition))
{
return(state);
}
return(parentQuery(definition));
};
atomicComposition.SetValue(this, newQuery);
}
private void UpdateAtomicCompositionQuery(
AtomicComposition atomicComposition,
Func <ComposablePartDefinition, bool> query,
AtomicCompositionQueryState state)
{
var parentQuery = GetAtomicCompositionQuery(atomicComposition);
Func <ComposablePartDefinition, AtomicCompositionQueryState> newQuery = definition =>
{
if (query(definition))
{
if (state == AtomicCompositionQueryState.TreatAsValidated)
{
// Graph is in a cycle
atomicComposition.CompositionInCycle = true;
}
return(state);
}
return(parentQuery(definition));
};
atomicComposition.SetValue(this, newQuery);
}
protected PartQueryStateNode(PartQueryStateNode previousNode, AtomicCompositionQueryState state)
{
_previousNode = previousNode;
_state = state;
}
public PartInHashSetQueryStateNode(HashSet <ComposablePartDefinition> parts, PartQueryStateNode previousNode, AtomicCompositionQueryState state) :
base(previousNode, state)
{
_parts = parts;
}
public PartEqualsQueryStateNode(ComposablePartDefinition part, PartQueryStateNode previousNode, AtomicCompositionQueryState state) :
base(previousNode, state)
{
_part = part;
_hashCode = part.GetHashCode();
}
