public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
var output = newGroup();
Predicate <MemberType> isMemberTypeDefined = mType => (definition.MemberType & mType) > 0;
output.AddMembers(input, mType => isMemberTypeDefined((MemberType)mType.Info.MemberType));
return(output);
}
public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
var output = newGroup();
var explicitMembers = definition.ExplicitMembers;
output.AddMembers(input, m => explicitMembers.Contains(m.Name));
return(output);
}
public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
var output = newGroup();
output.AddMembers(input, m =>
{
var memberDef = m.Info.GetCustomAttribute <CategoryAttribute>();
return(memberDef != null && memberDef.name == definition.FullPath);
});
return(output);
}
public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
var output = newGroup();
var returnType = definition.DataType;
if (returnType != null)
{
output.AddMembers(input, m => m.DataType.IsA(returnType));
}
return(output);
}
public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
var output = newGroup();
var pattern = definition.Pattern;
if (!pattern.IsNullOrEmpty())
{
output.AddMembers(input, member => Regex.IsMatch(member.Name, pattern));
}
return(output);
}
public MemberGroup Resolve(MemberGroup input)
{
var result = newGroup();
var comparer = new MemberComparer();
var defResolvers = groupResolvers.OfType <DefintionResolver>().ToArray();
var memResolvers = groupResolvers.Except(defResolvers);
// Takes a sequence of resolvers - have them each resolve the input
// and finally return groups of the resolved members
Func <IEnumerable <GroupResolver>, IEnumerable <List <VisibleMember> > > resolveGroupMembers =
resolvers => resolvers.Select(r => r.Resolve(input, definition))
.Where(g => !g.Members.IsEmpty())
.Select(g => g.Members);
// Solve category definition members
var defMembers = resolveGroupMembers(defResolvers).Cast <IEnumerable <VisibleMember> >().ToArray();
if (!defMembers.IsEmpty())
{
switch (definition.Grouping)
{
case SetOp.Intersection:
result.AddMembers(defMembers.Aggregate((g1, g2) => g1.Intersect(g2, comparer)));
break;
case SetOp.Union:
result.AddMembers(defMembers.UnionAll(comparer));
break;
}
}
// Solve members annotated with CategoryAttribute
resolveGroupMembers(memResolvers).Foreach(result.UnionMembers);
// Filter out excluded members
result.Members.RemoveAll(excluded.Contains);
// If this definition's members are exclusive (doesn't allow dups)
// we maintain a ref to its members to exclude them from other defs
if (definition.Exclusive)
{
excluded.AddRange(result.Members);
}
return(result);
}
public void AddMembers(MemberGroup input, Func <VisibleMember, bool> predicate)
{
input.Members.Where(predicate).Foreach(AddMember);
}
public abstract MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition);
public override MemberGroup Resolve(MemberGroup input, DefineCategoryAttribute definition)
{
this.definition = definition;
return(Resolve(input));
}
