private IGrouping <int, MethodDefinition> ChooseCandidateGroup(
IEnumerable <IGrouping <int, MethodDefinition> > candidatesByInheritanceOffset,
MethodInfo interfaceMethod,
RequirementDefinitionBase requirement)
{
try
{
return(candidatesByInheritanceOffset.OrderBy(group => group.Key).First()); // take the group with the lowest distance from the target class
}
catch (InvalidOperationException)
{
string requiringEntityString = requirement.GetRequiringEntityDescription();
// In practice, every requirement should know its requiring entities. However, this is not enforced, so provide a fallback...
if (string.IsNullOrEmpty(requiringEntityString))
{
requiringEntityString = "<unknown>";
}
string message = string.Format(
"The dependency '{0}' (required by {1} on class '{2}') is not fulfilled - public or protected method '{3}' could not be "
+ "found on the target class.",
requirement.Type.Name,
requiringEntityString,
requirement.TargetClass,
interfaceMethod);
throw new ConfigurationException(message);
}
}
private void CheckSomeRequiringMixin(RequirementDefinitionBase requirement, MixinDefinition expectedRequiringMixin)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
ArgumentUtility.CheckNotNull("expectedRequiringMixin", expectedRequiringMixin);
var requirers = requirement.GetRequiringEntityDescription().Split(new[] { ", " }, StringSplitOptions.None);
Assert.That(requirers, Has.Member("mixin '" + expectedRequiringMixin.FullName + "'"));
}
private void CheckSomeRequiringComposedInterface(RequirementDefinitionBase requirement, Type expectedRequiringComposedInterface)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
ArgumentUtility.CheckNotNull("expectedRequiringComposedInterface", expectedRequiringComposedInterface);
var requirers = requirement.GetRequiringEntityDescription().Split(new[] { ", " }, StringSplitOptions.None);
Assert.That(requirers, Has.Member("composed interface '" + expectedRequiringComposedInterface.FullName + "'"));
}
private MethodDefinition FindMethod(MethodInfo interfaceMethod, RequirementDefinitionBase requirement)
{
var candidatesByInheritanceOffset = from candidate in _allTargetMethodsByName[interfaceMethod.Name]
where s_signatureComparer.Equals(candidate.MethodInfo, interfaceMethod)
let offset = GetInheritanceOffset(candidate.MethodInfo.DeclaringType)
group candidate by offset;
IGrouping <int, MethodDefinition> candidateGroup = ChooseCandidateGroup(candidatesByInheritanceOffset, interfaceMethod, requirement);
// Unless the signature comparer is broken, each group can only hold one match.
return(candidateGroup.Single());
}
public void Apply(RequirementDefinitionBase requirement)
{
if (requirement.IsEmptyInterface || !requirement.Type.IsInterface)
{
return;
}
var methodCollector = GetMethodCollector(requirement);
foreach (var requiredMethodDefinition in methodCollector.CreateRequiredMethodDefinitions(requirement))
{
requirement.Methods.Add(requiredMethodDefinition);
}
}
private void CheckAllRequiringEntities(RequirementDefinitionBase requirement, params MixinDefinition[] expectedRequiringMixins)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
ArgumentUtility.CheckNotNull("expectedRequiringMixins", expectedRequiringMixins);
var requiringEntityDescription = requirement.GetRequiringEntityDescription();
var requiringEntityDescriptionItems = requiringEntityDescription.Split(new[] { ", " }, StringSplitOptions.None);
foreach (var mixinDefinition in expectedRequiringMixins)
{
CheckSomeRequiringMixin(requirement, mixinDefinition);
}
Assert.That(requiringEntityDescriptionItems, Has.Length.EqualTo(expectedRequiringMixins.Length), requiringEntityDescription);
}
private IRequiredMethodDefinitionCollector GetMethodCollector(RequirementDefinitionBase requirement)
{
if (requirement.TargetClass.ImplementedInterfaces.Contains(requirement.Type))
{
return(_implementedInterfaceMethodCollector);
}
else if (requirement.TargetClass.ReceivedInterfaces.ContainsKey(requirement.Type))
{
return(_introducedInterfaceMethodCollector);
}
else
{
return(_duckTypingMethodCollector);
}
}
private DependencyDefinitionBase BuildDependency(Type type, DependencyDefinitionBase aggregator)
{
ArgumentUtility.CheckNotNull("type", type);
RequirementDefinitionBase requirement = GetRequirement(type);
if (requirement == null)
{
requirement = CreateRequirement(type);
AddRequirement(requirement);
}
DependencyDefinitionBase dependency = CreateDependency(requirement, aggregator);
requirement.RequiringDependencies.Add(dependency);
CheckForAggregate(dependency);
return(dependency);
}
private static void CheckRequiredMethods(RequirementDefinitionBase requirement, ClassDefinitionBase implementer, string memberPrefix)
{
BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
Assert.That(requirement.Methods.Count, Is.EqualTo(5));
RequiredMethodDefinition method = requirement.Methods[typeof(IMixinRequiringAllMembersRequirements).GetMethod("Method", bf)];
Assert.That(method, Is.Not.Null);
Assert.That(method.InterfaceMethod, Is.EqualTo(typeof(IMixinRequiringAllMembersRequirements).GetMethod("Method", bf)));
Assert.That(method.ImplementingMethod, Is.SameAs(implementer.Methods[implementer.Type.GetMethod(memberPrefix + "Method", bf)]));
RequiredMethodDefinition propertyGetter = requirement.Methods[typeof(IMixinRequiringAllMembersRequirements).GetMethod("get_Property", bf)];
Assert.That(propertyGetter, Is.Not.Null);
Assert.That(propertyGetter.InterfaceMethod, Is.EqualTo(typeof(IMixinRequiringAllMembersRequirements).GetMethod("get_Property", bf)));
Assert.That(propertyGetter.ImplementingMethod, Is.SameAs(implementer.Properties[implementer.Type.GetProperty(memberPrefix + "Property", bf)].GetMethod));
RequiredMethodDefinition propertySetter = requirement.Methods[typeof(IMixinRequiringAllMembersRequirements).GetMethod("set_Property", bf)];
Assert.That(propertySetter, Is.Not.Null);
Assert.That(propertySetter.InterfaceMethod, Is.EqualTo(typeof(IMixinRequiringAllMembersRequirements).GetMethod("set_Property", bf)));
Assert.That(propertySetter.ImplementingMethod, Is.SameAs(implementer.Properties[implementer.Type.GetProperty(memberPrefix + "Property", bf)].SetMethod));
RequiredMethodDefinition eventAdder = requirement.Methods[typeof(IMixinRequiringAllMembersRequirements).GetMethod("add_Event", bf)];
Assert.That(eventAdder, Is.Not.Null);
Assert.That(eventAdder.InterfaceMethod, Is.EqualTo(typeof(IMixinRequiringAllMembersRequirements).GetMethod("add_Event", bf)));
Assert.That(eventAdder.ImplementingMethod, Is.SameAs(implementer.Events[implementer.Type.GetEvent(memberPrefix + "Event", bf)].AddMethod));
RequiredMethodDefinition eventRemover = requirement.Methods[typeof(IMixinRequiringAllMembersRequirements).GetMethod("remove_Event", bf)];
Assert.That(eventRemover, Is.Not.Null);
Assert.That(eventRemover.InterfaceMethod, Is.EqualTo(typeof(IMixinRequiringAllMembersRequirements).GetMethod("remove_Event", bf)));
Assert.That(eventRemover.ImplementingMethod, Is.SameAs(implementer.Events[implementer.Type.GetEvent(memberPrefix + "Event", bf)].RemoveMethod));
}
public IEnumerable <RequiredMethodDefinition> CreateRequiredMethodDefinitions(RequirementDefinitionBase requirement)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
Assertion.IsTrue(requirement.Type.IsInterface);
InterfaceIntroductionDefinition introduction = requirement.TargetClass.ReceivedInterfaces[requirement.Type];
foreach (EventIntroductionDefinition eventIntroduction in introduction.IntroducedEvents)
{
yield return(new RequiredMethodDefinition(requirement, eventIntroduction.InterfaceMember.GetAddMethod(), eventIntroduction.ImplementingMember.AddMethod));
yield return(new RequiredMethodDefinition(requirement, eventIntroduction.InterfaceMember.GetRemoveMethod(), eventIntroduction.ImplementingMember.RemoveMethod));
}
foreach (PropertyIntroductionDefinition propertyIntroduction in introduction.IntroducedProperties)
{
var getMethod = propertyIntroduction.InterfaceMember.GetGetMethod();
if (getMethod != null)
{
yield return(new RequiredMethodDefinition(requirement, getMethod, propertyIntroduction.ImplementingMember.GetMethod));
}
var setMethod = propertyIntroduction.InterfaceMember.GetSetMethod();
if (setMethod != null)
{
yield return(new RequiredMethodDefinition(requirement, setMethod, propertyIntroduction.ImplementingMember.SetMethod));
}
}
foreach (MethodIntroductionDefinition methodIntroduction in introduction.IntroducedMethods)
{
yield return(new RequiredMethodDefinition(requirement, methodIntroduction.InterfaceMember, methodIntroduction.ImplementingMember));
}
}
protected abstract DependencyDefinitionBase CreateDependency(RequirementDefinitionBase requirement, DependencyDefinitionBase aggregator);
protected abstract void AddRequirement(RequirementDefinitionBase requirement);
protected override DependencyDefinitionBase CreateDependency(RequirementDefinitionBase requirement, DependencyDefinitionBase aggregator)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
return(new MixinDependencyDefinition((RequiredMixinTypeDefinition)requirement, _mixin, (MixinDependencyDefinition)aggregator));
}
protected override void AddRequirement(RequirementDefinitionBase requirement)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
_mixin.TargetClass.RequiredMixinTypes.Add((RequiredMixinTypeDefinition)requirement);
}
public IEnumerable <RequiredMethodDefinition> CreateRequiredMethodDefinitions(RequirementDefinitionBase requirement)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
Assertion.IsTrue(requirement.Type.IsInterface);
return(from interfaceMethod in requirement.Type.GetMethods()
let implementingMethod = FindMethod(interfaceMethod, requirement)
select new RequiredMethodDefinition(requirement, interfaceMethod, implementingMethod));
}
public static void AddRequiringDependency(RequirementDefinitionBase requirement, DependencyDefinitionBase dependency)
{
PrivateInvoke.InvokeNonPublicMethod(requirement.RequiringDependencies, "Add", dependency);
}
protected override void AddRequirement(RequirementDefinitionBase requirement)
{
_targetClass.RequiredTargetCallTypes.Add((RequiredTargetCallTypeDefinition)requirement);
}
public IEnumerable <RequiredMethodDefinition> CreateRequiredMethodDefinitions(RequirementDefinitionBase requirement)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
Assertion.IsTrue(requirement.Type.IsInterface);
Assertion.IsTrue(requirement.TargetClass == _targetClassDefinition);
Assertion.IsTrue(requirement.TargetClass.ImplementedInterfaces.Contains(requirement.Type));
InterfaceMapping interfaceMapping = _targetClassDefinition.GetAdjustedInterfaceMap(requirement.Type);
for (int i = 0; i < interfaceMapping.InterfaceMethods.Length; ++i)
{
var interfaceMethod = interfaceMapping.InterfaceMethods[i];
var implementingMethod = _allTargetClassMethods[interfaceMapping.TargetMethods[i]];
yield return(new RequiredMethodDefinition(requirement, interfaceMethod, implementingMethod));
}
}
protected override DependencyDefinitionBase CreateDependency(RequirementDefinitionBase requirement, DependencyDefinitionBase aggregator)
{
return(new ComposedInterfaceDependencyDefinition((RequiredTargetCallTypeDefinition)requirement, _composedInterface, aggregator));
}
